type.H

Go to the documentation of this file.

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_X3D_TYPE_H
#define ARCHON_X3D_TYPE_H

#include <string>
#include <map>
#include <set>
#include <list>

#include <archon/util/logger.H>
#include <archon/util/ref.H>
#include <archon/util/time.H>

#include <archon/x3d/server/exception.H>

namespace Archon
{
  namespace X3D
  {
    using namespace std;
    using namespace Utilities;

    struct ValueBase;
    struct Event;
    struct Route;
    struct RouteTail;
    struct NodeBase;
    struct NodeType;

    struct ExecutionContext; // Defined in scene.H

    struct FieldType
    {
      FieldType(unsigned index, string name, const FieldType *singleType=0);

      unsigned getIndex() const { return index; }
      string getName() const { return name; }
      bool getIsMultiple() const { return singleType; }
      const FieldType *getSingleType() const { return singleType; }

      static const FieldType *lookup(string name);

    private:
      unsigned index;
      string name;
      const FieldType *singleType;
    };

    struct FieldBase
    {
      unsigned long getId() const { return id; }
      string getName() const { return name; }
      const FieldType *getType() const { return type; }
      bool getIsEventTarget() const { return isEventTarget; }
      bool getIsEventSource() const { return isEventSource; }

      static const FieldBase *fetch(unsigned long fieldId, const NodeBase *n=0);

      virtual Ref<ValueBase> get(const NodeBase *) const = 0;

      virtual void set(NodeBase *, const Event *, bool cascade) const = 0;

      virtual bool changedSince(const NodeBase *n, const Time &) const = 0;

      virtual bool addRoute(NodeBase *, const RouteTail *) const = 0;

      virtual void delRoute(NodeBase *, const RouteTail *) const = 0;

      virtual bool delRouteMatch(NodeBase *, const RouteTail *) const = 0;

      //virtual string dump(const NodeBase *n, int level) const = 0;

      virtual ~FieldBase() {}

    protected:
      FieldBase(string name, const FieldType *,
                bool isEventTarget, bool isEventSource);

      FieldBase() {}

      bool isEventTarget;
      bool isEventSource;

      friend struct NodeBase;
      friend struct NodeType;

      virtual void forwardClear(NodeBase *) const = 0;

      unsigned long id;
      string name;
      const FieldType *type;
    };


    struct SequenceFieldBase: virtual FieldBase
    {
      virtual unsigned getSize(const NodeBase *) const = 0;
      virtual Ref<ValueBase> getAt(const NodeBase *, unsigned index) const = 0;
      virtual void setAt(NodeBase *, const ValueBase *, unsigned index, Time, bool cascade) const = 0;
      virtual void add(NodeBase *, const ValueBase *, Time, bool cascade) const = 0;
      virtual void remove(NodeBase *, const ValueBase *, Time, bool cascade) const = 0;
    };


    struct NodeFieldBase: virtual FieldBase
    {
      const NodeType *getNodeType() const { return nodeType; }

    protected:
      NodeFieldBase(const NodeType *nodeType): nodeType(nodeType)
      {
        if(!nodeType)
          ARCHON_THROW1(InternalException,
                        "Refering to uninitialized node type");
      }

    private:
      friend struct NodeBase;

      virtual bool inject(NodeBase *, NodeBase *childNode, Time, bool cascade) const = 0;

      const NodeType *nodeType;
    };

    struct NodeSequenceFieldBase: NodeFieldBase, SequenceFieldBase
    {
    protected:
      NodeSequenceFieldBase(const NodeType *nodeType):
        NodeFieldBase(nodeType) {}
    };

    struct NodeType
    {
      static const int maxIndexBits = 7;

      unsigned long getIndex() const { return index; }

      static unsigned long getTotalNumber();

      static const NodeType *get(unsigned long index);

      static const NodeType *lookup(const string &nodeTypeName);

      Ref<NodeBase> instantiate(BackRef<ExecutionContext> context) const;

      string getName() const { return name; }

      string getContainerField() const { return containerField; }

      bool isAbstract() const { return !instanceMaker; }
      bool isVirtualBase() const { return virtualBase; }
      bool isInternalUseOnly() const { return internalUseOnly; }
      bool isDerivedFrom(const NodeType *baseType) const;

      bool isUserInstantiable() const
      {
        return instanceMaker && !internalUseOnly;
      }

      unsigned long getNumberOfImmediateFields() const
      {
        return fields.size();
      }

      const FieldBase *getImmediateField(unsigned long fieldIndex) const
      {
        if(fieldIndex >= fields.size())
          ARCHON_THROW1(InternalException, "Index out of bound");
        return fields[fieldIndex];
      }

      const FieldBase *lookupImmediateField(string name) const;

      const FieldBase *lookupField(string name) const;

      const NodeFieldBase *lookupNodeField(const NodeType *) const;


      static const NodeType *newAbstract(string name, bool virtualBase,
                                         const vector<const FieldBase *> *fields);
      static const NodeType *newAbstract(string name, bool virtualBase,
                                         const vector<const FieldBase *> *fields,
                                         const NodeType *derivedFrom1);
      static const NodeType *newAbstract(string name, bool virtualBase,
                                         const vector<const FieldBase *> *fields,
                                         const NodeType *derivedFrom1,
                                         const NodeType *derivedFrom2);
      static const NodeType *newConcrete(string name, string conatinerField,
                                         Ref<NodeBase> (*instanceMaker)(BackRef<ExecutionContext>),
                                         const vector<const FieldBase *> *fields,
                                         const NodeType *derivedFrom1);
      static const NodeType *newConcrete(string name, string conatinerField,
                                         Ref<NodeBase> (*instanceMaker)(BackRef<ExecutionContext>),
                                         const vector<const FieldBase *> *fields,
                                         const NodeType *derivedFrom1,
                                         const NodeType *derivedFrom2);

      void setFields(const vector<const FieldBase *> *fields);


      bool changedSince(const NodeBase *, const Time &) const;

      void describe(Logger *) const;
      static void describeAll(Logger *);

      // string dumpFields(const NodeBase *, int level) const;

      typedef vector<const NodeType *>::const_iterator iterator;
      iterator derivedFromBegin() const;
      iterator derivedFromEnd() const;

    private:
      unsigned long index;
      string name;
      string containerField;
      bool virtualBase;
      bool internalUseOnly;
      vector<const NodeType *> derivedFrom;
      vector<const FieldBase *> fields;
      Ref<NodeBase> (*instanceMaker)(BackRef<ExecutionContext>);
      map<string, const FieldBase *> fieldMap; // Fast access to all local and inherited fields

      void addFields(vector<pair<const FieldBase *, const NodeType *> > &) const;
      void initFieldMap(map<string, const FieldBase *> &,
                        string, set<const NodeType *> &) const;

      NodeType(string name, string containerField, bool virtualBase,
               const vector<const NodeType *> *derivedFrom,
               const vector<const FieldBase *> *fields,
               Ref<NodeBase> (*instanceMaker)(BackRef<ExecutionContext>));


      friend struct NodeBase;

      void forwardClear(NodeBase *) const;
    };
  }
}

#endif // ARCHON_X3D_TYPE_H

---