---

ObjectInterface.h

Go to the documentation of this file.

/* SimData: Data Infrastructure for Simulations
 * Copyright (C) 2002 Mark Rose <tm2@stm.lbl.gov>
 * 
 * This file is part of SimData.
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */


#ifndef __SIMDATA_OBJECTINTERFACE_H__
#define __SIMDATA_OBJECTINTERFACE_H__


#include <string>
#include <vector>

#include <SimData/hash_map.h>
#include <SimData/TypeAdapter.h>
#include <SimData/Namespace.h>
#include <SimData/Archive.h>

/*
 * Simulated Partial Template Specialization
 *
 * Adapted from: metactrl.h
 * by Krzysztof Czarnecki & Ulrich Eisenecker
 */
#include <SimData/PTS.h>



NAMESPACE_SIMDATA


class Object;


SIMDATA_EXCEPTION(InterfaceError)




class MemberAccessorBase 
{
public:
        virtual ~MemberAccessorBase() {}

        typedef HASH_MAPS<std::string, MemberAccessorBase *, hashstring, eqstring>::Type map;

        
        virtual void set(Object *, TypeAdapter const &) throw(TypeMismatch) { 
                throw TypeMismatch("Cannot set vector<> '" + name + "' directly, use push_back() instead."); 
        }
        virtual void push_back(Object *, TypeAdapter const &) throw(TypeMismatch) { 
                throw TypeMismatch("Cannot call push_back() on non-vector<> variable '" + name + "'.");
        }
        virtual void clear(Object *) throw(TypeMismatch) { 
                throw TypeMismatch("Cannot call clear() on non-vector<> variable '" + name + "'.");
        }
        virtual TypeAdapter const get(Object *) const throw(TypeMismatch) {
                throw TypeMismatch("get() '" + name + "': not supported for variables of type vector<>.");
        }
        bool isRequired() const { return required; };
        std::string getName() const { return name; }
        virtual void pack(Object *, Packer &) const {
                assert(0);
        }
        virtual void unpack(Object *, UnPacker &) {
                assert(0);
        }
        std::string getType() const { return type; }
        virtual unsigned int getMask() const { return 0; }
protected:
        void setType(BaseType &x) { type = x.typeString(); }
        void setType(double &x) { type = "builtin::double"; }
        void setType(float &x) { type = "builtin::float"; }
        void setType(unsigned int &x) { type = "builtin::uint"; }
        void setType(int &x) { type = "builtin::int"; }
        void setType(unsigned char &x) { type = "builtin::uint8"; }
        void setType(char &x) { type = "builtin::int8"; }
        void setType(unsigned short &x) { type = "builtin::uint16"; }
        void setType(short &x) { type = "builtin::int16"; }
        void setType(bool &x) { type = "builtin::bool"; }
        void setType(std::string const &x) { type = "builtin::string"; }
        MemberAccessorBase(): type("none") {}
        std::string name;
        std::string help;
        std::string type;
        bool required;
};


template <class C, typename T> 
class MemberMaskAccessor: public MemberAccessorBase 
{
        T C::* member;
        T mask;
public:
        MemberMaskAccessor(T C::*pm, std::string name_, int mask_, bool required_) {
                member = pm;
                name = name_;
                mask = mask_;
                required = required_;
                {
                        T prototype;
                        setType(prototype);
                }
        }
        virtual TypeAdapter const get(Object *o) const throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("get(\"" + name + "\"): Object class does not match interface.");
                }
                return TypeAdapter(object->*member);
        }
        virtual void set(Object *o, TypeAdapter const &v) throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("set(\"" + name + "\"): Object class does not match interface.");
                }
                try {
                        if (mask != 0) {
                                T value;
                                v.set(value);
                                if (value != 0) {
                                        object->*member |= mask;
                                } else {
                                        object->*member &= ~mask;
                                }
                        } else {
                                v.set(object->*member);
                        }
                } catch (Exception &e) {
                        e.addMessage("MemberMaskAccessor::set(" + name + "):");
                        throw;
                }
        }
        virtual void pack(Object *o, Packer &p) const {
                C * object = dynamic_cast<C *>(o);
                p(object->*member);
        }
        virtual void unpack(Object *o, UnPacker &p) {
                C * object = dynamic_cast<C *>(o);
                p(object->*member);
        }
        virtual unsigned int getMask() const { return static_cast<unsigned int>(mask); }
};


template <class C, typename T> 
class MemberAccessor: public MemberAccessorBase 
{
        T C::* member;
public:
        MemberAccessor(T C::*pm, std::string name_, bool required_) {
                member = pm;
                name = name_;
                required = required_;
                {
                        T prototype;
                        setType(prototype);
                }
        }
        virtual TypeAdapter const get(Object *o) const throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("get(\"" + name + "\"): Object class does not match interface.");
                }
                return TypeAdapter(object->*member);
        }
        virtual void set(Object *o, TypeAdapter const &v) throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("set(\"" + name + "\"): Object class does not match interface.");
                }
                try {
                        v.set(object->*member);
                } catch (Exception &e) {
                        e.addMessage("MemberAccessor::set(" + name + "):");
                        throw;
                }
        }
        virtual void pack(Object *o, Packer &p) const {
                C * object = dynamic_cast<C *>(o);
                p(object->*member);
        }
        virtual void unpack(Object *o, UnPacker &p) {
                C * object = dynamic_cast<C *>(o);
                p(object->*member);
        }
};


#ifdef __SIMDATA_PTS_SIM
template <class C, typename T> 
class VectorMemberAccessor: public MemberAccessorBase 
{
        T C::* member;
public:
        VectorMemberAccessor(T C::*pm, std::string name_, bool required_) {
                member = pm;
                name = name_;
                required = required_;
                {
                        T prototype;
                        setType(prototype);
                        type = "vector::" + type;
                }
        }
        virtual void push_back(Object *o, TypeAdapter const &v) throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("push_back(\"" + name + "\"): Object class does not match interface.");
                }
                typename T::value_type value;
                try {
                        v.set(value);
                } catch (Exception &e) {
                        e.addMessage("VectorMemberAccessor::push_back(" + name + "):");
                        throw;
                }
                (object->*member).push_back(value);
        }
        virtual void clear(Object *o) throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("push_back(\"" + name + "\"): Object class does not match interface.");
                }
                (object->*member).clear();
        }
        virtual void pack(Object *o, Packer &p) const {
                C * object = dynamic_cast<C *>(o);
                T &m = object->*member;
                int n = static_cast<int>(m.size());
                p(n);
                typename T::iterator idx;
                for (idx = m.begin(); idx != m.end(); idx++) {
                        p(*idx);
                }
        }
        virtual void unpack(Object *o, UnPacker &p) {
                C * object = dynamic_cast<C *>(o);
                T &m = object->*member;
                typename T::value_type temp;
                int n;
                p(n);
                while (--n >= 0) {
                        p(temp);
                        m.push_back(temp);
                }
        }
};

#else // #if !defined(__SIMDATA_PTS_SIM)
template <class C, typename T> 
class MemberAccessor< C, std::vector<T> >: public MemberAccessorBase 
{
        std::vector<T> C::* member;
public:
        MemberAccessor(std::vector<T> C::*pm, std::string name_, bool required_) {
                member = pm;
                name = name_;
                required = required_;
                {
                        T prototype;
                        setType(prototype);
                        type = "vector::" + type;
                }
        }
        virtual void push_back(Object *o, TypeAdapter const &v) throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("push_back(\"" + name + "\"): Object class does not match interface.");
                }
                T value;
                try {
                        v.set(value);
                } catch (Exception &e) {
                        e.addMessage("MemberAccessor::push_back(" + name + "):");
                        throw;
                }
                (object->*member).push_back(value);
        }
        virtual void clear(Object *o) throw(TypeMismatch) {
                C * object = dynamic_cast<C *>(o);
                if (object == NULL) {
                        throw TypeMismatch("push_back(\"" + name + "\"): Object class does not match interface.");
                }
                (object->*member).clear();
        }
        virtual void pack(Object *o, Packer &p) const {
                C * object = dynamic_cast<C *>(o);
                std::vector<T> &m = object->*member;
                int n = static_cast<int>(m.size());
                p(n);
                typename std::vector<T>::iterator idx;
                for (idx = m.begin(); idx != m.end(); ++idx) {
                        p(*idx);
                }
        }
        virtual void unpack(Object *o, UnPacker &p) {
                C * object = dynamic_cast<C *>(o);
                std::vector<T> &m = object->*member;
                T temp;
                int n;
                p(n);
                m.reserve(n);
                while (--n >= 0) {
                        p(temp);
                        m.push_back(temp);
                }
        }
};

template <class C> 
class MemberAccessor< C, int >: public MemberMaskAccessor<C, int> {
public:
        MemberAccessor(int C::*pm, std::string name_, bool required_):
                MemberMaskAccessor<C, int>(pm, name_, 0, required_) { }
        MemberAccessor(int C::*pm, std::string name_, int mask_, bool required_):
                MemberMaskAccessor<C, int>(pm, name_, mask_, required_) { }
};

template <class C> 
class MemberAccessor< C, short >: public MemberMaskAccessor<C, short> {
public:
        MemberAccessor(short C::*pm, std::string name_, bool required_):
                MemberMaskAccessor<C, short>(pm, name_, 0, required_) { }
        MemberAccessor(short C::*pm, std::string name_, int mask_, bool required_):
                MemberMaskAccessor<C, short>(pm, name_, mask_, required_) { }
};

template <class C> 
class MemberAccessor< C, char >: public MemberMaskAccessor<C, char> {
public:
        MemberAccessor(char C::*pm, std::string name_, bool required_):
                MemberMaskAccessor<C, char>(pm, name_, 0, required_) { }
        MemberAccessor(char C::*pm, std::string name_, int mask_, bool required_):
                MemberMaskAccessor<C, char>(pm, name_, mask_, required_) { }
};

#endif // !defined(__SIMDATA_PTS_SIM)


#ifdef __SIMDATA_PTS_SIM

namespace PTS {

        template <typename T>
        char IsVector(std::vector<T> const *);  // no implementation is required

        int IsVector(BaseType const *); // no implementation is required
        int IsVector(float const *);    // no implementation is required
        int IsVector(double const *);   // no implementation is required
        int IsVector(int const *);      // no implementation is required
        int IsVector(bool const*);      // no implementation is required
        int IsVector(char const*);      // no implementation is required
        int IsVector(short const*);     // no implementation is required
        int IsVector(std::string const*);// no implementation is required
        int IsVector(TypeAdapter const *);// no implementation is required

        template <typename T>
        struct ISVECTOR {
                enum { RET = (sizeof(IsVector((T*)0)) == 1) };
        };
        
        template <class C, typename T>
        struct SELECT_ACCESSOR {
                typedef typename meta::IF<ISVECTOR<T>::RET, 
                        simdata::VectorMemberAccessor<C, T>, simdata::MemberAccessor<C, T> >::RET ACCESSOR;
        };
}

#endif // __SIMDATA_PTS_SIM


class ObjectInterfaceBase {
public:
        virtual ~ObjectInterfaceBase() {}

        virtual bool variableExists(std::string const &name) const = 0;

        virtual bool variableRequired(std::string const &name) const = 0;

        virtual std::string variableType(std::string const &name) const = 0;

        virtual std::vector<std::string> getVariableNames() const = 0;
        
        virtual std::vector<std::string> getRequiredNames() const = 0;

        virtual const TypeAdapter get(Object *o, std::string const &name) const = 0;
        
        virtual void set(Object *o, std::string const &name, const TypeAdapter &v) const = 0;
        
        virtual void push_back(Object *o, std::string const &name, const TypeAdapter &v) const = 0;
        
        virtual void clear(Object *o, std::string const &name) const = 0;
};


template <class C>
class ObjectInterface: public ObjectInterfaceBase {
        
        typedef ObjectInterface<C> Self;
        MemberAccessorBase::map table;

        void __not_found(std::string const &name) const throw (InterfaceError) {
                throw InterfaceError("Variable '"+name+"' not found in interface to class '" + C::_getClassName()+"'");
        }

        MemberAccessorBase *getAccessor(std::string const &name) const {
                MemberAccessorBase::map::const_iterator idx = table.find(name);
                if (idx == table.end()) return 0;
                return idx->second;
        }

public:
        ObjectInterface() {}
        virtual ~ObjectInterface() {}

        template<typename T>
        Self& def(std::string const &name, T C::*pm, bool required) throw(InterfaceError) {
                if (variableExists(name)) throw InterfaceError("interface variable \"" + std::string(name) + "\" multiply defined in class '" + C::_getClassName() + "'.");
#ifdef __SIMDATA_PTS_SIM
                table[name] = new typename PTS::SELECT_ACCESSOR<C, T>::ACCESSOR(pm, name, required);
#else
                table[name] = new MemberAccessor<C, T>(pm, name, required);
#endif
                return *this;
        }
        template<typename T>
        Self& def(std::string const &name, T C::*pm, int mask, bool required) throw(InterfaceError) {
                if (variableExists(name)) throw InterfaceError("interface variable \"" + std::string(name) + "\" multiply defined in class '" + C::_getClassName() + "'.");
#ifdef __SIMDATA_PTS_SIM
                table[name] = new typename PTS::SELECT_ACCESSOR<C, T>::ACCESSOR(pm, name, required);
#else
                table[name] = new MemberAccessor<C, T>(pm, name, mask, required);
#endif
                return *this;
        }

        inline Self& pass() { return *this; }

        virtual bool variableExists(std::string const &name) const {
                return table.find(name) != table.end();
        }

        virtual bool variableRequired(std::string const &name) const {
                MemberAccessorBase::map::const_iterator idx = table.find(name);
                if (idx == table.end()) return false;
                return idx->second->isRequired();
        }

        virtual std::string variableType(std::string const &name) const {
                MemberAccessorBase::map::const_iterator idx = table.find(name);
                if (idx == table.end()) __not_found(name);
                return idx->second->getType();
        }

        virtual std::vector<std::string> getVariableNames() const {
                std::vector<std::string> names;
                MemberAccessorBase::map::const_iterator idx;
                for (idx = table.begin(); idx != table.end(); idx++) {
                        names.push_back(idx->first);
                }
                return names;
        }

        virtual std::vector<std::string> getRequiredNames() const {
                std::vector<std::string> names;
                MemberAccessorBase::map::const_iterator idx;
                for (idx = table.begin(); idx != table.end(); idx++) {
                        if (idx->second->isRequired()) {
                                names.push_back(idx->first);
                        }
                }
                return names;
        }

        virtual const TypeAdapter get(Object *o, std::string const &name) const {
                return getAccessor(name)->get(o);
        }
        
        virtual void set(Object *o, std::string const &name, const TypeAdapter &v) const {
                getAccessor(name)->set(o, v);
        }
        
        virtual void push_back(Object *o, std::string const &name, const TypeAdapter &v) const {
                getAccessor(name)->push_back(o, v);
        }
        
        virtual void clear(Object *o, std::string const &name) const {
                getAccessor(name)->clear(o);
        }

private:
        // These methods are currently in limbo.  Minimally they should be
        // updated to use serialize(Archive&), but the usefulness of this
        // feature is still in doubt.
        virtual void pack(Object *o, Packer &p) const {
                MemberAccessorBase::map::const_iterator idx;
                for (idx = table.begin(); idx != table.end(); ++idx) {
                        idx->second->pack(o, p);
                }
        }

        virtual void unpack(Object *o, UnPacker &p) const {
                MemberAccessorBase::map::const_iterator idx;
                for (idx = table.begin(); idx != table.end(); ++idx) {
                        idx->second->unpack(o, p);
                }
        }
};


NAMESPACE_SIMDATA_END


#endif // __SIMDATA_OBJECTINTERFACE_H__

---

SimData version pre-0.4.0. For more information on SimData, visit the SimData Homepage. Generated on Tue Oct 14 12:06:39 2003, using Doxygen 1.2.18.