event.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_EVENT_H
#define ARCHON_X3D_EVENT_H

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

namespace Archon
{
  namespace X3D
  {
    struct Event;


    struct RouteTail: RefObjectBase
    {
      virtual void cascadeEvent(const Event *) const = 0;

      const BackRef<NodeBase> sourceNode;
      const FieldBase *const sourceField;

      virtual bool match(const RouteTail *) const = 0;

    protected:
      RouteTail(Ref<NodeBase> n, const FieldBase *f):
        sourceNode(n), sourceField(f) {}

      unsigned long getTailCountNoLock() { return getUseCountNoLock(); }
    };

    struct RouteHead: virtual RefObjectBase
    {
      const BackRef<NodeBase> targetNode;
      const FieldBase *const targetField;

      virtual Ref<NodeBase> getSourceNode() const = 0;
      virtual const FieldBase *getSourceField() const = 0;

    protected:
      RouteHead(Ref<NodeBase> n, const FieldBase *f):
        targetNode(n), targetField(f) {}

      unsigned long getHeadCountNoLock() { return getUseCountNoLock(); }
    };

    struct Route: RouteTail, RouteHead
    {
      struct AccessException: Exception
      {
        AccessException(string l): Exception(l) {}
      };
      struct TypeException: Exception
      {
        TypeException(string l): Exception(l) {}
      };
      struct ContextException: Exception
      {
        ContextException(string l): Exception(l) {}
      };

      void cascadeEvent(const Event *e) const;

      virtual Ref<NodeBase> getSourceNode() const;
      virtual const FieldBase *getSourceField() const;

      static void add(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                      Ref<NodeBase> targetNode, const FieldBase *targetField)
        throw(AccessException, TypeException, ContextException);

      static bool del(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                      Ref<NodeBase> targetNode, const FieldBase *targetField)
        throw(ContextException);

      void refDispose(Mutex::Lock &l);

      ~Route();

    private:
      Route(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
            Ref<NodeBase> targetNode, const FieldBase *targetField);

      bool match(const RouteTail *) const;
    };




    struct ValueBase: virtual RefObjectBase
    {
      const FieldType *getFieldType() const { return fieldType; }

    protected:
      ValueBase(const FieldType *fieldType): fieldType(fieldType) {}

    private:
      const FieldType *fieldType;
    };

    struct SimpleValueBase: ValueBase
    {
      virtual const void *getValuePtr() const = 0;

    protected:
      SimpleValueBase(const FieldType *fieldType): ValueBase(fieldType) {}
    };

    template<typename T>
    struct SimpleValue: SimpleValueBase
    {
      SimpleValue(const FieldType *fieldType, const T &value):
        SimpleValueBase(fieldType), value(value) {}

      SimpleValue(const FieldType *fieldType):
        SimpleValueBase(fieldType) {}

      const void *getValuePtr() const { return &value; }

      T value;
    };

    struct NodeValue: ValueBase
    {
      NodeValue(const FieldType *fieldType, NodeBase *value):
        ValueBase(fieldType), value(value) {}
      NodeValue(const FieldType *fieldType, Ref<NodeBase> value):
        ValueBase(fieldType), value(value) {}

      Ref<NodeBase> value;
    };

    struct NodeSequenceValue: ValueBase
    {
      NodeSequenceValue(const FieldType *fieldType):
        ValueBase(fieldType) {}

      vector<Ref<NodeBase> > value;

      typedef vector<Ref<NodeBase> >::const_iterator ConstIterator;

      ConstIterator begin() const { return value.begin(); }
      ConstIterator end()   const { return value.end();   }
    };

    struct Event
    {
      Event(Ref<const ValueBase> value, const Time &time): value(value), time(time) {}

      const Ref<const ValueBase> value;
      const Time time;
    };
  }
}

#endif // ARCHON_X3D_EVENT_H

---