custom_field.H

/*
 * 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_CUSTOM_FIELD_H
#define ARCHON_X3D_CUSTOM_FIELD_H

/*
 * \file
 *
 *  Definition of custom fields as used in scripts.
 */

#include <archon/x3d/server/field_type.H>
// #include <archon/x3d/server/dump.H>
#include <archon/x3d/server/type.H>
#include <archon/x3d/server/event.H>
#include <archon/x3d/server/node.H>

namespace Archon
{
  namespace X3D
  {
    using namespace Archon::Math;

    struct Parser;

    struct CustomFieldBase: virtual RefObjectBase, virtual FieldBase
    {
      int getIndex() const { return index; }

    protected:
      CustomFieldBase(int index, const NodeBase *containingNode):
        index(index)
      {
        const NodeType *t = containingNode->getType();
        unsigned long j = t->getNumberOfImmediateFields();
        j += index;
        j <<= NodeType::maxIndexBits;
        j |= t->getIndex();
        id = j;
      }

      const int index; // Index into CustomFieldNode::customFields

      // Overriding from FieldBase
      bool addRoute(NodeBase *, const RouteTail *r) const
      {
        CustomFieldBase *f =
          const_cast<CustomFieldBase *>(this);
        return f->eventSource.addRoute(r);
      }

      // Overriding from FieldBase
      void delRoute(NodeBase *, const RouteTail *r) const
      {
        CustomFieldBase *f =
          const_cast<CustomFieldBase *>(this);
        f->eventSource.delRoute(r);
      }

      // Overriding from FieldBase
      bool delRouteMatch(NodeBase *, const RouteTail *r) const
      {
        CustomFieldBase *f =
          const_cast<CustomFieldBase *>(this);
        return f->eventSource.delRouteMatch(r);
      }

    protected:
      EventSource eventSource;
      Time timestamp;
    };

    struct CustomFieldNode: virtual NodeBase
    {
      bool addCustomField(Ref<CustomFieldBase>) throw(RealizedException);

      unsigned getNumberOfCustomFields() const
      {
        Mutex::Lock l(mutex);
        return customFields.size();
      }

      Ref<CustomFieldBase> getCustomField(unsigned index) const
      {
        Mutex::Lock l(mutex);
        if(index >= customFields.size()) return 0;
        return customFields[index];
      }
      Ref<CustomFieldBase> getCustomFieldNoLock(unsigned index) const
      {
        return customFields[index];
      }

      // Overriding from NodeBase
      // string dumpFields(int level) const;

    protected:
      CustomFieldNode() {}

      vector<Ref<CustomFieldBase> > customFields;

      template<typename T> friend struct SimpleCustomField;
      template<typename T> friend struct SimpleSeqCustomField;
      template<typename C> friend struct NodeCustomField;
      template<typename C> friend struct NodeSequenceCustomField;

      virtual void handleEvent(int fieldIndex, Time timestamp) = 0;

    private:
      // Overriding from NodeBase
      const FieldBase *lookupField(string name) const;
    };


    template<typename T>
    struct SimpleCustomField: CustomFieldBase
    {
      SimpleCustomField(const NodeBase *containingNode,
                        int index, string name, const FieldType *type,
                        bool isEventTarget, bool isEventSource,
                        const T &v):
        FieldBase(name, type, isEventTarget, isEventSource),
        CustomFieldBase(index, containingNode),
        value(v) {}

      // Overriding from FieldBase
      Ref<ValueBase> get(const NodeBase *) const
      {
        return new SimpleValue<T>(this->getType(), value);
      }

      // Overriding from FieldBase
      void set(NodeBase *n, const Event *e, bool cascade) const
      {
        const SimpleValueBase *val =
          dynamic_cast<const SimpleValueBase *>(e->value.get());
        if(!val) ARCHON_THROW1(InternalException,
                              "SimpleCustomField::set: "
                              "Value/Field type inconsistency");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException,
                            "SimpleCustomField::set: "
                            "Node was not a CustomFieldNode");  
        SimpleCustomField *f =
          const_cast<SimpleCustomField *>(this);
        f->timestamp = e->time;
        f->value = *static_cast<const T *>(val->getValuePtr());
        if(cascade && isEventTarget) m->handleEvent(index, e->time);
        if(cascade) eventSource.cascadeEvent(e);
      }

      // Overriding from FieldBase
      bool changedSince(const NodeBase *, const Time &t) const
      {
        return timestamp >= t;
      }

      // Overriding from FieldBase
      /*
      string dump(const NodeBase *, int level) const
      {
        return string(2*level, ' ') +
          this->getName() + " " + dumpValue(value) + "\n";
      }
      */

      void forwardClear(NodeBase *n) const
      {
        SimpleCustomField *f =
          const_cast<SimpleCustomField *>(this);
        f->eventSource.clear();
      }

    private:
      T value;
    };

    template<typename T>
    struct SimpleSeqCustomField: CustomFieldBase, SequenceFieldBase
    {
      typedef vector<T> V;

      SimpleSeqCustomField(const NodeBase *containingNode,
                           int index, string name, const FieldType *type,
                           bool isEventTarget, bool isEventSource,
                           const V &v):
        FieldBase(name, type, isEventTarget, isEventSource),
        CustomFieldBase(index, containingNode) {}

      // Overriding from FieldBase
      Ref<ValueBase> get(const NodeBase *) const
      {
        return new SimpleValue<V>(this->getType(), value);
      }

      // Overriding from FieldBase
      void set(NodeBase *n, const Event *e, bool cascade) const
      {
        const SimpleValueBase *val =
          dynamic_cast<const SimpleValueBase *>(e->value.get());
        if(!val) ARCHON_THROW1(InternalException,
                              "SimpleCustomField::set: "
                              "Value/Field type inconsistency");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException,
                            "SimpleCustomField::set: "
                            "Node was not a CustomFieldNode");  
        SimpleSeqCustomField *f =
          const_cast<SimpleSeqCustomField *>(this);
        f->timestamp = e->time;
        f->value = *static_cast<const V *>(val->getValuePtr());
        if(cascade && isEventTarget) m->handleEvent(index, e->time);
        if(cascade) eventSource.cascadeEvent(e);
      }

      // Overriding from SequenceFieldBase
      unsigned getSize(const NodeBase *) const
      {
        return value.size();
      }

      // Overriding from SequenceFieldBase
      Ref<ValueBase> getAt(const NodeBase *, unsigned i) const
      {
        if(i >= value.size())
          ARCHON_THROW1(InternalException, "Index out of range");
        return new SimpleValue<T>(this->getType()->getSingleType(), value[i]);
      }

      // Overriding from SequenceFieldBase
      void setAt(NodeBase *n, const ValueBase *v,
                 unsigned i, Time time, bool cascade) const
      {
        if(i >= value.size())
          ARCHON_THROW1(InternalException, "Index out of range");
        const SimpleValue<T> *w =
          dynamic_cast<const SimpleValue<T> *>(v);
        if(!w) ARCHON_THROW1(InternalException, "Value/Field type mismatch");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException, "Not a CustomFieldNode");
        SimpleSeqCustomField *f =
          const_cast<SimpleSeqCustomField *>(this);
        f->timestamp = time;
        f->value[i] = w->value;
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Ref<ValueBase> x = get(n);
          SimpleValue<V> *s = dynamic_cast<SimpleValue<V> *>(x.get());
          if(!s) ARCHON_THROW1(InternalException, "Wrong value type");
          Event e(s, time);
          eventSource.cascadeEvent(&e);
        }
      }

      // Overriding from SequenceFieldBase
      void add(NodeBase *n, const ValueBase *v, Time time, bool cascade) const
      {
        const SimpleValue<T> *w =
          dynamic_cast<const SimpleValue<T> *>(v);
        if(!w) ARCHON_THROW1(InternalException, "Value/Field type mismatch");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException, "Not a CustomFieldNode");
        SimpleSeqCustomField *f =
          const_cast<SimpleSeqCustomField *>(this);
        f->timestamp = time;
        f->value.push_back(w->value);
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Ref<ValueBase> x = get(n);
          SimpleValue<V> *s = dynamic_cast<SimpleValue<V> *>(x.get());
          if(!s) ARCHON_THROW1(InternalException, "Wrong value type");
          Event e(s, time);
          eventSource.cascadeEvent(&e);
        }
      }

      // Overriding from SequenceFieldBase
      void remove(NodeBase *n, const ValueBase *v, Time time, bool cascade) const
      {
        const SimpleValue<T> *w =
          dynamic_cast<const SimpleValue<T> *>(v);
        if(!w) ARCHON_THROW1(InternalException, "Value/Field type mismatch");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException, "Not a CustomFieldNode");
        SimpleSeqCustomField *f =
          const_cast<SimpleSeqCustomField *>(this);
        f->timestamp = time;
        std::remove(f->value.begin(), f->value.end(), w->value);
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Ref<ValueBase> x = get(n);
          SimpleValue<V> *s = dynamic_cast<SimpleValue<V> *>(x.get());
          if(!s) ARCHON_THROW1(InternalException, "Wrong value type");
          Event e(s, time);
          eventSource.cascadeEvent(&e);
        }
      }

      // Overriding from FieldBase
      bool changedSince(const NodeBase *, const Time &t) const
      {
        return timestamp >= t;
      }

      // Overriding from FieldBase
      /*
      string dump(const NodeBase *, int level) const
      {
        return string(2*level, ' ') +
          this->getName() + " " + dumpValue(value) + "\n";
      }
      */

      void forwardClear(NodeBase *n) const
      {
        SimpleSeqCustomField *f =
          const_cast<SimpleSeqCustomField *>(this);
        f->eventSource.clear();
      }

    private:
      V value;
    };

    template<typename C>
    struct NodeCustomField: CustomFieldBase, NodeFieldBase
    {
      NodeCustomField(const NodeBase *containingNode,
                      int index, string name, const NodeType *nodeType,
                      bool isEventTarget, bool isEventSource,
                      Ref<C> v):
        FieldBase(name, SFNode::type, isEventTarget, isEventSource),
        CustomFieldBase(index, containingNode),
        NodeFieldBase(nodeType), value(v) {}

      // Overriding from FieldBase
      Ref<ValueBase> get(const NodeBase *) const
      {
        return new NodeValue(SFNode::type, value.get());
      }

      // Overriding from FieldBase
      void set(NodeBase *n, const Event *e, bool cascade) const
      {
        const NodeValue *val =
          dynamic_cast<const NodeValue *>(e->value.get());
        if(!val) ARCHON_THROW1(InternalException,
                              "NodeCustomField::set: "
                              "Value/Field type inconsistency");
        C *v = dynamic_cast<C *>(val->value.get());
        if(!v && val->value.get())
          ARCHON_THROW1(InternalException,
                        "NodeCustomField::set: "
                        "Incompatible node");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException,
                             "NodeCustomField::set: "
                             "Node was not a CustomFieldNode");
        NodeCustomField *f =
          const_cast<NodeCustomField *>(this);
        f->timestamp = e->time;
        f->value = v;
        if(cascade && isEventTarget) m->handleEvent(index, e->time);
        if(cascade) eventSource.cascadeEvent(e);
      }

      // Overriding from NodeFieldBase
      bool inject(NodeBase *n, NodeBase *child, Time time, bool cascade) const
      {
        C *c = dynamic_cast<C *>(child);
        if(!c && child)
          ARCHON_THROW1(InternalException,
                        "NodeCustomField::inject: "
                        "Incompatible node");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException,
                             "NodeCustomField::inject: "
                             "Node was not a CustomFieldNode");
        NodeCustomField *f =
          const_cast<NodeCustomField *>(this);
        if(f->value) return false;
        f->timestamp = time;
        f->value = c;
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Event e(new NodeValue(SFNode::type, c), time);
          eventSource.cascadeEvent(&e);
        }
        return true;
      }

      // Overriding from FieldBase
      bool changedSince(const NodeBase *, const Time &t) const
      {
        return timestamp >= t || value->changedSince(t);
      }

      // Overriding from FieldBase
      /*
      string dump(const NodeBase *, int level) const
      {
        return string(2*level, ' ') + this->getName() +
          (value ? "\n" + value->dump(level+1) : string(" NULL\n"));
      }
      */

      void forwardClear(NodeBase *) const
      {
        NodeCustomField *f =
          const_cast<NodeCustomField *>(this);
        f->value.reset();
        f->eventSource.clear();
      }

    private:
      Ref<C> value;
    };

    template<typename C>
    struct NodeSequenceCustomField: CustomFieldBase, NodeSequenceFieldBase
    {
      NodeSequenceCustomField(const NodeBase *containingNode,
                              int index, string name, const NodeType *nodeType,
                              bool isEventTarget, bool isEventSource,
                              const vector<Ref<C> > &v):
        FieldBase(name, MFNode::type, isEventTarget, isEventSource),
        CustomFieldBase(index, containingNode),
        NodeSequenceFieldBase(nodeType), value(v) {}

      // Overriding from FieldBase
      void set(NodeBase *n, const Event *e, bool cascade) const
      {
        const NodeSequenceValue *val =
          dynamic_cast<const NodeSequenceValue *>(e->value.get());
        if(!val) ARCHON_THROW1(InternalException,
                               "NodeSequenceCustomField::set: "
                               "Value/Field type inconsistency");
        vector<Ref<C> > v;
        v.resize(val->value.size());
        for(unsigned i=0; i<val->value.size(); ++i)
        {
          NodeBase *m = val->value[i].get();
          if(!m) ARCHON_THROW1(InternalException,
                               "NodeSequenceCustomField::set: "
                               "Null node is illegal");
          v[i] = dynamic_cast<C *>(m);
          if(!v[i])
            ARCHON_THROW1(InternalException,
                          "NodeSequenceCustomField::set: "
                          "Incompatible node");
        }
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException,
                             "SimpleCustomField::set: "
                             "Node was not a CustomFieldNode"); 
        NodeSequenceCustomField *f =
          const_cast<NodeSequenceCustomField *>(this);
        f->timestamp = e->time;
        f->value = v;
        if(cascade && isEventTarget) m->handleEvent(index, e->time);
        if(cascade) eventSource.cascadeEvent(e);
      }


      Ref<ValueBase> get(const NodeBase *) const
      {
        Ref<NodeSequenceValue> v = new NodeSequenceValue(MFNode::type);
        v->value.resize(value.size());
        for(unsigned i=0; i<value.size(); ++i) v->value[i] = value[i];
        return v;
      }

      // Overriding from SequenceFieldBase
      unsigned getSize(const NodeBase *) const
      {
        return value.size();
      }

      // Overriding from SequenceFieldBase
      Ref<ValueBase> getAt(const NodeBase *, unsigned i) const
      {
        if(i >= value.size())
          ARCHON_THROW1(InternalException, "Index out of range");
        return new NodeValue(SFNode::type, value[i].get());
      }

      // Overriding from SequenceFieldBase
      void setAt(NodeBase *n, const ValueBase *v,
                 unsigned i, Time time, bool cascade) const
      {
        if(i >= value.size())
          ARCHON_THROW1(InternalException, "Index out of range");
        const NodeValue *w =
          dynamic_cast<const NodeValue *>(v);
        if(!w) ARCHON_THROW1(InternalException, "Value/Field type mismatch");
        C *c = dynamic_cast<C *>(w->value.get());
        if(!c) ARCHON_THROW1(InternalException, "Incompatible node type");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException, "Not a CustomFieldNode");

        NodeSequenceCustomField *f =
          const_cast<NodeSequenceCustomField *>(this);
        f->timestamp = time;
        f->value[i].reset(c);
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Ref<ValueBase> x = get(n);
          NodeSequenceValue *s =
            dynamic_cast<NodeSequenceValue *>(x.get());
          if(!s) ARCHON_THROW1(InternalException, "Wrong value type");
          Event e(s, time);
          eventSource.cascadeEvent(&e);
        }
      }

      // Overriding from SequenceFieldBase
      void add(NodeBase *n, const ValueBase *v, Time time, bool cascade) const
      {
        const NodeValue *w =
          dynamic_cast<const NodeValue *>(v);
        if(!w) ARCHON_THROW1(InternalException, "Value/Field type mismatch");
        C *c = dynamic_cast<C *>(w->value.get());
        if(!c) ARCHON_THROW1(InternalException, "Incompatible node type");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException, "Not a CustomFieldNode");

        NodeSequenceCustomField *f =
          const_cast<NodeSequenceCustomField *>(this);
        f->timestamp = time;
        f->value.push_back(c);
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Ref<ValueBase> x = get(n);
          NodeSequenceValue *s =
            dynamic_cast<NodeSequenceValue *>(x.get());
          if(!s) ARCHON_THROW1(InternalException, "Wrong value type");
          Event e(s, time);
          eventSource.cascadeEvent(&e);
        }
      }

      // Overriding from SequenceFieldBase
      void remove(NodeBase *n, const ValueBase *v, Time time, bool cascade) const
      {
        const NodeValue *w =
          dynamic_cast<const NodeValue *>(v);
        if(!w) ARCHON_THROW1(InternalException, "Value/Field type mismatch");
        C *c = dynamic_cast<C *>(w->value.get());
        if(!c) ARCHON_THROW1(InternalException, "Incompatible node type");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException, "Not a CustomFieldNode");

        NodeSequenceCustomField *f =
          const_cast<NodeSequenceCustomField *>(this);
        f->timestamp = time;
        std::remove(f->value.begin(), f->value.end(), Ref<C>(c));
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Ref<ValueBase> x = get(n);
          NodeSequenceValue *s =
            dynamic_cast<NodeSequenceValue *>(x.get());
          if(!s) ARCHON_THROW1(InternalException, "Wrong value type");
          Event e(s, time);
          eventSource.cascadeEvent(&e);
        }
      }


      // Overriding from NodeFieldBase
      bool inject(NodeBase *n, NodeBase *child, Time time, bool cascade) const
      {
        C *c = dynamic_cast<C *>(child);
        if(!c && child)
          ARCHON_THROW1(InternalException,
                        "NodeCustomField::inject: "
                        "Incompatible node");
        CustomFieldNode *m = dynamic_cast<CustomFieldNode *>(n);
        if(!m) ARCHON_THROW1(InternalException, "Not a CustomFieldNode");
        NodeSequenceCustomField *f =
          const_cast<NodeSequenceCustomField *>(this);
        f->timestamp = time;
        f->value.push_back(c);
        if(cascade && isEventTarget) m->handleEvent(index, time);
        if(cascade)
        {
          Ref<ValueBase> x = get(n);
          NodeSequenceValue *s =
            dynamic_cast<NodeSequenceValue *>(x.get());
          if(!s) ARCHON_THROW1(InternalException, "Wrong value type");
          Event e(s, time);
          eventSource.cascadeEvent(&e);
        }
        return true;
      }

      // Overriding from FieldBase
      bool changedSince(const NodeBase *, const Time &t) const
      {
        if(timestamp >= t) return true;
        for(unsigned i=0; i<value.size(); ++i)
        {
          const C *c = value[i].get();
          if(c->changedSince(t)) return true;
        }
        return false;
      }

      // Overriding from FieldBase
      /*
      string dump(const NodeBase *, int level) const
      {
        string indent(2*level, ' ');
        string s = indent + this->getName();
        if(!value.size()) return s + " []\n";
        s += "\n";
        indent + "[\n";
        for(unsigned i=0; i<value.size(); ++i)
        {
          const C *child = value[i].get();
          s += child->dump(level+1);
        }
        return s + indent + "]\n";
      }
      */

      void forwardClear(NodeBase *) const
      {
        NodeSequenceCustomField *f =
          const_cast<NodeSequenceCustomField *>(this);
        f->value.clear();
        f->eventSource.clear();
      }

    private:
      vector<Ref<C> > value;
    };
  }
}

#endif // ARCHON_X3D_CUSTOM_FIELD_H

---