PhxNamedInterface.h

Go to the documentation of this file.

#ifndef PHX_NAMED_INTERFACE_H
#define PHX_NAMED_INTERFACE_H

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

#include <Phx/Core/PhxDescription.h>
#include <Phx/Util/PhxLocks.h>

namespace Phx {

  class NamedInterface : public LockedPtrInterface<NamedInterface> {
    class TypeClass;
    class IdentifierClass;

  public:
    class Manager;

    typedef ValueType<TypeClass, uint32_t>  Type;

    typedef ValueType<IdentifierClass, uint32_t>  Identifier;

    static const Type INVALID_TYPE;

    static const Identifier INVALID_IDENTIFIER;

    const Type& type(void) const { return mType; }

    const Identifier& identifier(void) const { return mIdentifier; }

    const String& name(void) const { return mName; }

  protected:
    // Default constructor - protected to prevent direct
    // instantiation.
    NamedInterface(void);

    // Virtual destructor -- necessary for subclasses.
    virtual ~NamedInterface() {}

  private:
    friend class Manager;

    // Allows manager to set values after creation
    void setType(Type type) { mType = type; }
    void setIdentifier(Identifier identifier) { mIdentifier = identifier; }
    void setName(const String& name) { mName = name; }

    Type       mType;
    Identifier mIdentifier;
    String     mName;
  };

  class NamedInterface::Manager : public LockedPtrInterface<NamedInterface::Manager> {
  public:
    // Type constant and name
    const static NamedInterface::Type INTERFACE_TYPE;
    const static String               INTERFACE_TYPE_NAME;

    // --------- NAMED INTERFACE INSTANCES ---------

    virtual Ptr<NamedInterface> newNamedInterface(NamedInterface::Type interfaceType,
                                                  const Ptr<Description>& description,
                                                  const String& instanceName,
                                                  NamedInterface::Identifier identifier) = 0;

    // same as above but assigns identifier automatically from a locally unique pool
    virtual Ptr<NamedInterface> newNamedInterface(NamedInterface::Type interfaceType,
                                                  const Ptr<Description>& description,
                                                  const String& instanceName) = 0;

    virtual Ptr<NamedInterface> namedInterface(NamedInterface::Identifier identifier) const = 0;

    virtual Ptr<NamedInterface> namedInterface(const String& name) const = 0;

    virtual void deleteNamedInterface(const Ptr<NamedInterface>& interface) = 0;

    // ------- NAMED INTERFACE TYPES -------

    class TypeListener :
      public BaseMultiListener<NamedInterface::Manager, TypeListener, NamedInterface::Type> {
    public:
      virtual Ptr<NamedInterface> onNewNamedInterface(const Ptr<Description>& constructorData,
                                                      const String& instanceName,
                                                      NamedInterface::Identifier identifier) = 0;

      virtual void onDeleteNamedInterface(const Ptr<NamedInterface>& interface) = 0;
    };

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

    template <class T>
    Ptr<TypeListener> newNamedInterfaceType(void) {
      
      // create default listener for client
      Ptr<DefaultTypeListener<T> > typeListenerPtr(new DefaultTypeListener<T>());
      typeListener(T::INTERFACE_TYPE, typeListenerPtr.ptr());

      try {
                // Set type name if name is non-null string
                if (T::INTERFACE_TYPE_NAME != "") {
                  typeNameType(T::INTERFACE_TYPE_NAME, T::INTERFACE_TYPE);
                }
      } catch (...) {
                // Remove listener if setting type name failed.
                typeListener(T::INTERFACE_TYPE, 0);
                throw ;
      }

      return typeListenerPtr;
    }

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

    virtual NamedInterface::Type typeNameType(const String& typeName) const = 0;

  protected:
    // Calls interface->setType(type);
    void setNamedInterfaceType(const Ptr<NamedInterface>& interface, NamedInterface::Type type);

    // Calls interface->setName(name);
    void setNamedInterfaceName(const Ptr<NamedInterface>& interface, const String& name);

    // Calls interface->setIdentifier(identifier);
    void setNamedInterfaceIdentifier(const Ptr<NamedInterface>& interface,
                                     NamedInterface::Identifier identifier);
 
  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<NamedInterface> onNewNamedInterface(const Ptr<Description>& description,
                                                      const String& instanceName,
                                                      NamedInterface::Identifier identifier) {
        const NamedInterface::Manager* mgr = notifier();
        return Ptr<NamedInterface>(new T(description, instanceName, identifier, mgr));
      }
      virtual void onDeleteNamedInterface(const Ptr<NamedInterface>& interface) { }
    };
  };

  
}; // namespace Phx

#endif /* PHX_NAMED_INTERFACE_H */

---