Simple Dynamic Loader Library Documentation (v. 1.1.0)

sdl.h

Go to the documentation of this file.

// -*- C++ -*-
//
//  This file is part of the Simple Dynamic Loader Library.
//  See http://www.inf.unisi.edu/carzaniga/sdl/
//
//  Author: Antonio Carzaniga <[email protected]>
//  See the file AUTHORS for full details. 
//
//  Copyright (C) 2005 Antonio Carzaniga
//
//  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, or send email to the author.
//
//
// $Id: sdl.h,v 1.2 2005/01/27 12:42:07 carzanig Exp $
//
#ifndef _sdl_h
#define _sdl_h

#include <map>
#include <string>
#include <exception>

#include <iostream>

using std::exception;
using std::string;
using std::map;

namespace sdl {

enum member_typeid_t { 
    m_unknown_tid       = 0,
    m_int_tid           = 1,
    m_char_tid          = 2,
    m_long_tid          = 3,
    m_bool_tid          = 4,
    m_double_tid        = 5,
    m_float_tid         = 6,
    m_string_tid        = 7,
    m_c_string_tid      = 8,
    m_char_p_tid        = 9,
    m_c_char_p_tid      = 10,
    m_void_p_tid        = 11,

    mf_void_void_tid            = 12,
    mf_void_int_tid             = 13,
    mf_void_char_tid            = 14,
    mf_void_long_tid            = 15,
    mf_void_bool_tid            = 16,
    mf_void_float_tid           = 17,
    mf_void_double_tid          = 18,
    mf_void_c_string_r_tid      = 19,
    mf_void_c_char_p_tid        = 20,
    mf_void_void_p_tid          = 21
};

class Exception : public exception {
public:
    virtual ~Exception() throw() {};

    virtual const char * what() const throw();

    Exception(const string &) throw();
    Exception(const Exception &) throw();

protected:
    string msg;
};

class TypeMismatch : public Exception {
public:
    TypeMismatch() throw();
    TypeMismatch(member_typeid_t a, member_typeid_t e) throw();
    TypeMismatch(member_typeid_t a, 
                 member_typeid_t e1, 
                 member_typeid_t e2) throw();
    TypeMismatch(member_typeid_t a, 
                 member_typeid_t e1, 
                 member_typeid_t e2, 
                 member_typeid_t e3) throw();

    TypeMismatch(const string & m) throw();

private:
    static const string error_msg;
};

class UnknownMember : public Exception {
 public:
    UnknownMember() throw();
    UnknownMember(const string & s) throw();

private:
    static const string error_msg;
};

class Object;

// documentation is in doc/maindoc.h
//
class Member {
private:
    const Object * object;
    const string & name;

    Member(const Object * o, const string & n) : object(o), name(n) {};
    friend class Object;

public:
    template <typename T>
    void operator () (const T & x) throw(TypeMismatch, UnknownMember);

    template <typename T> 
    T operator = (T x) throw(TypeMismatch, UnknownMember);

    operator int () const throw(TypeMismatch, UnknownMember);
    operator char () const throw(TypeMismatch, UnknownMember);
    operator long () const throw(TypeMismatch, UnknownMember);
    operator bool () const throw(TypeMismatch, UnknownMember);
    operator double () const throw(TypeMismatch, UnknownMember);
    operator float () const throw(TypeMismatch, UnknownMember);
    operator const char * () const throw(TypeMismatch, UnknownMember);
    operator char * () const throw(TypeMismatch, UnknownMember);
};

// documentation is in doc/maindoc.h
//
class Object {
    //  Notice that the library support only a restricted set of types
    //  for data members and member functions.  Extending this class
    //  and the ConcreteClass template to support more complex methods
    //  is trivial, although a bit tedious.  Same deal for the
    //  extension of the available constructors in Class and
    //  ConcreteClass.
    //
public:
    virtual ~Object() {};

    virtual void call(const string & name) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, int x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, char x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, long x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, bool x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, float x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, double x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, const string & x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, const char * x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void call(const string & name, void * x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string & name, int x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string & name, char x) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, long) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, bool) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, float) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, double) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, char *) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, const char *) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void assign(const string &, void *) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual int & int_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual char & char_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual long & long_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual bool & bool_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual double & double_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual float & float_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual char * & char_p_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual const char * & const_char_p_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual string & string_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual const string & const_string_attribute(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual int int_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual char char_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual long long_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual bool bool_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual double double_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual float float_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual char * char_p_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual const char * const_char_p_value(const string &) const
        throw(TypeMismatch, UnknownMember) = 0;
    virtual void * this_pointer() const = 0;

    Member member(const string & name) const throw() {
        return Member(this, name);
    }
};

class Class {
public:
    virtual ~Class() {};

    virtual Object * new_object() const throw(UnknownMember) = 0;
    virtual Object * new_object(int c) const throw(UnknownMember) = 0;
    virtual Object * new_object(char c) const throw(UnknownMember) = 0;
    virtual Object * new_object(long c) const throw(UnknownMember) = 0;
    virtual Object * new_object(bool c) const throw(UnknownMember) = 0;
    virtual Object * new_object(float c) const throw(UnknownMember) = 0;
    virtual Object * new_object(double c) const throw(UnknownMember) = 0;
    virtual Object * new_object(const string & c) const throw(UnknownMember)=0;
    virtual Object * new_object(const char * c) const throw(UnknownMember) = 0;
    virtual Object * new_object(void * c) const throw(UnknownMember) = 0;
};

extern const char * type_declarator(unsigned int) throw();

template<class T>
class ConcreteClass : public Class {
private:
    struct MemberDescr {
        member_typeid_t         type;
        union {
            int                 T::*m_int;
            char                T::*m_char;
            long                T::*m_long;
            bool                T::*m_bool;
            double              T::*m_double;
            float               T::*m_float;
            string              T::*m_string;
            const string        T::*m_c_string;
            char *              T::*m_char_p;
            const char *        T::*m_c_char_p;
            void *              T::*m_void_p;

            void                (T::*mf_void_void)(void);
            void                (T::*mf_void_int)(int);
            void                (T::*mf_void_char)(char);
            void                (T::*mf_void_long)(long);
            void                (T::*mf_void_bool)(bool);
            void                (T::*mf_void_float)(float);
            void                (T::*mf_void_double)(double);
            void                (T::*mf_void_c_string_r)(const string &);
            void                (T::*mf_void_c_char_p)(const char *);
            void                (T::*mf_void_void_p)(void *);
        };
    };

    typedef map<string,MemberDescr> MembersMap;
    MembersMap members;

    T * (*cf_void)(void);
    T * (*cf_int)(int);
    T * (*cf_char)(char);
    T * (*cf_long)(long);
    T * (*cf_bool)(bool);
    T * (*cf_float)(float);
    T * (*cf_double)(double);
    T * (*cf_c_string_r)(const string &);
    T * (*cf_c_char_p)(const char *);
    T * (*cf_void_p)(void *);

    class ObjectProxy : public Object {
    private:
        const MembersMap & members;
        T * object;

        inline const MemberDescr & member(const string & name) const 
            throw(UnknownMember) {
            typename MembersMap::const_iterator i = members.find(name);
            if (i == members.end()) {
                throw UnknownMember(name);
            } else {
                return (*i).second;
            }
        }
    public:
        ObjectProxy(const ConcreteClass * c, T * o)
            : members(c->members), object(o) {};

        virtual void call(const string & name) const 
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_void_tid: (object->*(d.mf_void_void))(); break;
            default: throw TypeMismatch(d.type, mf_void_void_tid);
            }
        }
        virtual void call(const string & name, int v) const 
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_int_tid: (object->*(d.mf_void_int))(v); break;
            case mf_void_long_tid: (object->*(d.mf_void_long))(v); break;
            default: throw TypeMismatch(d.type, 
                                        mf_void_int_tid, mf_void_long_tid);
            }
        }
        virtual void call(const string & name, char v) const 
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_char_tid: (object->*(d.mf_void_char))(v); break;
            case mf_void_int_tid: (object->*(d.mf_void_int))(v); break;
            case mf_void_long_tid: (object->*(d.mf_void_long))(v); break;
            default: throw TypeMismatch(d.type, mf_void_char_tid,
                                        mf_void_int_tid, mf_void_long_tid);
            }
        }
        virtual void call(const string & name, long v) const 
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_long_tid: (object->*(d.mf_void_long))(v); break;
            default: throw TypeMismatch(d.type, mf_void_long_tid);
            }
        }
        virtual void call(const string & name, bool v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_bool_tid: (object->*(d.mf_void_bool))(v); break;
            default: throw TypeMismatch(d.type, mf_void_bool_tid);
            }
        }
        virtual void call(const string & name, float v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_float_tid: (object->*(d.mf_void_float))(v); break;
            case mf_void_double_tid: (object->*(d.mf_void_double))(v); break;
            default: throw TypeMismatch(d.type, mf_void_bool_tid);
            }
        }
        virtual void call(const string & name, double v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_double_tid: (object->*(d.mf_void_double))(v); break;
            default: throw TypeMismatch(d.type, mf_void_double_tid);
            }
        }
        virtual void call(const string & name, const string & v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_c_string_r_tid: 
                (object->*(d.mf_void_c_string_r))(v); break;
            default: throw TypeMismatch(d.type, mf_void_c_string_r_tid);
            }
        }
        virtual void call(const string & name, const char * v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_c_string_r_tid: 
                (object->*(d.mf_void_c_string_r))(string(v)); break;
            case mf_void_c_char_p_tid: 
                (object->*(d.mf_void_c_char_p))(v); break;
            default: throw TypeMismatch(d.type, mf_void_c_string_r_tid,
                                        mf_void_c_char_p_tid);
            }
        }
        virtual void call(const string & name, void * v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case mf_void_void_p_tid: 
                (object->*(d.mf_void_void_p))(v); break;
            default: throw TypeMismatch(d.type, mf_void_void_p_tid);
            }
        }
        virtual void assign(const string & name, int v) const 
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_int_tid: (object->*(d.m_int)) = v; break;
            case m_long_tid: (object->*(d.m_long)) = v; break;
            default: throw TypeMismatch(d.type, m_int_tid, m_long_tid);
            }
        }
        virtual void assign(const string & name, char v) const 
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_char_tid: (object->*(d.m_char)) = v; break;
            case m_int_tid: (object->*(d.m_int)) = v; break;
            case m_long_tid: (object->*(d.m_long)) = v; break;
            default: throw TypeMismatch(d.type, m_char_tid,
                                        m_int_tid, m_long_tid);
            }
        }
        virtual void assign(const string & name, long v) const 
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_long_tid: (object->*(d.m_long)) = v; break;
            default: throw TypeMismatch(d.type, m_long_tid);
            }
        }
        virtual void assign(const string & name, bool v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_bool_tid: (object->*(d.m_bool)) = v; break;
            default: throw TypeMismatch(d.type, m_bool_tid);
            }
        }
        virtual void assign(const string & name, float v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_float_tid: (object->*(d.m_float)) = v; break;
            case m_double_tid: (object->*(d.m_double)) = v; break;
            default: throw TypeMismatch(d.type, m_float_tid, m_double_tid);
            }
        }
        virtual void assign(const string & name, double v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_double_tid: (object->*(d.m_double)) = v; break;
            default: throw TypeMismatch(d.type, m_double_tid);
            }
        }
        virtual void assign(const string & name, const string & v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_string_tid: (object->*(d.m_string)) = v; break;
            default: throw TypeMismatch(d.type, m_string_tid);
            }
        }
        virtual void assign(const string & name, char * v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_char_p_tid: (object->*(d.m_char_p)) = v; break;
            case m_string_tid: (object->*(d.m_string)) = v; break;
            case m_c_char_p_tid: (object->*(d.m_c_char_p)) = v; break;
            default: throw TypeMismatch(d.type, m_char_p_tid,
                                        m_string_tid, m_c_char_p_tid);
            }
        }
        virtual void assign(const string & name, const char * v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_string_tid: (object->*(d.m_string)) = v; break;
            case m_c_char_p_tid: (object->*(d.m_c_char_p)) = v; break;
            default: throw TypeMismatch(d.type, m_string_tid, m_c_char_p_tid);
            }
        }
        virtual void assign(const string & name, void * v) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_void_p_tid: (object->*(d.m_void_p)) = v;; break;
            default: throw TypeMismatch(d.type, m_void_p_tid);
            }
        }

        virtual int & int_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_int_tid: return (object->*(d.m_int)); break;
            default: throw TypeMismatch(d.type, m_int_tid);
            }
        }
        virtual char & char_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_char_tid: return (object->*(d.m_char)); break;
            default: throw TypeMismatch(d.type, m_char_tid);
            }
        }
        virtual long & long_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_long_tid: return (object->*(d.m_long)); break;
            default: throw TypeMismatch(d.type, m_long_tid);
            }
        }
        virtual bool & bool_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_bool_tid: return (object->*(d.m_bool)); break;
            default: throw TypeMismatch(d.type, m_bool_tid);
            }
        }
        virtual double & double_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_double_tid: return (object->*(d.m_double)); break;
            default: throw TypeMismatch(d.type, m_double_tid);
            }
        }
        virtual float & float_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_float_tid: return (object->*(d.m_float)); break;
            default: throw TypeMismatch(d.type, m_float_tid);
            }
        }
        virtual string & string_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_string_tid: return (object->*(d.m_string)); break;
            default: throw TypeMismatch(d.type, m_string_tid);
            }
        }
        virtual const string & const_string_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_c_string_tid: return (object->*(d.m_c_string)); break;
            default: throw TypeMismatch(d.type, m_c_string_tid);
            }
        }
        virtual char * & char_p_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_char_p_tid: return (object->*(d.m_char_p)); break;
            default: throw TypeMismatch(d.type, m_char_p_tid);
            }
        }
        virtual const char * & const_char_p_attribute(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_c_char_p_tid: return (object->*(d.m_c_char_p)); break;
            default: throw TypeMismatch(d.type, m_c_char_p_tid);
            }
        }

        virtual int int_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_int_tid: return (object->*(d.m_int)); break;
            case m_char_tid: return (object->*(d.m_char)); break;
            default: throw TypeMismatch(d.type, m_int_tid, m_char_tid);
            }
        }
        virtual char char_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_char_tid: return (object->*(d.m_char)); break;
            default: throw TypeMismatch(d.type, m_char_tid);
            }
        }
        virtual long long_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_long_tid: return (object->*(d.m_long)); break;
            case m_int_tid: return (object->*(d.m_int)); break;
            case m_char_tid: return (object->*(d.m_char)); break;
            default: throw TypeMismatch(d.type, m_long_tid, 
                                        m_int_tid, m_char_tid);
            }
        }
        virtual bool bool_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_bool_tid: return (object->*(d.m_bool)); break;
            default: throw TypeMismatch(d.type, m_bool_tid);
            }
        }
        virtual double double_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_float_tid: return (object->*(d.m_float)); break;
            case m_double_tid: return (object->*(d.m_double)); break;
            default: throw TypeMismatch(d.type, m_double_tid, m_float_tid);
            }
        }
        virtual float float_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_float_tid: return (object->*(d.m_float)); break;
            default: throw TypeMismatch(d.type, m_float_tid);
            }
        }
        virtual char * char_p_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_char_p_tid: return (object->*(d.m_char_p)); break;
            default: throw TypeMismatch(d.type, m_char_p_tid);
            }
        }
        virtual const char * const_char_p_value(const string & name) const
            throw(TypeMismatch, UnknownMember) {
            const MemberDescr & d = member(name);
            switch(d.type) {
            case m_c_char_p_tid: return (object->*(d.m_c_char_p)); break;
            case m_string_tid: return (object->*(d.m_string)).c_str(); break;
            case m_c_string_tid: return (object->*(d.m_c_string)).c_str(); break;
            case m_char_p_tid: return (object->*(d.m_char_p)); break;
            default: throw TypeMismatch(d.type, m_c_char_p_tid);
            }
        }

        virtual void * this_pointer() const { return object; }
    };

public:
    ConcreteClass() throw ()
        : members(),
          cf_void(0),
          cf_int(0),
          cf_char(0),
          cf_long(0),
          cf_bool(0),
          cf_float(0),
          cf_double(0),
          cf_c_string_r(0),
          cf_c_char_p(0),
          cf_void_p(0)
    {}

    virtual Object * new_object() const throw(UnknownMember) {
        if (cf_void == 0) throw UnknownMember("constructor()");
        return new ObjectProxy(this, (cf_void)());
    }
    virtual Object * new_object(int c) const throw(UnknownMember) {
        if (cf_int == 0) throw UnknownMember("constructor(int)");
        return new ObjectProxy(this, (cf_int)(c));
    }
    virtual Object * new_object(char c) const throw(UnknownMember) {
        if (cf_char == 0) throw UnknownMember("constructor(char)");
        return new ObjectProxy(this, (cf_char)(c));
    }
    virtual Object * new_object(long c) const throw(UnknownMember) {
        if (cf_long == 0) throw UnknownMember("constructor(long)");
        return new ObjectProxy(this, (cf_long)(c));
    }
    virtual Object * new_object(bool c) const throw(UnknownMember) {
        if (cf_bool == 0) throw UnknownMember("constructor(bool)");
        return new ObjectProxy(this, (cf_bool)(c));
    }
    virtual Object * new_object(float c) const throw(UnknownMember) {
        if (cf_float == 0) throw UnknownMember("constructor(float)");
        return new ObjectProxy(this, (cf_float)(c));
    }
    virtual Object * new_object(double c) const throw(UnknownMember) {
        if (cf_double == 0) throw UnknownMember("constructor(double)");
        return new ObjectProxy(this, (cf_double)(c));
    }
    virtual Object * new_object(const string & c) const throw(UnknownMember) {
        if (cf_c_string_r == 0) throw UnknownMember("constructor(const string &)");
        return new ObjectProxy(this, (cf_c_string_r)(c));
    }
    virtual Object * new_object(const char * c) const throw(UnknownMember) {
        if (cf_c_char_p == 0) throw UnknownMember("constructor(const char *)");
        return new ObjectProxy(this, (cf_c_char_p)(c));
    }
    virtual Object * new_object(void * c) const throw(UnknownMember) {
        if (cf_void_p == 0) throw UnknownMember("constructor(void *)");
        return new ObjectProxy(this, (cf_void_p)(c));
    }

    void bind(const string & name, int T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_int = m;
        md.type = m_int_tid;
    }
        
    void bind(const string & name, char T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_char = m;
        md.type = m_char_tid;
    }

    void bind(const string & name, long T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_long = m;
        md.type = m_long_tid;
    }

    void bind(const string & name, bool T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_bool = m;
        md.type = m_bool_tid;
    }

    void bind(const string & name, double T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_double = m;
        md.type = m_double_tid;
    }

    void bind(const string & name, float T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_float = m;
        md.type = m_float_tid;
    }

    void bind(const string & name, string T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_string = m;
        md.type = m_string_tid;
    }

    void bind(const string & name, char * T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_char_p = m;
        md.type = m_char_p_tid;
    }

    void bind(const string & name, const char * T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_c_char_p = m;
        md.type = m_c_char_p_tid;
    }

    void bind(const string & name, void * T::*m) throw() {
        MemberDescr & md = members[name];
        md.m_void_p = m;
        md.type = m_void_p_tid;
    }

    void bind(const string & name, void (T::*m)()) throw() {
        MemberDescr & md = members[name];
        md.mf_void_void = m;
        md.type = mf_void_void_tid;
    }

    void bind(const string & name, void (T::*m)(int)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_int = m;
        md.type = mf_void_int_tid;
    }

    void bind(const string & name, void (T::*m)(char)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_char = m;
        md.type = mf_void_char_tid;
    }

    void bind(const string & name, void (T::*m)(long)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_long = m;
        md.type = mf_void_long_tid;
    }

    void bind(const string & name, void (T::*m)(bool)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_bool = m;
        md.type = mf_void_bool_tid;
    }

    void bind(const string & name, void (T::*m)(float)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_float = m;
        md.type = mf_void_float_tid;
    }

    void bind(const string & name, void (T::*m)(double)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_double = m;
        md.type = mf_void_double_tid;
    }

    void bind(const string & name, void (T::*m)(const string &)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_c_string_r = m;
        md.type = mf_void_c_string_r_tid;
    }

    void bind(const string & name, void (T::*m)(const char *)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_c_char_p = m;
        md.type = mf_void_c_char_p_tid;
    }

    void bind(const string & name, void (T::*m)(void *)) throw() {
        MemberDescr & md = members[name];
        md.mf_void_void_p = m;
        md.type = mf_void_void_p_tid;
    }
    void set_constructor(T* (c)(void)) throw() { cf_void = c; }
    void set_constructor(T* (c)(int)) throw() { cf_int = c; }
    void set_constructor(T* (c)(char)) throw() { cf_char = c; }
    void set_constructor(T* (c)(long)) throw() { cf_long = c; }
    void set_constructor(T* (c)(bool)) throw() { cf_bool = c; }
    void set_constructor(T* (c)(float)) throw() { cf_float = c; }
    void set_constructor(T* (c)(double)) throw() { cf_double = c; }
    void set_constructor(T* (c)(const string &)) throw() { cf_c_string_r = c; }
    void set_constructor(T* (c)(const char *)) throw() { cf_c_char_p = c; }
    void set_constructor(T* (c)(void *)) throw() { cf_void_p = c; }
};

extern Class * load_class(const string & classname, 
                          const string & libname) throw(Exception);

extern void close_libraries();

template <typename T>
inline void Member::operator () (const T & x) throw(TypeMismatch, 
                                                    UnknownMember) {
    object->call(name, x);
}

template <typename T>
T Member::operator = (T x) throw(TypeMismatch, UnknownMember) {
    object->assign(name, x);
    return x;
}

inline Member::operator int () const throw(TypeMismatch, UnknownMember) {
    return object->int_value(name);
}
inline Member::operator char () const throw(TypeMismatch, UnknownMember) {
    return object->char_value(name);
}
inline Member::operator long () const throw(TypeMismatch, UnknownMember) {
    return object->long_value(name);
}
inline Member::operator bool () const throw(TypeMismatch, UnknownMember) {
    return object->bool_value(name);
}
inline Member::operator double () const throw(TypeMismatch, UnknownMember) {
    return object->double_value(name);
}
inline Member::operator float () const throw(TypeMismatch, UnknownMember) {
    return object->float_value(name);
}
inline Member::operator const char * () const throw(TypeMismatch, UnknownMember) {
    return object->const_char_p_value(name);
}
inline Member::operator char * () const throw(TypeMismatch, UnknownMember) {
    return object->char_p_value(name);
}
}; // end namespace sdl

#endif /* _sdl_h */

Copyright © 2005 Antonio Carzaniga.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". This documentation is authored and maintained by Antonio Carzaniga