PhxDescription.h

Go to the documentation of this file.

#ifndef PHX_DESCRIPTION_H
#define PHX_DESCRIPTION_H

#include <Phx/PhxConfig.h>
#include <Phx/PhxTypes.h>

#include <Phx/Util/PhxBitVector.h>
#include <Phx/Util/PhxListeners.h>

namespace Phx {

  class Description : public LockedPtrInterface<Description> {
    class TypeClass;
  public:
    class Manager;

    typedef ValueType<TypeClass, uint32_t>  Type;

    const static Type INVALID_TYPE;

    virtual BitVector serializedData(void) const = 0;

    virtual void serializedData(const BitVector& serializedData) = 0;

    // virtual XMLNode xmlData(void) = 0;
    // virtual void xmlData(const XMLNode& xmlNode) =0;

    Type type() const { return mType; }

    // virtual destructor
    virtual ~Description() {}

  protected:
    Description() : mType(INVALID_TYPE) {}

  private:
    // no assignment
    Description& operator=(const Description& rhs);

    friend class Manager;
    void setType(Type type) { mType = type; }

    Type mType;
  };


  class Description::Manager : public LockedPtrInterface<Description::Manager> {
    template <class T>
    class DefaultTypeListener;

  public:

    // ------------ CREATING DESCRIPTIONS ------------

    virtual Ptr<Description> newDescription(Description::Type type) = 0;


    virtual Ptr<Description> newDescription(const Ptr<const Description>& description) = 0;


    virtual Ptr<const Description> fileDescription(const String& filename) = 0;


    // ----------- DESCRIPTION TYPES -----------

    class TypeListener : 
    public BaseMultiListener<Description::Manager, TypeListener, Description::Type> {

    public:
      virtual Ptr<Description> onNewDescription(const Ptr<const Description>& description) = 0;
    };

    virtual void typeListener(Description::Type type, TypeListener* listener) = 0;

    // typeNameType(String typeName, Type type);
    // Type typeNameType(String typeName);

    template <class T>
    Ptr<TypeListener> newDescriptionType() {
      Ptr<DefaultTypeListener<T> > typeListenerPtr(new DefaultTypeListener<T>());
      typeListener(T::DESCRIPTION_TYPE, typeListenerPtr.ptr());
      return typeListenerPtr;
    }


    // virtual destructor
    virtual ~Manager() { }

  private:
    // A default listener implementation that returns a default
    // constructed instance of the template parameter type T.
    template <class T>
    class DefaultTypeListener : public TypeListener {
      virtual Ptr<Description> onNewDescription(const Ptr<const Description>& description)
      { return Ptr<Description>(new T(description)); }
    };
  };

}; // namespace Phx

#endif /* PHX_DESCRIPTION_H */

---