Code for the Closet

Ganked Android Interface

2011-10-30T08:35:00.000-07:00

I have not spoken much about Ganked lately, but I have modified the library to use Boost shared pointers for memory management, Boost graph library for path finding algorithms, Boost serialization for map state, and I have created google V8 bindings to the library for use in Node.js .

I have recently started working on the Android interface to the game server. for the QuickAction bar, I used the great code provided by Lorensius in his Blog Post on QuickActions. The great RPG icons for the interface concept are coming from Ails as part of the collection you can find at Ails' Deviant Art RPG Collection.

At the moment, persistence works, you select a location and it gives you the option to change the current item or clear the existing item.

If you choose to change the item, a list of items in your inventory is presented that is appropriate for the given slot.

You are returned to the previous screen with the selected item in the appropriate slot.

Moved to Node.js

2011-10-14T08:46:00.000-07:00

It has been quiet for a long time on the game development front. It is a hobby that I do not get to spend much time with, but I have not been completely lazy! I have refined the Ganked library and created bindings for Node.js. I am currently trying to decide how to document the system in terms of a user guide. Look for more soon!

Quick Note on Partitioned Maps

2011-01-24T19:42:00.001-08:00

I wanted to add a visual dot graph of the partition space described in my previous post. I hope you enjoy!

New Phase to the Map Processing

2011-01-24T16:23:00.000-08:00

I mentioned in my previous post that I had partitioned the map to generate hallways. Next I have begun to tackle the problem of navigation. Taking a 200 x 200 map, that generates 40,000 vertices, each vertex can have an edge with an adjacent vertex. It is easy to see this problem could get big! Finding your way from point A to point B could be very expensive. The map you see above turns out to have 6776 vertices (i.e. X,Y coordinates) with 28,669 edges between those vertices. To try to reduce the problem, I have taken a common approach of creating a navigational mesh. By creating partition spaces, I can reduce the problem set dramatically. It would probably be better if my partitions were of similar size, but I have expanded them as much as I could x and y. I may take a square approach at a later time, but hallways.... "Bleh!" In the picture above, each partition has its own colour. I measure the weight of an edge between two partitions to be the distance from one partitions centre to the centre of an adjacent partition. This reduces the navigation problem to finding the best path from a point within a partition to the edge of an adjacent partition, and a path of partitions. The partition graph in the example above is only 65 vertices (partitions) with 66 edges ( shared sides between partitions). I apologize for the horrible description, but hopefully you found this interesting.

Dynamic Map Generation in Ganked

2011-01-17T11:07:00.000-08:00

I have been working on the dynamic map generation for Ganked. I have been prototyping it in python; though, the final implementation will likely live in C++. I currently have 4 phases of map generation:

Phase 1: Using a room placement strategy ( 2 strategies exist at the moment), place the rooms

Phase 2 : I create a navigation map with lines extending from the center of rooms, but terminating just before any other room it may run into. This will form the paths that hallway generation will use to create hallways in later steps.

Phase 3: Using a clustering algorithm based on distance between centers, I cluster the rooms to determine what will be connected to what. Rooms are initially turned into a cluster node and then cluster nodes are clustered into composite nodes based on distances between centers. This continues until there is only one node left in the list. In the graphic above, each clustering is outlined in its own color.

Phase 4: Using a depth first approach to the clustered nodes, begin connecting nodes to each other with a simple A* pathfinding hallway generator with all spaces blocked except those identified in phase 2 (the lines). Now we have hallways connecting all of our rooms!

In future iterations I hope to have hallway "diggers" widen out the hallways based on relationships to room sizes they connect to and potential space they have to dig in.

GankWar Lives!

2011-01-04T18:44:00.000-08:00

I have started work on GankWars again. My first approach is to revamp the C++ libraries to use boost. I have started, and am almost 80% complete. Next phase will likely be Google V8 bindings. I good friend of mine has joined in on the fun, Brian Watson. Hopefully we can make some headway.

Workflow added to CAJS

2010-05-15T18:16:00.000-07:00

CAJS has been updated on Google code hosting. Would love any peer review and input. The tests could do with, well .. more tests! Suggestions for improvements are welcome, as I am sure it can be improved in many ways.

CAJS up on Google Hosting

2010-05-01T13:07:00.000-07:00

I have cleaned up some of my code and provided it as library on Google Hosting, named: CAJS. You can find it at http://code.google.com/p/cajs/

What in the Gank(war) has been going on!

2009-12-22T07:21:00.000-08:00

Some of you may be wondering what the silence around GankWar has been. Is it dead, Is it alive... It is, in fact, alive. It has undergone a big transition. I have been working on message communication, mostly combat chat, and I ran into some performance issues. Some of the performance may be related to the fact that I am developing and testing on a cheap laptop. This caused me to do a few things:

Move to Ubuntu for development

No longer worrying with windows for compiling server code
Client still in browser, so folks can play from any machine

Administration and Data Changes

Introduced some Sqlite for the persistence of data
Moved application layer (e.g. Admin) to Django
Maintained Orbited as Comet server
Testing RabbitMQ in place of MorbidQ (which was part of Orbited)

I have recieved HUGE speedups for game world "ticks" in Linux, but I am up against two bottlenecks:

Message Serialization (to JSON), which is big, but I have not optimized the message structure itself
Message Delivery

I believe the issue here is running too much on the same machine(thought that does not appear to be it by looking at the processes resource use)
I hope that simply moving Orbited and/or the STOMP server to a different machine will make a difference, but I do not have a second machine to test from.
I am playing with different Message Queue types (MorbidQ vs RabbitMQ) to look for a difference/speedup with that change.

It is going slow, but I will try to keep you up to date!

GankWar Screen Shot

2009-11-16T17:50:00.001-08:00

The above is a screen shot of the current user interface. It uses icons designed by Ails. This will likely not change until someone with a lot more graphic design skill than myself changes it! This UI is using HTML5 Canvas with jquery behind the scenes. I don't have much to post at the moment, but I did want to provide a screen shot!

TickHandler and its Kids!

2009-11-05T20:16:00.001-08:00

As mentioned previously, the TickHandler can receive tick events from the GameObjectCollector. We previously discussed Tickhandler, but now we will cover its two direct subclasses: GameObject and PyTickHandler.

GameObject


  GameObject (GameObjectCollector *c)
  GameObject (GameObjectCollector *c, const string &grid)
  GameObject (GameObjectCollector *c, const char *rGrid)
GOComponent *  GetGOC (const char *rFamilyID)
GOComponent *  GetGOC (const string &familyID)
void  SetGOC (GOComponent *newGOC)
void  DelGOC (const char *rFamilyID)
void  DelGOC (const string &familyID)
void  ClearGOCs ()
void  SetLocation (GameMapLocation *gloc)
GameMapLocation *  GetLocation ()
Point  GetLocationPoint ()
GamePoint *  GWGetLocation ()
bool  Tick (TickPhase phase)
bool  TestProposition (char *name, bool truth, float value)
void  UpdateProposition (GameProposition &g)
void  AddProposition (GameProposition *prop)
GameProposition *  GetProposition (string &name, bool truth)
GameProposition *  GetProposition (char *name, bool truth)
float  Distance (GameObject *obj)
GameReferenceType  GetReferenceType ()

GameObject is intended to be the first concrete class to be registered with the GameObjectCollector. It could be thought as an object in the game environment. It could represent both and actor or a tree. The GameObject uses a game object component system that is very similar to what is described in Game Programming Gems: 6. The components make up the specialized behavior of varios GameObjects, and will be covered in much more detail in my next post. It is the ability to set and get these components that allow some objects, an avatar for example, to have an Artificial Intelligence, and some objects, such as a trap, to have minimal intelligence.

PyTickHandler


  PyTickHandler (PyObject *o, GameObjectCollector *c, const char *tid)
bool  Tick (TickPhase phase)

This handler is very generic, and dellegates the handling of the Tick call to whatever python object is attached to this object. This allows a great deal of extensibility, as you can allow any python object to participate in the tick events of the GameObjectCollector. An example might be a timing component, a state renderer, or simply an object that resurrects fallen avatars as their deaths are detected in the tick event cycle.

GameReference, GameObjectCollector, and TickHandler

2009-11-03T11:32:00.000-08:00

GameReference


GameReference (GameObjectCollector *c)
GameReference (GameObjectCollector *c, const string &grid)
GameReference (GameObjectCollector *c, const char *rGrid)
virtual ~GameReference ()
const string &  GetID ()
char *  GetIDRaw ()
bool  IncRef ()
bool  DecRef ()
int  RefCount ()
bool  Collectable ()
bool  Attach (PyObject *p)
bool  Collect (bool force=false)
PyObject *GetPyObject ()
GameObjectCollector *GetCollector ()
virtual GameReferenceType GetReferenceType ()

In GankWar, the GameReference is the basic class of entities in the game. GameReference provices a reference counting scheme, which allows for memory management of items in the "zone". You might ask why I bothered implementing my own refcounting mechanism? It just seemed right. I was spending a lot of time know when something was crossing the reference boundaries between c++ and python; so, I used this system to work it out. To increment the reference count, you would call IncRef(), and to decrement DecRef(). If the reference count reaches zero, the item will be marked for collection in the next cycle of the GameObjectCollector.

GameObjectCollector


GameObjectCollector (const string &tid)
GameObjectCollector (const char *tid)
~GameObjectCollector ()
void  Put (GameReference *ref)
GameReference *  Get (const string &id)
GameReference *  Get (const char *rid)
void  Collect (GameReference *ref)
void  CollectAll ()
void  PutAll ()
string  NextID ()
void  Register (TickHandler *handler, TickPhase phase)
void  UnRegister (TickHandler *handler, TickPhase phase)
void  Tick ()
void  ForEach (GameReferenceType grt, foreachgameobject_cb fn, void *user_data)

The GameObjectCollector is the heart of a zone, as it manages GameReferences. It also handles "Tick" events within the scenario. As mentioned previously, it will insert and collect GameReferences at the beginning of each Tick cycle. A Tick has three specific phases to it, pretick, tick, and posttick. These various tick events are handled by TickHandlers.

TickHandler


TickHandler (GameObjectCollector *c)
TickHandler (GameObjectCollector *c, const string &grid)
TickHandler (GameObjectCollector *c, const char *rGrid)
virtual bool  Tick (TickPhase phase)
void  StopTicking (TickPhase phase)
void  StartTicking (TickPhase phase)
bool  IsTicking (TickPhase phase)

TickHandler is a subclass of GameReference that can be registered with the GameObjectCollector to recieve Tick events for a given phase in the Tick. They server various roles and are very flexible to support behavior that needs to occur at a given Tick. And example might be a reporting component that reports on the state of the simulation at the end of every tick.

GankWar and Virtualization

2009-10-29T19:45:00.001-07:00

I have been working on making GankWar more Linux friendly, which will allow folks to work on it without requiring they have Visual Studio. With that in mind, I installed various components on Virtual Box with Ubuntu desktop version, and I got everything running.

I am still having some issues, as I can hit orbited locally on the VM and everything behaves like it should, and the Zone Runner messages are received. I can hit Orbited from outside the VM, and it appears to connect, registers for the same channel as the local STOMP client does, but does not receive the messages that the local client is receiving. I am guessing it is either in how I am sending the messages or some domain thing to channel registration... okay I don't believe that either /grin. I am chalking it up to me being an Orbited Noob, and I am rolling up my sleeves to dig deeper.

High Level GankWar System View

2009-10-27T06:07:00.001-07:00

GankWar is a simulation type game, where players will be either able to play their avatars, or allow artificial intelligence instructions, through behavior trees, to guide the actions of their players. The AI will be able to be switched on and off, but the avatar will always be present in the gaming world.

The interface will use HTML and Canvas, which makes compatibility with Internet Explorer unlikely, though not impossible. The web interface will provide something slightly more graphical than the typical roguelike, but will play much the same as one.

In order to stream events to and from the browser, a Comet server will be used, to handle the persistent connection and data pushed from the server. Data and presentation pulled from the server by the client will be handled by a standard web framework. In the prototype, my chosen Comet server, Orbited, will handle both Comet and presentation layer, but shortly into full development I see something like Django taking over the presentation layer surrounding the map.

The MapRunner is a Twisted Python STOMP client, that is running the Game Engine while communicating with the connected clients via the STOMP protocol.

More to come as I have time!

From Sleep I Rise!

2009-10-21T18:21:00.000-07:00

Well, I have not exactly been sleeping, but I have been buried under work. My blogging has not been going... period. I am going to try to fix that by turning to a project that I am doing for fun: GankWar. There is nothing new about the idea, but I will be implementing a Roguelike Multiplayer Online (Just MO... No MMO) that will enable players to write artificial intelligence to drive their persona while they are not in game. I hope this will add more diversity to the mob AI. The engine is a C++ library that has python bindings. My objective for this game is not to rock the gaming world with my brilliance, as that would be a comedy and not a game, but to hopefully learn a few things about game making, while having fun along the way.

Anyhow, I will be updating this blog periodically with code samples and such as it progresses.

I think I've Lost My Memory!

2009-03-28T06:56:00.000-07:00

I know it has been forever since I have posted, but work has been busy. I do want to share something, not ground breaking, that we have started doing to track down memory issues in our javascript applications. In my example below, I create this alien registerEventHandler function that would take an object and register for an event on it by name, taking a function and a scope.


function getClosure(arg1,arg2){
  var trkel = document.createElement("DIV");
  trkel.setAttribute("id","TRACK_getClosure" );
  registerEventHandler(arg1,"click",
     function(){ .... },this);
}

As we can see, when this function is ran, we register a function as a handler. A function which involves a closure ( function within function holds containing scope). This is not a problem, so much, if it is cleaned up, after the arg1 has seen its day. When we have a stray memory issue we will use sIEve and code like above. While the closure is alive, sIEve will show the element whose ID is "TRACK_getClosure" as not freed and orphaned. When our code behaves, the element is dereferenced and gets freed. This same approach can be used to track the life of objects, and if they get destroyed, by assigning the tracker_el instance directly too the object; so, when all references to the object are cleaned up, the element will be reclaimed.

I hope this helps you all like it has helped us!

Event Driven Construction Part 2

2008-12-18T21:12:00.000-08:00

In my previous post,Event Driven Construction , I discussed the concept of using metaclasses to provide event driven construction of singleton services. I wanted to introduce two more examples. One is a class which combines the two metaclasses from the previous post together:


class CreateAndSignal(EventSingleton,
  CreateOnSignal):
     pass

class D(object):
     __metaclass__ = CreateAndSignal
     _i_signal = "C-Created"
     _o_signal = "D-Created"

class E(object):
    __metaclass__ = CreateAndSignal
    _i_signal = "C-Created"
    _o_signal = "E-Created"

In the code above, I have created two classes of type CreateAndSignal, which construct themselves on recieving _i_signal, and upon construction throw the event _o_signal. In the example both classes await the event "C-Created"; so, lets provide that class as well, which is of type EventSingleton from the previous post.


class C(object):
    __metaclass__ = EventSingleton
    _o_signal = "C-Created"

Now with a class that does the same by tracking a few signals we can wait on multiple events.


def getOnDependancy(sig,k):
     x = lambda *args:k.onDependancy(sig)
     return x
class CreateAfterDependancies(Singleton):
     msg="[%s]CreateAfterDependancies(%s)%s"
     def __init__(cls,name,bases,dic):
        super(CreateAfterDependancies,cls).\
        __init__(name,bases,dic)
        cls._d_signal_lookup = {}
        cls._d_signals = list(cls._d_signals)
        for signal in cls._d_signals:
           rec=getOnDependancy(signal,cls)
           cls._d_signal_lookup[signal] = rec
        connectEx(rec,signal)
     def __call__(cls,*args,**kw):
        if cls.isSatisfied():
           return super(
              CreateAfterDependancies,cls).\
                 __call__(*args,**kw)
        else:
           msg = "Dependencies not met"
           raise Exception(msg)
      def isSatisfied(cls):
         return len(cls._d_signals) == 0
      def onDependancy(cls,signal):
         if signal in cls._d_signals:
            rec=cls._d_signal_lookup[signal]
      del cls._d_signal_lookup[signal]
            cls._d_signals.remove(signal)
            satisfied = (cls.isSatisfied() \
               and 1) or 0
            msg=["--%s"%repr(cls._d_signals),
               "--Creating"]
            print cls.msg%(signal,
              cls.__name__,
              msg[satisfied])
            if satisfied:
               cls()

By creating closures to functions that will remove the signal when fired and check to see if all dependencies have been met, this class allows us to create based off of more than one event, as previous classes worked.


class G(object):
   __metaclass__ = CreateAfterDependancies
   _d_signals = ["E-Created","F-Created"]

C()

The classes above create a build condition which can be visualized by:
C->D
->E -> F
And the output of:


[C]EventSingleton(C-Created)
[D]CreateOnSignal(C-Created)
[D]EventSingleton(D-Created)
[E]CreateOnSignal(C-Created)
[E]EventSingleton(E-Created)
[E-Created]CreateAfterDependancies(G)--['F-Created']

Event Driven Construction

2008-12-15T14:55:00.001-08:00

I have always had fun playing with metaclasses in python. If you are not familair with metaclasses, you may want to read about them in general here or a brief introduction to them in python. If you want the short, Mike-Webb, possibly wrong verion, then without getting in too deep, I will try to give a crash introduction to metaclasses. You can think of a metaclass as the class of a class or as a type. Objects are instances of Classes and Classes are instances of Types. __metaclass__ attribute of classes in python allow one to declare the type of that class. That may sound whacky, but what a metaclass allows you to do is change the bahvoir of class instantiation and construction, possibly doing things such as override behavior at compile time. A method defined on a type, becomes a classmethod of the class, but not of an instance of the class. This allows us to override behavior such as making the class callable, as well as overriding representation behavior, construction behavior, and initialization behavior. One metaclass I use a lot in python helps implement the singleton pattern borrowed from here.


class Singleton(type):
def __init__(cls,name,bases,dic):
   super(Singleton,cls).__init__(name,
     bases,dic)
   cls.instance=None
def __call__(cls,*args,**kw):
   if cls.instance is None:
      cls.instance=super(Singleton,cls).\
         __call__(*args,**kw)
   return cls.instance

As you can see, this class overrides the call behavior to only create a new instance if one did not already exist.

I tend to use Singleton to represent services in my projects. Something I have difficulty with often, is sometimes my services have dependencies on lower level services. No matter how I try to refactor them, I either have autonomy and services that do too much or services that depend on lower level services. As I was thinking about this issue, I started thinking more about order of instantiation and dependency. I thought it would be neat to create a set of metaclasses that helped classes define their dependency with one another based on events that must take place. The idea was that if a services threw an event which notifies that the services was created, then other service classes could register for that event, and instantiate themselves when the environment was right for them.

To make this example work, we must assume that two functions exist:

sendEx - which will send an event

connectEx - which will connect a function to handle an event

Lets look at a metaclass which will cause a class to be instantiated if a signal is recieved:


class EventSingleton(Singleton):
 """This Class needs to have an attribute
 named _o_signal that defines the signal
 that will be thrown when this class is
 created"""
 def __call__(cls,*args,**kw):
     if cls.instance is None:
         super(EventSingleton,cls).__call__\
             (*args,**kw)
         msg = "[%s]EventSingleton(%s)"%\
             (cls.__name__,cls._o_signal)
         print msg
         sendEx(cls._o_signal)
     return cls.instance

In the above metaclass, a class defined an attribute named _o_signal that identifies the event the class should throw when it is instantiated for the first time.
Now lets look at a metaclass that will create a class after a signal has been received for the first time.


class CreateOnSignal(Singleton):
 """This Class needs to have an attribute
 named _i_signal that defines the signal
 that will create the class"""
 def __init__(cls,name,bases,dic):
    super(CreateOnSignal,cls).__init__(
    name,bases,dic)
    #set a flag that indicates if we have
    #been signaled
    cls.signaled = False
    connectEx(cls.onCreateEvent,
         cls._i_signal)
 def __call__(cls,*args,**kw):
     if not cls.signaled:
         exc ="Signal not raised!"
         raise Exception(exc)
     return super(CreateOnSignal,cls).\
         __call__(*args,**kw)
 def onCreateEvent(cls):
     msg = "[%s]CreateOnSignal(%s)"%\
         (cls.__name__,cls._i_signal)
     print msg
     cls.signaled=True
     cls()

Now lets write a class that throws a signal and one that waits on it!


class A(object):
 __metaclass__ = EventSingleton
 _o_signal = "A-Created"

class B(object):
 __metaclass__ = CreateOnSignal
 _i_signal = "A-Created"

>>> A()
[A]EventSingleton(A-Created)
[B]CreateOnSignal(A-Created)

In part 2 I will show more on the idea of dependencies and multiple dependencies, but let me leave you with a sendEx and connectEx function that will allow you to play with this code:


def makeConnectAndSend():
 registry = {}
 def cE(fn,msg):
     fl = registry.setdefault(msg,[])
     fl.append(fn)
 def sE(msg):
     fl = registry.setdefault(msg,[])
     for fn in fl:
         fn()
 return cE,sE

connectEx,sendEx = makeConnectAndSend()

Visitor Pattern for Unification via JavaScript

2008-12-12T12:50:00.000-08:00

One of the libraries that the company I work for has written, is one that implements unification. As I was thinking about my last post on the Visitor Pattern for JavaScript, I thought about how the pattern could be applied to unification. Using the same accept functions from the previous post, I fooled around, creating a visitor that could handle unification. One of the things I wanted to provide for was partial unification; so, I could use a few attributes of an object, like a query does.


/**
* @module UnificationVisitor
*/

/**
* A class implementing a variation of the
* visitor pattern, which performs unifying
* operations on datastructures
* @class unifyVisitor
* @constructor
* @param {object} config configuration object
*/
var unifyVisitor = function(config){
  /**
  *@config functions
  *@description indicate if functions should
  *be traversed
  *@type boolean
  */
  config.functions = config.functions ||
      false;
  /**
  *@config partial
  *@description indicate if a unification can
  *occure when all attributes #present#
  *match even if they are not all present
  *@type boolean
  */
  config.partial = config.partial || false;
  this.config = config;
};
/**
* Create a new token for carrying
* around state
* @method newToken
* @return Object an object to hold
* the state of the call.  It is used
* as a dictionary for lugging around
* more state.
*/
unifyVisitor.prototype.newToken = function(){
  var obj = {};
  //Copy config onto the token
  for(var key in this.config){
      var val = this[key];
      if(this.config.hasOwnProperty(key) &&
        typeof(val)!=="function"){
          obj[key]=val;
      }
  }
  return obj;
};
/**
* Attempts to visit an object
* @method dispatchVisit
* @param {Unknown} visitee the value
* currently being visited
* @param {Object} token an object to hold
* additional info the visitor may need
*/
unifyVisitor.prototype.dispatchVisit =
function(a,b,token){
  /*Create a token if this is the first call
  * and a token is not provided*/
  if(!token){
      token = this.newToken();
  }
  /*if the first value is of no value,
  * give the other value an opportunity
  * to match*/
  if(a==null || a==undefined){
      /*if both are null then they
      * are unified*/
      if(a===b){
          token.result = true;
          return true;
      }
      /*final being true represents a
      * match being performed on right
      * operand of the match*/
      if(!token.final){
          token.final = true;
          /* call dispatchVisit instead
          * of accept as b may be null
          * or undefined*/
          return this.dispatchVisit(b,
              a,token);
      }
      return false;
  }
  /*Everything else should have an accept
  * function*/
  else{
      a.accept(this,b,token);
      return true;
  }
};
/**
* Registers a handler for the
* visitation of a named item
* @method addVisitHandler
* @param {String} name the name of the
* item this handler visits
* @param {Function} handler the function
* handling the visitation
*/
unifyVisitor.addVisitHandler = function( name,
handler ){
  unifyVisitor.prototype["visit"+name] =
      handler;
};
/**
* Default visitor method
* @class VisitorHandlersCollection
* @method visitDefault
* @param {Unknown} visitee the value
* currently being visited
* @param {ArrayLike} args an array-like
* object that holds the values passed
* to the originating accept function
*/
var visitDefault = function(item,args){
  var other = args[1];
  var token = args[2];
  //test equality
  if(item == other){
      token.result = true;
  }
  //if not final let right side try
  else if(!token.final){
      token.final = true;
      if(!this.dispatchVisit(
          other,item,token)){
            token.result = false;
      }
  }
  /*we are teh right side and none
  * matched*/
  else{
      token.result = false;
  }
};
//need to deal with null and undefined values
unifyVisitor.addVisitHandler("String",
  visitDefault);
unifyVisitor.addVisitHandler("Number",
  visitDefault);
unifyVisitor.addVisitHandler("Function",
  visitDefault);
/**
* Handles the visitation of objects
* Not sure how to define non-method
* functions in YUI Doc
* @method visitObject
* @param {Object} item the object
* currently being visited
* @param {ArrayLike} args an array-like
* object that holds the values passed
* to the originating accept function
*/
var visitObject = function( item, args){
  var other = args[1];
  var token = args[2];
  var a_match = false;
  if(!token.final){
      /*I am not the right side so
      * let the right go first!*/
      token.final = true;
      /*If we fail to dispatch
      * set failure as object wont
      * match null or undefined*/
      if(!this.dispatchVisit(
          other,item,token)){
            token.result = false;
            return;
      }
  }
  /*If it is partial, give us a chance
  * to match something in the other object*/
  if(token.result === false &&
      !token.partial){
        return;
  }
  var key;
  var result = true;
  //iterate keys
  for(key in item){
      var value = item[key];
      /*skip functions if config.functions
      * is false*/
      if(item.hasOwnProperty(key) &&
          (!token.functions ||
          typeof(value)!="function")){
            var oval = other[key];
          /*If key is undefined in other and
          * config.partial was false,
          *fail out*/
          if(oval==undefined &&
              !token.partial){
                result = false;
                break;
          }
          var new_token = this.newToken();
          new_token.result = false;
          /*try to unify the values*/
          this.dispatchVisit(value,oval,
              new_token);
          /*capture if we got a match*/
          if(new_token.result){
              a_match = true;
          }
          /*match failed, so if not
          * partial, fail out*/
          else if(!token.partial){
              result = false;
              break;
          }
      }
  }
  /* Other side could have declared
  * a match, if not, see if this
  * obj did*/
  if(!token.result){
      if(result == false){
          token.result = false;
      }
      else if(result==true){
          /*if we matched any we must
          * be matched*/
          if(a_match){
              token.result = true;
          }
          else{
              token.result = false;
          }
      }
  }                           
};
unifyVisitor.addVisitHandler("Object",
  visitObject);
/**
* Handles the visitation of arrays
* @method visitArray
* @param {Array} item the array
* currently being visited
* @param {ArrayLike} args an array-like
* object that holds the values passed
* to the originating accept function
*/
var visitArray = function( item, args){
  var other = args[1];
  var token = args[2];
  if(!token.final){
      /*I am not the right side so
      * let the right go first!*/
      token.final = true;
   
if(!this.dispatchVisit(other,item,token)){
          token.result = false;
      }
  }
  else{
      /*lengths must match for a match*/
      if(item.length != other.length){
          token.result = false;
      }
      else{
          /*assume a match*/
          token.result = true;
          for(var i=0;i<item.length;i++){
              var value = item[i];
              var oval = other[i];
              var new_token =
                  this.newToken();
              new_token.result = false;
              /*unify values*/
              this.dispatchVisit(value,
                  oval,new_token);
              /*if unify fails, fail out*/
              if(!new_token.result){
                  token.result = false;
                  break;
              }
          }
      }
  }                         
};
unifyVisitor.addVisitHandler("Array",
  visitArray);

The above provides a way to unify the base types, but to provide a bit more utility, we will introduce the idea of a variable. In order to customize a visit experience, an object need only to implement the accept function, and possibly register its own handler, which is exactly what we will do for Variables:


/**
* Unifies with anything storing the
* matched object as its value
* @class Variable
* @constructor
*/
var Variable = function(){
  this.value = undefined;
};
/**
* Gets the value of the Variable
* @method getValue
* @return {object} the matched value
*/
Variable.prototype.getValue = function(){
  return this.value;
};
/**
* Sets the value of the Variable
* @method setValue
* @param {object} the value
*/
Variable.prototype.setValue = function(val){
  this.value = val;
};
/**
* Accepts the visitor
* @method accept
* @param {Visitor} the visitor
* @param {...} variable number of args passed
* along to the visitVariable fuction
*/
Variable.prototype.accept = function(){
  var visitor = arguments[0];
  visitor.visitVariable(this,arguments);
};
/**
* Handles the visitation of arrays
* @method visitArray
* @for VisitorHandlersCollection
* @param {Array} item the array
* currently being visited
* @param {ArrayLike} args an array-like
* object that holds the values passed
* to the originating accept function
*/
var visitVariable = function( item, args){
  var other = args[1];
  var token = args[2];
  token.result = true;
  /*store the matched value*/
  item.setValue(other);
};
unifyVisitor.addVisitHandler("Variable",
  visitVariable);

If you look at the visitVariable function, you can see that all the variable is doing is saving a reference to the value it is being unified with and setting token.result to true to indicate a unification has occurred. Below is an example of how this simple unification could work. In this example the variable will have a value of 13, as the c attribute is unified:


//exclude functions
var v = new unifyVisitor({functions:false});
var vari = new Variable();
var o1 = {a:11,b:12,c:13};
var o2 = {a:11,b:12,c:vari};
var t = v.newToken();
//try to unify
v.dispatchVisit(o3,o4,t);
//did they unify?
if(t.result){
  alert("Val is "+vari.getValue());
}

A more complex example of overriding accept can be seen in matching an entire object base on partial results. Unlike the variable example, the entire object partially matched will be saved. In this example we did not need to create a visitorHandler, because the conditions argument is being used in place of the MatchObject to partial match against the object trying to unifty with the MatchObject:


/**
* Unifies with value that matches
* conditions at least partially
* @class MatchObject
* @constructor
* @param {object} conditions the object which
* must be partially matched
*/
var MatchObject = function(conditions){
  this.value = undefined;
  this.conditios = conditions;
};
/**
* Accepts the visitor
* @method accept
* @param {Visitor} the visitor
* @param {object} other the object to match
* @param {object} token the object holding
* additional call state
* along to the visitVariable fuction
*/
MatchObject.prototype.accept = function(visitor
  ,other,token){
    var partial = token.partial;
    token.partial = true;
    /*try the match on conditions*/
    visitor.visitObject(this.conditios,
      arguments);
    token.partial = partial;
    if(token.result){
      this.setValue(other);
    }
};
/**
* Gets the value of the MatchObject
* @method getValue
* @return {object} the matched value
*/
MatchObject.prototype.getValue = function(){
  return this.value;
};
/**
* Sets the value of the MatchObject
* @method setValue
* @param {object} the value
*/
MatchObject.prototype.setValue = function(val){
  this.value = val;
};

And example using it:


//Example data
var data = [ {x:11,y:10},
             {x:3,y:14},
             {x:12,y:34},
             {x:11,y:3},
             {x:0,y:0}];
/*A function that will iterate the
* data and try to match, returning
* a list of all matched object,
* like a query*/
var iterArray = function(mo,arry,viz){
    var result = [];
    for(var i=0;i<arry.length;i++){
        var t = v.newToken();
        //try to unify
        v.dispatchVisit(arry[i],mo,t);
        //if unify add to result list
        if(t.result){
            result.push(mo.getValue());
        }
    }
    return result;
};
var v = new unifyVisitor({final:false});
var mo = new MatchObject({x:11});
var itemz = iterArray(mo,data,v);

As you would guess the value in itemz is:


[Object x=11 y=10, Object x=11 y=3]

Visitor Pattern for JavaScript

2008-12-11T10:17:00.000-08:00

I find myself using some variation of the visitor pattern often in my JavaScript for things varying from validation of data structures to serialization/de-serialization of UI state. It has an exaulted spot in my pattern toolbox! The basics to the pattern is that classes have an accept function that takes a visitor. In turn, that accept function will call the proper visit function on the visitor, passing itself in as an argument. The visit function is described as using double dispatch to get the right object to the right handler, but to get around this in JavaScript without using conditional statements, I like to name my visit functions after the object it will be visiting. An example would be visitString for a visitor function that handles visiting strings. I find with the visitor pattern it is much easier to understand by jumping in with both feet! I am trying out the YUI Doc with this code; so, it may explain the structure of the comments. In the following code I have created accept functions for some of the built-in types of JavaScript:


Function.prototype.accept = function(){
var visitor = arguments[0];
visitor.visitFunction(this,arguments);
};
Object.prototype.accept = function(){
var visitor = arguments[0];
visitor.visitObject(this,arguments);
};
String.prototype.accept = function(){
var visitor = arguments[0];
visitor.visitString(this,arguments);
};
Array.prototype.accept = function(){
var visitor = arguments[0];
visitor.visitArray(this,arguments);
};
Number.prototype.accept = function(){
var visitor = arguments[0];
visitor.visitNumber(this,arguments);
};

I like to include arguments with my visit functions. This is not necessary, as you could have all state managed by the visitor function, but as you will see later, I like to allow registration of visitor handlers that can extend the function of the visitor without changing too much about what the visitor has to know. You may find it cleaner to keep the visit functions pure, by only calling them with this, such as:


Number.prototype.accept = function(visitor){
visitor.visitNumber(this);
};

Now that you see the accept functions, I will create a visitor that will use them and will generate an XML representation of these basic JavaScript types.


/**
* @module XMLVisitor
*/

/**
* A class implementing a variation of the
* visitor pattern, which transforms js
* objects into xml
* @class xmlVisitor
* @constructor
*/
var xmlVisitor = function(){
this.reset();
};
/**
* Resets the current instance in
* preperation for visiting a new
* root object
* @method reset
*/
xmlVisitor.prototype.reset = function(){
var obj = {};
obj.xml = [];
obj.indent = "";
obj.depth = 0;
this.token = obj;
};
/**
* Create a new token for carrying
* around state
* @method newToken
* @return Object an object to hold
* the state of the call
*/
xmlVisitor.prototype.newToken = function(){
return this.token;
};
/**
* Returns the XML generated
* from the most recent visit(s)
* conducted by the visitor
* @method toXML
* @return String the xml string
*/
xmlVisitor.prototype.toXML = function(){
return this.token.xml.join("\n");
};
/**
* Attempts to visit an object
* @method dispatchVisit
* @param {Unknown} visitee the value
* currently being visited
* @param {Object} token an object to hold
* additional info the visitor may need
*/
xmlVisitor.prototype.dispatchVisit =
function(visitee,token){
/* Get a new token for handling
* state*/
if(!token){
   token = this.newToken();
}
//Hanlde null
if(visitee==null){
   var
   token.xml.push(token.indent+
      "<atomic type='null'/>");
}
else{
   visitee.accept(this,token);
}
};
/**
* Registers a handler for the
* visitation of a named item
* @method addVisitHandler
* @param {String} name the name of the
* item this handler visits
* @param {Function} handler the function
* handling the visitation
*/
xmlVisitor.addVisitHandler = function( name,
   handler ){
xmlVisitor.prototype["visit"+name] =
   handler;
};
/**
* Default visitor method
* @class VisitorHandlersCollection
* @static
* @param {Unknown} visitee the value
* currently being visited
* @param {ArrayLike} args an array-like
* object that holds the values passed
* to the originating accept function
*/
var visitDefault = function(visitee,args){
   var token = args[1];
   //push an xml representation on the list
   var ttype = "Unknown";
   if(visitee.constructor==String){
       ttype = "String";
   }
   else if(visitee.constructor==Number){
      ttype = "Number";
   }
   token.xml.push(token.indent+
      "<atomic type='"+ttype+
      "'value='"+visitee+"'/>");
};

/**
* Handles the visitation of objects
* Not sure how to define non-method
* functions in YUI Doc
* @static
* @param {Object} item the object
* currently being visited
* @param {ArrayLike} args an array-like
* object that holds the values passed
* to the originating accept function
*/
var visitObject = function( item, args){
var token = args[1];
var indent = token.indent;
//push opening tag
token.xml.push(indent+"<Object>");
token.indent = indent+"      ";
var keyindent = indent+"   ";
//cal accept on children
for(var key in item){
   var value = item[key];
   if(item.hasOwnProperty(key) &&
       typeof(value)!="function")
   {
       //push on key tag
       token.xml.push(keyindent+
           "<attribute "+
           "name='"+key+"'>");
       //push on value
       this.dispatchVisit(value,token);
       token.xml.push(keyindent+
           "</attribute>");
   }
}
token.indent = indent;
token.xml.push(indent+"</Object>");    
         
};
/**
* Handles the visitation of arrays
* @static
* @param {Array} item the array
* currently being visited
* @param {ArrayLike} args an array-like
* object that holds the values passed
* to the originating accept function
*/
var visitArray = function( item, args){
var token = args[1];
var indent = token.indent;
token.xml.push(indent+"<Array>");
token.indent = indent+"   ";
for(var i=0;i<item.length;i++){
   var value = item[i];
   this.dispatchVisit(value,token);
}
token.indent = indent;
token.xml.push(indent+"</Array>");     
        
};

//register Handlers
xmlVisitor.addVisitHandler("String",
visitDefault);
xmlVisitor.addVisitHandler("Number",
visitDefault);
xmlVisitor.addVisitHandler("Function",
function(){});
xmlVisitor.addVisitHandler("Object",
visitObject);
xmlVisitor.addVisitHandler("Array",visitArray);

With the code above we can run the following test:


var v = new xmlVisitor();
var val = [1,2,"three",
{'value':4,'str':'four'}];
v.dispatchVisit(val);
v.toXML();

The output of the last function call would be:


<Array>
<atomic type='Number' value='1'/>
<atomic type='Number' value='2'/>
<atomic type='String' value='three'/>
<Object>
 <attribute name='value'>
   <atomic type='Number' value='4'/>
 </attribute>
 <attribute name='str'>
   <atomic type='String' value='four'/>
 </attribute>
</Object>
</Array>

I hope this was a useful example of the Visitor pattern. You may have noticed that to accommodate custom classes, all one would need to do is implement the accept function in that class to override what visit function would be called. Also new functions could be registered by calling the addVisitHandler method. If you know of other examples of visitor pattern in the JavaScript wild, please drop me a comment.

Inversion-of-Control: Dependency Injection with JavaScript Part 2

2008-12-09T10:19:00.000-08:00

When writing about Inversion of Control in my post Inversion-of-Control: Dependency Injection with JavaScript, I had touched upon the idea of mutators. I did not provide an example; so, I wanted to rectify that problem. To tie in the idea of Adaptation, I will also be using the code from my post Adaptation: Adapter Design Pattern and JavaScript. If you have not read those posts, it might be worth the time to browse through them or print out the code to use as a reference.


/* Adapter : Mutator function
* returns a function that will adapt
* a value passed into the resulting
* function to the interface required
* through iFace
* iFace - the interface to adapt to*/
var Adapter = function(iFace){
   return function(o){
       return AdapterRegistry.Adapt(o,iFace);
   };
}

/* Create adapter from IAnotherConsole
* to IConsole*/
var IAnotherConsole2IConsole = function(o){
   return {
       WriteLine : o.AlertIt
   };
};

//Register the adapter
AdapterRegistry.Add(IAnotherConsole,
    IConsole,IAnotherConsole2IConsole);

/* Register AnotherConsole from the Adapter
* post, whose interface is IAnotherConsole*/
Features.Provide("Console",AnotherConsole);

var GreeterClass = function(name){
   /* The salutation feature was defined
    * in the IoC post*/
   this.salutation = name+","+
      RequiredFeature("Salutation",
           IsTypeOf("string"));
   this.con = RequiredFeature("Console",
          NoAssertion,Adapter(IConsole));
}
GreeterClass.prototype.greet = function(){
   this.con.WriteLine(this.salutation);
}

As you can see from the above code, the con attribute of GreeterClasss is provided by AnotherConsole. AnotherConsole implements the IAnotherConsole interface, while GreeterClass expects a IConsole interface. To Achieve this, we pass in the Adapt mutator, which will return an object of the IConsole interface using the AdapterRegistry.

From looking at the code above, you might have noticed that I used NoAssertion, an always-true assertion. To enforce the IConsole interface, I could have used the DoesImplement function from the Adapter post. With that function we could enforce the interface through the required feature as below:


   this.con = RequiredFeature("Console",
          DoesImplement(IConsole),Adapter(IConsole));

Signals and Slots for JavaScript

2008-12-09T08:14:00.001-08:00

Qt implements a message decoupling approach called Signals and Slots (S&S). I am not very familiar with S&S, but the idea sounded interesting, and I wanted to see what it would look like in JavaScript. As far as I could determine from here, the S&S approach registers a receiver and its function (slot) to a sender and a method (signal). The Signal has no real implementation on the programmer's side, except in defining a name as a signal. Using the convertArguments function from Inversion-of-Control: Dependency Injection with JavaScript, I implemented Signals with a factory function, Signal, and created a connect function to align them with slots.


/* Signal : Factory Function
* Returns a function that has methods
* for connecting and disconnecting functions
* from it.
* When the function is invoked, the invocation
* is dispatched to each of the registered
* functions
* stateful - if the calling scope should be
*    passed on to
*    underlying dispatches. */
var Signal = function (stateful){
   var slots = [];
   /* _signal : Proxy Function
    * acts as a multicast proxy to the
    * functions connected to it,
    * passing along the arguments it was
    * invoked with */  
   var _signal = function()
   {
       var arglist = [];
       if(stateful)
           arglist.push(this);
       convertArguments(arguments,0,arglist);
       for(var j=0;j<slots.length;j++){
           var obj = slots[j][0];
           if(obj==undefined)
               obj = this;
           var fun = slots[j][1];
           try{
               fun.apply(obj,arglist);
           }catch(e){}
       }
   }
   /* _signal.connect: Function
   * Connects a function and the scope to be
   * called when the signal is invoked.
   * fun - The function to be invoked on
   *    signal.
   * obj - The scope
   */
   _signal.connect = function(fun,scope)
   {
       slots.push( [scope,fun] );
   }
   /*  _signal.disconnect: Function
   * Disconnects a matching function from a
   * signal.
   * fun - The function to be removed.
   * obj - The scope
   */
   _signal.disconnect = function(fun,scope)
   {
       var shift=false;
       for(var i=0; i<slots.length;i++){
           if(shift)
               slots[i-1]=slots[i];
           else if(scope==slots[i][0] &&
    fun==slots[i][1])shift=true;
       }
       if(shift)
           slots.pop();
   }
   _signal.disconnect_all = function()
   {
       var slen = slots.length;
       for(var i=0;i<slen;i++)
       {
           slots.pop();
       }
   }
   return _signal;
};
/* Connect : Helper function
* connects a sender to a reciever
* through a signal and slot
* sender - the object which will send
*      the signal.
* signal - string name representing
*      the signal
* rec - object to recieve the
*      signal notification.
* slot - a string that will be used
*      to look up the same named attr
*      on rec, which should be a
*      function.  The function gets
*      the arguments passed to the
*      signal.  If stateful, the
*      first argument will be the
*      scope of the connect call.*/
var Connect = function(sender,signal,
       rec,slot){
   var sigf;
   var err = null;
   if(sender[signal]==undefined){
       sigf = Signal(true);
       sender[signal] = sigf;
   }else{
       if(!sender[signal].connect){
           err="No Signal "+signal;
           throw new Error(err);
       }
       else{
           sigf = sender[signal];
       }
   }
   var slot_type = typeof(slot);
   var rec_type = typeof(rec);
   if(rec){
       var slotf = rec[slot];
       if(typeof(slotf)=="function"){
           sigf.connect(slotf,rec);
           return;
       }
   }
   err = "Bad Slot";
   throw new Error(err);
};

Using an example from the Qt website, we can see how this would be used in javascript compared to how it is used in C++.


var Foo = function(){
   this.val = null;
}
Foo.prototype.value = function(){
    return this.val;
}
Foo.prototype.setValue = function(value){
    if(this.val!=value){
        this.val = value;
        this.valueChanged(value);
    }
}
Foo.prototype.valueChanged = Signal(false);

var a = new Foo();
var b = new Foo();
Connect(a,"valueChanged",b,"setValue");
a.setValue(45);
alert(a.value()==b.value());

I did not implement a disconnect helper function, but since the signal supports disconnect, it should be trivial to introduce one. I did add create a signal within the Connect helper if one did not exist, and made the signal stateful, meaning the calling context of the signal would be inserted at index 0 into the arguments passed along to the slots. This could be a way to use this approach with objects that were constructed in another framework, for instance.

Python Namespaces

2008-12-08T11:08:00.000-08:00

Thomas Herchenröder, wrote a cool approach to using namespaces in python, Name spaces in Python using __getattr__. He covers the existing methods in Python for namespacing, such as modules/packages. I am not sure how or where I would use Namespaces, but it tickled my python-bone. I played with the idea and hacked in a way to share namespaces across modules. The code below has not been tested, much /grin. I recommend you reading the original post by Thomas. This is me foolin around!


import threading
reg_lock = threading.RLock()

class NameSpace(object):
#for multithreading
registry = {}
def __new__(typ, ns_name, *args, **kw):
   reg_lock.acquire()
   last_obj = typ.registry.get(ns_name)
   if last_obj==None:
       namelist = ns_name.split(".")
       cnl = []         
       registry = typ.registry
       for name in namelist:
           cnl.append(name)
           current_name = ".".join(cnl)
           obj = registry.get(name)
           if obj==None:
               obj = object.__new__(typ)
               registry[current_name]=obj
               obj.__ns__ = current_name
               if last_obj:
                   setattr(last_obj,name,obj)
           last_obj = obj
   reg_lock.release()
   return last_obj
def __getattribute__(self,name):
   reg_lock.acquire()
   try:
       p = object.__getattribute__(self,name)
   except:
       p = NameSpace("%s.%s"%(self.__ns__,name))
   reg_lock.release()
   return p

cool_example = NameSpace("cool.example")
cool = NameSpace("cool")
cool_example2 = cool.example
print cool_example == cool_example2

Inversion-of-Control: Dependency Injection with JavaScript

2008-12-05T07:45:00.000-08:00

A few weeks ago I found a nifty python implementation of Inversion of Control, called Dependency Injection The Python Way, and I thought it would be interesting to do something similar for JavaScript. The code below is a translation of that implementation. I have added the addition of a mutator to the RequiredFeature, as I cannot resist fooling around. It might be best to remove that, as it makes the function carry on extra duties. I will leave it in, as I have fun with it. I will leave the mutator subject with defining a mutator as a function that will be called with the resulting feature and having its return value assigned as the feature, giving the function the opportunity to mutate the result. This post will not cover mutators.


/* convertArguments : Utility Function
 * copies array A starting at index i
 * into existing array R, or new R if undefined */
var convertArguments = function(A,i,R){
    if(R==undefined){
        R = [];
    }
    for(;i<A.length;i++){
        R.push(A[i]);
    }
    return R;
}

/* FeatureBroker : Factory Function
 * Factory for a feature broker that provides 
 * methods to register and lookup a provider
 * allowReplace - bool indicating if features 
 * can be overwrote by providers registering 
 * to provide the same feature */
FeatureBroker = function(allowReplace){
    var providers = {};
    return {
        /* Provide: Method of FeatureBroker
         * Function to register a feature 
         * provider.
         * feature - a string representing the 
         * feature being provided
         * provider - the function which will 
         *        provide the feature or
         *        a value representing the 
         *        feature
         * scope - the scope in which to call 
         *        the providing function
         * ... - any additional arguments get 
         *       passed as arguments
         *       to the provider function */
        Provide : function(feature, provider, 
            scope){
            if(!self.allowReplace && 
                providers[feature]!=undefined){
                throw new 
                   Error("Duplicate: "+feature);
            }
            var call;
            if(typeof(provider)=="function"){
                var args = convertArguments(
                           arguments,3);
                /* call : Closure of Provide
                 * Invokes the callable provider
                 */
                call = function(){
                    return provider.apply(
                                scope,args);
                }
            }else{
                /* call : Closure of Provide
                 * returns the value of provider
                 */
                call = function(){
                    return provider;
                }
            }
            providers[feature] = call;
        },
        /* Lookup: Method of FeatureBroker
         * Function to lookup a feature 
         * provider.
         * feature - a string representing the
         * feature being provided*/
        Lookup : function(feature){
            var provider = providers[feature];
            if(provider!=undefined){
                return provider();
            }else{
                throw new 
                   Error("Unknown:"+feature);
            }
        }
    };
}

var Features = FeatureBroker(false);

//No-Op functions
var NoMutation = function(o){ return o; }
var NoAssertion = function(o){ return true; }

/* RequiredFeature : Factory Function
 * feature - a string representing the feature 
 *          being required
 * assertion - a function acting as a constraint
 *          to test the result of the provided 
 *          result
 * mutator - a function that mutates a provided
 *          feature */
var RequiredFeature = function(feature,
                       assertion,mutator){
    assertion = assertion || NoAssertion;
    mutator = mutator || NoMutation;
    var value = Features.Lookup(feature);
    if(!assertion(value)){
        throw new 
              Error(feature+" fails criteria");
    }
    return mutator(value);
}

Now to define an example assertion:


/* IsTypeOf : Factory that returns an Example
 * Assertion Function
 * Tests the typeof call on the value
 * type_str - string representation of the type 
 *                    (e.g. "string")
 */
var IsTypeOf = function(type_str){
    /* Anonymous Function
     * Tests the typeof call on the value
     * o - feature result being tested */
    return function(o){
        return typeof(o)==type_str;
    }
};

Using this code provides a way to design components without assuming too much about what tools they use to perform the duties of the component, such as a CSS selector implementation. An example of this:


//Define the providers somewhere in your glue code
//Set the Application Node Feature
Features.Provide("ApplicationNode","#appNode");
//Register Sizzle to provide CSS selection
Features.Provide("CSS_Selector",Sizzle);


/*Create something that uses the Features in
 * later code */
var AppHelper = function(){
    this.selectionString = 
         RequiredFeature("ApplicationNode",
                       IsTypeOf("string"));
    this.selectionFunction = 
         RequiredFeature("CSS_Selector",
                       IsTypeOf("function"));
}
AppHelper.prototype.selectApp = function(){
    return 
       this.selectionFunction(this.selectionString)[0];
};

//use the class
var helper = new AppHelper();
var appNode = helper.selectApp();

Adaptation: Adapter Design Pattern and JavaScript

2008-12-05T06:26:00.000-08:00

Adaptation is something I find interesting as a tool to decouple your own code. It can also be used to bring differing libraries and frameworks together in your glue code. Below is an implementation of an Adapter Registry that allows functions performing adaptation to register for interfaces which they adapt from and to. The implementation of the interface code is from that discussed in Pro JavaScript Design Patterns, in chapter two. The code samples are downloadable from the books link. In the DoesImplement function, below, the Interface.ensureImplements is implemented in the chapter two code.


var DoesImplement = function(obj,iFace){
  try{
      Interface.ensureImplements(obj, iFace);
      return true;
  }catch(ex){
      return false;
  }
};

/* AdapterRegistry : Singleton
* Provides facilities for registering
* and looking up adapters */
var AdapterRegistry = (function(){
  var registry = [];//private
  return {
      /* Add : Method of AdapterRegistry
       * Provides facilities for registering
       * an adaptation
       * from_ - the Interface being adapted
       * to_ - the Interface of the adaptation
       * adapter - the function that performs
       *  the adaptation
       */
      Add : function(from_,to_,adapter){
          registry.push( { 'from_' : from_,
                           'to_' : to_,
                           'adapter' : adapter
                       } );
      },
      /* Adapt : Method of AdapterRegistry
       * Adapts an object to a given interface
       * obj - the object being adapted
       * to_ - the Interface the object should
       * adapt to
       */
      Adapt : function(obj,to_){
          if(DoesImplement(obj,to_)){
              return obj;
          }
          for(var i=0;i<registry.length;i++){
              var entry = registry[i];
              if(to_==entry.to_){
                  if(DoesImplement(obj,
                              entry.from_)){
                     return entry.adapter(obj);
                  }
              }
          }
          throw new
               Error("No Adaptation Found");
      }
  }
}());

Using the Interface implementation from Pro JavaScript Design Patterns, we can see an example of adaptation of a simple class:


/* Example Interface */
var IConsole = new Interface("IConsole",
      ["WriteLine"]);
/* Example Interface */
var IAnotherConsole = new Interface(
      "IAnotherConsole", ["AlertIt"]);

//Impliments IAnotherConsole
var aConsole = { 
     AlertIt: function(val){ 
          alert(val); 
     } };

var adaptIAnotherConsoleToIConsole = function(o){
    return {
        WriteLine : o.AlertIt
    };
};

//Register the adapter
AdapterRegistry.Add(IAnotherConsole,
      IConsole,adaptIAnotherConsoleToIConsole);
//Use the adapter
AdapterRegistry.Adapt(aConsole,
      IConsole).WriteLine("Hey!");

As you can see in the example, without recreating the wheel, you can provide glue between different interfaces/libraries/frameworks using an approach like this one.