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_PROXY_FIELD_H
#define ARCHON_X3D_PROXY_FIELD_H

#include <archon/x3d/proxy/node.H>
#include <archon/x3d/proxy/event.H>

namespace Archon
{
  namespace X3D
  {
    namespace Proxy
    {
      template<typename> struct EventSource;
      template<typename> struct EventTarget;

      struct Field
      {
      protected:
        friend struct ExecutionContext;

        Field() {} // Dummy
        Field(NodeBase *s, unsigned long i): self(s), id(i) {}

        NodeBase *self;
        unsigned long id;

        template<typename T> static void checkDerivation(T *) {}

        template<typename F, typename G>
        static void registerInterest(EventSource<F> *f,
                                     EventHandler<G> *h, bool destroy)
        {
          if(false) { F *p; checkDerivation<G>(p); }
          f->self->registerFieldInterest(f->id, h, destroy);
        }

        template<typename C, typename D>
        static void registerInterest(EventSource<SFNode<C> > *f,
                                     EventHandler<SFNode<C> > *h, bool destroy)
        {
          if(false) { C *p; checkDerivation<D>(p); }
          f->self->registerFieldInterest(f->id, h, destroy);
        }

        template<typename C, typename D>
        static void registerInterest(EventSource<MFNode<C> > *f,
                                     EventHandler<MFNode<C> > *h, bool destroy)
        {
          if(false) { C *p; checkDerivation<D>(p); }
          f->self->registerFieldInterest(f->id, h, destroy);
        }
      };

      template<typename F> struct FieldGet: virtual Field
      {
        typedef typename F::Type T;
        T get() const
        {
          x3d::sai::Value_var w = self->fieldGet(id);
          T v;
          self->importValue(F::index, w,
                            reinterpret_cast<void *>(&v));
          return v;
        }

      protected:
        FieldGet() {}
      };

      template<typename C> struct FieldGet<SFNode<C> >: virtual Field
      {
        typedef typename SFNode<C>::Type T;
        T get() const
        {
          x3d::sai::Value_var w = self->fieldGet(id);
          Ref<NodeBase> v;
          self->importValue(SFNode<C>::index, w,
                            reinterpret_cast<void *>(&v));
          C *c = dynamic_cast<C *>(v.get());
          if(!c) ARCHON_THROW1(Session::ProtocolException,
                               "Incompatible node type");
          return c;
        }

      protected:
        FieldGet() {}
      };

      template<typename C> struct FieldGet<MFNode<C> >: virtual Field
      {
        typedef typename MFNode<C>::Type T;
        T get() const
        {
          x3d::sai::Value_var w = self->fieldGet(id);
          vector<Ref<NodeBase> > v;
          self->importValue(MFNode<C>::index, w,
                            reinterpret_cast<void *>(&v));
          vector<Ref<C> > u(v.size());
          for(unsigned i=0; i<v.size(); ++i)
          {
            C *c = dynamic_cast<C *>(v[i].get());
            if(!c) ARCHON_THROW1(Session::ProtocolException,
                                 "Incompatible node type");
            u[i].reset(c);
          }
          return u;
        }

      protected:
        FieldGet() {}
      };

      template<typename F> struct FieldSet: virtual Field
      {
        typedef typename F::ArgType A;
        void set(A v)
        {
          x3d::sai::Value w;
          self->exportValue(F::index,
                            reinterpret_cast<const void *>(&v), w);
          self->fieldSet(id, w);
        }

      protected:
        FieldSet() {}
      };

      template<typename C> struct FieldSet<SFNode<C> >: virtual Field
      {
        typedef typename SFNode<C>::ArgType A;
        void set(A v)
        {
          Ref<NodeBase> u = v;
          x3d::sai::Value w;
          self->exportValue(SFNode<C>::index,
                            reinterpret_cast<const void *>(&u), w);
          self->fieldSet(id, w);
        }

      protected:
        FieldSet() {}
      };

      template<typename C> struct FieldSet<MFNode<C> >: virtual Field
      {
        typedef typename MFNode<C>::ArgType A;
        void set(A v)
        {
          vector<Ref<NodeBase> > u(v.size());
          for(unsigned i=0; i<v.size(); ++i) u[i] = v[i];
          x3d::sai::Value w;
          self->exportValue(MFNode<C>::index,
                            reinterpret_cast<const void *>(&u), w);
          self->fieldSet(id, w);
        }

      protected:
        FieldSet() {}
      };

      template<typename F> struct FieldSeqGet: virtual FieldGet<F>
      {
        typedef typename F::Single SF;
        typedef typename SF::Type ST;

        ST getAt(unsigned long i) const
        {
          x3d::sai::Value_var w = this->self->fieldGetAt(this->id, i);
          ST v;
          this->self->importValue(SF::index, w,
                                  reinterpret_cast<void *>(&v));
          return v;
        }

      protected:
        FieldSeqGet() {}
      };

      template<typename C>
      struct FieldSeqGet<MFNode<C> >: virtual FieldGet<MFNode<C> >
      {
        typedef typename MFNode<C>::Single SF;
        typedef typename SF::Type ST;

        ST getAt(unsigned long i) const
        {
          x3d::sai::Value_var w = this->self->fieldGetAt(this->id, i);
          Ref<NodeBase> v;
          this->self->importValue(SF::index, w,
                                  reinterpret_cast<void *>(&v));
          C *c = dynamic_cast<C *>(v.get());
          if(!c) ARCHON_THROW1(Session::ProtocolException,
                               "Incompatible node type");
          return c;
        }

      protected:
        FieldSeqGet() {}
      };

      template<typename F> struct FieldSeqSet: virtual FieldSet<F>
      {
        typedef typename F::Single SF;
        typedef typename SF::ArgType SA;

        void setAt(SA v, unsigned long i)
        {
          x3d::sai::Value w;
          this->self->exportValue(SF::index,
                                  reinterpret_cast<const void *>(&v), w);
          this->self->fieldSetAt(this->id, w, i);
        }

        void add(SA v)
        {
          x3d::sai::Value w;
          this->self->exportValue(SF::index,
                                  reinterpret_cast<const void *>(&v), w);
          this->self->fieldAdd(this->id, w);
        }

        void remove(SA v)
        {
          x3d::sai::Value w;
          this->self->exportValue(SF::index,
                                  reinterpret_cast<const void *>(&v), w);
          this->self->fieldDel(this->id, w);
        }

      protected:
        FieldSeqSet() {}
      };

      template<typename C>
      struct FieldSeqSet<MFNode<C> >: virtual FieldSet<MFNode<C> >
      {
        typedef typename MFNode<C>::Single SF;
        typedef typename SF::ArgType SA;

        void setAt(SA v, unsigned long i)
        {
          Ref<NodeBase> u = v;
          x3d::sai::Value w;
          this->self->exportValue(SF::index,
                                  reinterpret_cast<const void *>(&u), w);
          this->self->fieldSetAt(this->id, w, i);
        }

        void add(SA v)
        {
          Ref<NodeBase> u = v;
          x3d::sai::Value w;
          this->self->exportValue(SF::index,
                            reinterpret_cast<const void *>(&u), w);
          this->self->fieldAdd(this->id, w);
        }

        void remove(SA v)
        {
          Ref<NodeBase> u = v;
          x3d::sai::Value w;
          this->self->exportValue(SF::index,
                            reinterpret_cast<const void *>(&u), w);
          this->self->fieldDel(this->id, w);
        }

      protected:
        FieldSeqSet() {}
      };



      template<typename F>
      struct EventSource: virtual FieldGet<F>
      {
        template<typename G>
        void registerInterest(Ref<EventHandler<G> > h)
        {
          Field::registerInterest(this, h.get(), false);
        }

        template<typename G>
        void unregisterInterest(Ref<EventHandler<G> > h)
        {
          Field::registerInterest(this, h.get(), true);
        }
      };

      template<typename F>
      struct EventTarget: virtual FieldSet<F>
      {
      };



      template<typename F>
      struct EventSourceSeq: FieldSeqGet<F>, EventSource<F> {};

      template<typename F>
      struct EventTargetSeq: FieldSeqSet<F>, EventTarget<F> {};



      // Single value fields

      template<typename F>
      struct InitializeOnly: FieldGet<F>, FieldSet<F>
      {
        typedef typename F::Type T;
        typedef typename F::ArgType A;

        InitializeOnly &operator=(A a) { set(a); return *this; }
        operator T() const { return this->get(); }

        InitializeOnly(NodeBase *s, unsigned long i): Field(s, i) {}
      };

      template<typename F>
      struct InputOnly: EventTarget<F>
      {
        typedef typename F::ArgType A;

        InputOnly &operator=(A a) { set(a); return *this; }
        void operator()(A a) { set(a); }

        InputOnly(NodeBase *s, unsigned long i): Field(s, i) {}
      };

      template<typename F>
      struct OutputOnly: EventSource<F>
      {
        typedef typename F::Type T;

        operator T() const { return this->get(); }

        OutputOnly(NodeBase *s, unsigned long i): Field(s, i) {}
      };

      template<typename F>
      struct InputOutput: EventSource<F>, EventTarget<F>
      {
        typedef typename F::Type T;
        typedef typename F::ArgType A;

        InputOutput &operator=(A a) { set(a); return *this; }
        operator T() const { return this->get(); }

        InputOutput(NodeBase *s, unsigned long i): Field(s, i) {}
      };



      // Sequence fields

      template<typename F>
      struct InitializeOnlySeq: FieldSeqGet<F>, FieldSeqSet<F>
      {
        typedef typename F::Type T;
        typedef typename F::ArgType A;

        InitializeOnlySeq &operator=(A a) { set(a); return *this; }
        operator T() const { return this->get(); }

        InitializeOnlySeq(NodeBase *s, unsigned long i): Field(s, i) {}
      };

      template<typename F>
      struct InputOnlySeq: EventTargetSeq<F>
      {
        typedef typename F::ArgType A;

        InputOnlySeq &operator=(A a) { set(a); return *this; }
        void operator()(A a) { set(a); }

        InputOnlySeq(NodeBase *s, unsigned long i): Field(s, i) {}
      };

      template<typename F>
      struct OutputOnlySeq: EventSourceSeq<F>
      {
        typedef typename F::Type T;

        operator T() const { return this->get(); }

        OutputOnlySeq(NodeBase *s, unsigned long i): Field(s, i) {}
      };

      template<typename F>
      struct InputOutputSeq: EventSourceSeq<F>, EventTargetSeq<F>
      {
        typedef typename F::Type T;
        typedef typename F::ArgType A;

        InputOutputSeq &operator=(A a) { set(a); return *this; }
        operator T() const { return this->get(); }

        InputOutputSeq(NodeBase *s, unsigned long i): Field(s, i) {}
      };
    }
  }
}

#endif // ARCHON_X3D_PROXY_FIELD_H

---