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>
#include <Phx/Util/PhxXmlDescription.h>

namespace Phx {

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

    typedef ValueType<TypeClass, uint32_t>  Type;

    static const Type INVALID_TYPE;

    virtual BitVector serializedData(void) const = 0;

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

    virtual XmlDescriptionNode xmlData(void) const = 0;

    virtual void xmlData(const XmlDescriptionNode& xmlNode) = 0;

    Type type() const { return mType; }

  protected:
    Description(void);
    // virtual destructor
    virtual ~Description() {}

  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<Description> newDescription(const XmlDescriptionNode& node) = 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;


    virtual void typeNameType(const String& typeName, Type type) = 0;
    
    virtual Type typeNameType(const String& typeName) const = 0;

    template <class T>
    Ptr<TypeListener> newDescriptionType() {
      Ptr<DefaultTypeListener<T> > typeListenerPtr(new DefaultTypeListener<T>());
      typeListener(T::DESCRIPTION_TYPE, typeListenerPtr.ptr());
      typeNameType(T::DESCRIPTION_TYPE_NAME, T::DESCRIPTION_TYPE);
      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) {
        const Ptr<const T> descT = description.dynamicCast<const T>();
        if (!description || descT) {
          return Ptr<Description>(new T(descT, notifier())); 
        }
        return 0;
      }
    };
  };

}; // namespace Phx

#endif /* PHX_DESCRIPTION_H */

---