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_SAI_VALUE_H
#define ARCHON_X3D_SAI_VALUE_H

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

#include <archon/x3d/sai/exception.H>
#include <archon/x3d/sai/sai.H>

namespace Archon
{
  namespace X3D
  {
    namespace SAI
    {
      using namespace Utilities;

      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;

        Ref<ValueBase> im(const x3d::sai::Value &v)
          throw(TypeMismatchException, IllegalNodeIdException)
        {
          unsigned type = v.type;
          if(type >= fieldTypeIndexRoof) ARCHON_THROW(TypeMismatchException);
          return (this->*importers[type])(v);
        }

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

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

      private:
        typedef Ref<ValueBase> (Porter::*Importer)
          (const x3d::sai::Value &);
        typedef void (Porter::*Exporter)
          (const ValueBase *source, x3d::sai::Value &target);

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

        template<typename F>
        Ref<ValueBase> imScalar(const x3d::sai::Value &);
        template<typename F>
        Ref<ValueBase> imTuple(const x3d::sai::Value &);
        template<typename F>
        Ref<ValueBase> imScalarSeq(const x3d::sai::Value &);
        template<typename F>
        Ref<ValueBase> imTupleSeq(const x3d::sai::Value &);

        Ref<ValueBase> imSFImage(const x3d::sai::Value &);
        Ref<ValueBase> imMFImage(const x3d::sai::Value &);

        Ref<ValueBase> imSFRotation(const x3d::sai::Value &);
        Ref<ValueBase> imMFRotation(const x3d::sai::Value &);

        Ref<ValueBase> imSFTime(const x3d::sai::Value &);
        Ref<ValueBase> imMFTime(const x3d::sai::Value &);


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

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

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

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

#endif // ARCHON_X3D_SAI_VALUE_H

---