Figure 1: A partial definition of the proxy template

typedef int Handle;
     
template<class T> class dynamic {
     
private:
     
    // the actual object, its version information and its
    // class handle
    T *object;
    DynamicVersion *dvPtr;
    Handle classHandle;
     
public:
     
    // constructors, etc.
    dynamic(Handle handle);
    dynamic(const dynamic<T>& proxy);
    ~dynamic();
    dynamic<T>& operator= (const dynamic<T>& proxy);
     
    // smart pointer
    T *operator-> (void) throw(...);
     
    // activate a version
    static Handle 
    activate (const char *libraryName,
        const char *className = NULL) throw(...);
     
    // invalidate a version
    static void 
    invalidate (const char *libraryName, 
       Handle handle) throw(...);
     
    // activate and invalidate
    static Handle 
    activate_and_invalidate (const char *libraryName,
        const char *className = NULL) throw(...);
     
  private:
     
    // static data (shared by all versions and classes 
    // implementing the interface <T>)
    // 1. map: class name to class handle 
    static Hash handleMap;
    // 2. map: class handle to active class version - 
    //         grows/shrinks in actual implementation 
    static DynamicVersion *activeMap[NUM_HANDLES];
    // ... more ...
};