type.C

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).
 */

#include <archon/util/term.H>
#include <archon/util/text.H>

#include <archon/x3d/server/type.H>
#include <archon/x3d/server/node.H>
#include <archon/x3d/server/scene.H>
#include <archon/x3d/server/custom_field.H>

namespace Archon
{
  using namespace Utilities;

  namespace X3D
  {
    namespace
    {
      vector<const NodeType *> nodeTypes;

      map<string, const NodeType *>  nodeTypeMap;
      map<string, const FieldType *> fieldTypeMap;
    }

    void NodeType::addFields(vector<pair<const FieldBase *,
                             const NodeType *> > &l) const
    {
      for(unsigned i=0; i<derivedFrom.size(); ++i)
        derivedFrom[i]->addFields(l);
      for(unsigned i=0; i<fields.size(); ++i)
        l.push_back(make_pair(fields[i], this));
    }

    void NodeType::initFieldMap(map<string, const FieldBase *> &m,
                                string nodeType,
                                set<const NodeType *> &virtualBases) const
    {
      for(unsigned i=0; i<derivedFrom.size(); ++i)
      {
        const NodeType *b = derivedFrom[i];
        if(!b->isVirtualBase() || virtualBases.insert(b).second)
          b->initFieldMap(m, nodeType, virtualBases);
      }
      for(unsigned i=0; i<fields.size(); ++i)
      {
        const FieldBase *f = fields[i];
        if(!m.insert(make_pair(f->getName(), f)).second ||
           f->getIsEventTarget() && f->getIsEventSource() &&
           (!m.insert(make_pair("set_" + f->getName(), f)).second ||
            !m.insert(make_pair(f->getName() + "_changed", f)).second))
          ARCHON_THROW1(InternalException,
                        "Ambiguous field '" + f->getName() +
                        "' for node type '" + nodeType + "'");
      }
    }

    NodeType::NodeType(string name, string containerField,
                       bool virtualBase,
                       const vector<const NodeType *> *d,
                       const vector<const FieldBase *> *f,
                       Ref<NodeBase> (*instanceMaker)(BackRef<ExecutionContext>)):
      index(nodeTypes.size()), name(name), containerField(containerField),
      virtualBase(virtualBase), internalUseOnly(false),
      instanceMaker(instanceMaker)
    {
      if(nodeTypes.size() == (1 << maxIndexBits) - 1)
          ARCHON_THROW1(InternalException, "Too many node types");

      if(d) derivedFrom = *d;

      setFields(f);

      if(!nodeTypeMap.insert(make_pair(name, this)).second)
        ARCHON_THROW1(InternalException,
                      "Redefinition of node type '" + name + "'");

      nodeTypes.push_back(this);
    }

    void NodeType::setFields(const vector<const FieldBase *> *f)
    {
      fields.clear();
      if(f)
      {
        fields = *f;
        for(unsigned i=0; i<fields.size(); ++i)
        {
          unsigned long j = i;
          j <<= maxIndexBits;
          j |= index;
          const_cast<FieldBase *>(fields[i])->id = j;
        }
      }

      // Verify uniqueness of all local and inherited field names
      fieldMap.clear();
      set<const NodeType *> virtualBases;
      initFieldMap(fieldMap, name, virtualBases);
    }

    unsigned long NodeType::getTotalNumber()
    {
      return nodeTypes.size();
    }

    const NodeType *NodeType::get(unsigned long i)
    {
      if(i >= nodeTypes.size())
        ARCHON_THROW1(ArgumentException, "Index out of bound");
      return nodeTypes[i];
    }

    const NodeType *NodeType::lookup(const string &n)
    {
      map<string, const NodeType *>::iterator i = nodeTypeMap.find(n);
      return i==nodeTypeMap.end() ? 0 : i->second;
    }

    Ref<NodeBase> NodeType::instantiate(BackRef<ExecutionContext> c) const
    {
      if(!instanceMaker)
        ARCHON_THROW1(ArgumentException,
                      "Attempt to instantiate abstract node type");
      return (*instanceMaker)(c);
    }

    bool NodeType::isDerivedFrom(const NodeType *baseType) const
    {
      if(this == baseType) return true;
      for(unsigned i=0; i<derivedFrom.size(); ++i)
        if(derivedFrom[i]->isDerivedFrom(baseType)) return true;
      return false;
    }


    const FieldBase *FieldBase::fetch(unsigned long i, const NodeBase *n)
    {
      unsigned long j = i & (1 << NodeType::maxIndexBits) - 1;
      if(j >= nodeTypes.size()) return 0;
      const NodeType *t = nodeTypes[j];
      unsigned long k = i >> NodeType::maxIndexBits;
      if(k < t->getNumberOfImmediateFields()) return t->getImmediateField(k);
      if(!n || j != n->getType()->getIndex()) return 0;
      const CustomFieldNode *m = dynamic_cast<const CustomFieldNode *>(n);
      if(!m) return 0;
      return m->getCustomField(k - t->getNumberOfImmediateFields()).get();
    }


    FieldBase::FieldBase(string name, const FieldType *type,
                         bool isEventTarget, bool isEventSource):
      isEventTarget(isEventTarget), isEventSource(isEventSource), 
      id(0), name(name), type(type)
    {
    }

    const FieldBase *NodeType::lookupField(string name) const
    {
      map<string, const FieldBase *>::const_iterator i =
        fieldMap.find(name);
      return i==fieldMap.end() ? 0 : i->second;
    }

    const FieldBase *NodeType::lookupImmediateField(string name) const
    {
      for(unsigned i=0; i<fields.size(); ++i)
      {
        const FieldBase *f = fields[i];
        if(f->getName() == name) return f;
      }
      return 0;
    }

    const NodeFieldBase *NodeType::lookupNodeField(const NodeType *nodeType) const
    {
      for(unsigned i=0; i<derivedFrom.size(); ++i)
      {
        const NodeFieldBase *f = derivedFrom[i]->lookupNodeField(nodeType);
        if(f) return f;
      }
      for(unsigned i=0; i<fields.size(); ++i)
      {
        if(const NodeFieldBase *f =
           dynamic_cast<const NodeFieldBase *>(fields[i]))
        {
          if(f->getIsEventTarget() == f->getIsEventSource() &&
             nodeType->isDerivedFrom(f->getNodeType())) return f;
        }
      }
      return 0;
    }

    const NodeType *NodeType::
    newAbstract(string name, bool virtualBase,
                const vector<const FieldBase *> *fields)
    {
      return new NodeType(name, "", virtualBase, 0, fields, 0);
    }
    
    const NodeType *NodeType::
    newAbstract(string name, bool virtualBase,
                const vector<const FieldBase *> *fields,
                const NodeType *derivedFrom1)
    {
      if(!derivedFrom1)
        ARCHON_THROW1(InternalException,
                      "Deriving '" + name + "' from uninitialized node type");
      vector<const NodeType *> derivedFrom;
      derivedFrom.push_back(derivedFrom1);
      return new NodeType(name, "", virtualBase, &derivedFrom, fields, 0);
    }

    const NodeType *NodeType::
    newAbstract(string name, bool virtualBase,
                const vector<const FieldBase *> *fields,
                const NodeType *derivedFrom1,
                const NodeType *derivedFrom2)
    {
      if(!derivedFrom1 || !derivedFrom2)
        ARCHON_THROW1(InternalException,
                      "Deriving '" + name + "' from uninitialized node type");
      vector<const NodeType *> derivedFrom;
      derivedFrom.push_back(derivedFrom1);
      derivedFrom.push_back(derivedFrom2);
      return new NodeType(name, "", virtualBase, &derivedFrom, fields, 0);
    }

    const NodeType *NodeType::
    newConcrete(string name, string containerField,
                Ref<NodeBase> (*instanceMaker)(BackRef<ExecutionContext>),
                const vector<const FieldBase *> *fields,
                const NodeType *derivedFrom1)
    {
      if(!derivedFrom1)
        ARCHON_THROW1(InternalException,
                      "Deriving '" + name + "' from uninitialized node type");
      vector<const NodeType *> derivedFrom;
      derivedFrom.push_back(derivedFrom1);
      return new NodeType(name, containerField, false,
                          &derivedFrom, fields, instanceMaker);
    }

    const NodeType *NodeType::
    newConcrete(string name, string containerField,
                Ref<NodeBase> (*instanceMaker)(BackRef<ExecutionContext>),
                const vector<const FieldBase *> *fields,
                const NodeType *derivedFrom1,
                const NodeType *derivedFrom2)
    {
      if(!derivedFrom1 || !derivedFrom2)
        ARCHON_THROW1(InternalException,
                      "Deriving '" + name + "' from uninitialized node type");
      vector<const NodeType *> derivedFrom;
      derivedFrom.push_back(derivedFrom1);
      derivedFrom.push_back(derivedFrom2);
      return new NodeType(name, containerField, false,
                          &derivedFrom, fields, instanceMaker);
    }

    void NodeType::forwardClear(NodeBase *n) const
    {
      for(unsigned i=0; i<fields.size(); ++i)
        fields[i]->forwardClear(n);
      for(unsigned i=0; i<derivedFrom.size(); ++i)
        derivedFrom[i]->forwardClear(n);
    }

    bool NodeType::changedSince(const NodeBase *n, const Time &t) const
    {
      for(unsigned i=0; i<fields.size(); ++i)
        if(fields[i]->changedSince(n, t)) return true;
      for(unsigned i=0; i<derivedFrom.size(); ++i)
        if(derivedFrom[i]->changedSince(n, t)) return true;
      return false;
    }

    /*
    string NodeType::dumpFields(const NodeBase *n, int level) const
    {
      string s;
      for(unsigned i=0; i<derivedFrom.size(); ++i)
        s += derivedFrom[i]->dumpFields(n, level);
      for(unsigned i=0; i<fields.size(); ++i)
        s += fields[i]->dump(n, level);
      return s;
    }
    */

    void NodeType::describe(Logger *logger) const
    {
      string header = getName();
      if(derivedFrom.size())
      {
        header += ": ";
        for(unsigned i=0; i<derivedFrom.size(); ++i)
        {
          if(i) header += ", ";
          header += derivedFrom[i]->getName();
        }
      }
      if(!instanceMaker) header += " // abstract";
      vector<pair<const FieldBase *, const NodeType *> > l;
      addFields(l);
      vector<double> columnWidthFractions;
      columnWidthFractions.push_back(0.1);
      columnWidthFractions.push_back(0.1);
      columnWidthFractions.push_back(0.2);
      columnWidthFractions.push_back(0.2);
      columnWidthFractions.push_back(0.2);
      columnWidthFractions.push_back(0.2);
      Text::Table<string> table(l.size(), columnWidthFractions);
      for(unsigned i=0; i<l.size(); ++i)
      {
        const FieldBase *f = l[i].first;
        table(i, 0) = "  " + f->getType()->getName();
        table(i, 1) = "[" +
          string(f->getIsEventTarget()?"in":"") +
          (f->getIsEventTarget() && f->getIsEventSource()?",":"") +
          (f->getIsEventSource()?"out":"") + "]";
        table(i, 2) = f->getName();
        table(i, 3) = "<default value>";
        if(const NodeFieldBase *nf =
           dynamic_cast<const NodeFieldBase *>(f))
          table(i, 4) = nf->getNodeType()->getName();
        else
          table(i, 4) = "<domain>";
        if(l[i].second != this) table(i, 5) = "// " + l[i].second->getName();
      }
      logger->log(header + "\n{\n" +
                  Text::format(table, Term::getWidth(), 2, false) + "}\n");
    }

    void NodeType::describeAll(Logger *l)
    {
      for(unsigned i=0; i<nodeTypes.size(); ++i) nodeTypes[i]->describe(l);
    }

    NodeType::iterator NodeType::derivedFromBegin() const
    {
      return derivedFrom.begin();
    }

    NodeType::iterator NodeType::derivedFromEnd() const
    {
      return derivedFrom.end();
    }


    FieldType::FieldType(unsigned index, string name,
                         const FieldType *singleType):
      index(index), name(name), singleType(singleType)
    {
      if(!fieldTypeMap.insert(make_pair(name, this)).second)
        ARCHON_THROW1(InternalException,
                      "Redefinition of field type '" +
                      name + "'");
    }

    const FieldType *FieldType::lookup(string name)
    {
      map<string, const FieldType *>::iterator i = fieldTypeMap.find(name);
      return i==fieldTypeMap.end() ? 0 : i->second;
    }
  }
}

---