value.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_VALUE_H
#define ARCHON_X3D_PROXY_VALUE_H

#include <archon/x3d/proxy/field_type.H>
#include <archon/x3d/proxy/sai.H>

namespace Archon
{
  namespace X3D
  {
    namespace Proxy
    {
      using namespace Utilities;

      struct NodeBase;

      struct Porter
      {
        struct TypeMismatchException: Exception
        {
          TypeMismatchException(string l): Exception(l) {}
        };

        struct IllegalNodeIdException: Exception
        {
          IllegalNodeIdException(string l): Exception(l) {}
        };

        virtual unsigned long node2id(Ref<NodeBase>) = 0;

        virtual Ref<NodeBase> id2node(unsigned long)
          throw(IllegalNodeIdException) = 0;


        void im(unsigned long type,
                const x3d::sai::Value &source, void *target)
          throw(TypeMismatchException, IllegalNodeIdException)
        {
          if(type != source.type) ARCHON_THROW(TypeMismatchException);
          (this->*importers[type])(source, target);
        }

        void ex(unsigned long type,
                const void *source, x3d::sai::Value &target)
        {
          (this->*exporters[type])(source, target);
          target.type = type;
        }


      protected:
        Porter();
        virtual ~Porter() {}

      private:
        typedef void (Porter::*Importer)
          (const x3d::sai::Value &source, void *target);

        typedef void (Porter::*Exporter)
          (const void *source, x3d::sai::Value &target);


        vector<Importer> importers;
        vector<Exporter> exporters;


        template<typename F> void imScalar(const x3d::sai::Value &, void *);
        template<typename F> void imTuple(const x3d::sai::Value &, void *);
        template<typename F> void imScalarSeq(const x3d::sai::Value &, void *);
        template<typename F> void imTupleSeq(const x3d::sai::Value &, void *);

        void imSFImage(const x3d::sai::Value &, void *);
        void imMFImage(const x3d::sai::Value &, void *);

        void imSFRotation(const x3d::sai::Value &, void *);
        void imMFRotation(const x3d::sai::Value &, void *);

        void imSFTime(const x3d::sai::Value &, void *);
        void imMFTime(const x3d::sai::Value &, void *);


        template<typename F> void exScalar(const void *, x3d::sai::Value &);
        template<typename F> void exTuple(const void *, x3d::sai::Value &);
        template<typename F> void exScalarSeq(const void *, x3d::sai::Value &);
        template<typename F> void exTupleSeq(const void *, x3d::sai::Value &);

        void exSFImage(const void *, x3d::sai::Value &);
        void exMFImage(const void *, x3d::sai::Value &);

        void exSFRotation(const void *, x3d::sai::Value &);
        void exMFRotation(const void *, x3d::sai::Value &);

        void exSFTime(const void *, x3d::sai::Value &);
        void exMFTime(const void *, x3d::sai::Value &);
      };
    }
  }
}

#endif // ARCHON_X3D_PROXY_VALUE_H

---