00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifndef _sdl_h
00030 #define _sdl_h
00031
00032 #include <map>
00033 #include <string>
00034 #include <exception>
00035
00036 #include <iostream>
00037
00038 using std::exception;
00039 using std::string;
00040 using std::map;
00041
00047 namespace sdl {
00048
00049 enum member_typeid_t {
00050 m_unknown_tid = 0,
00051 m_int_tid = 1,
00052 m_char_tid = 2,
00053 m_long_tid = 3,
00054 m_bool_tid = 4,
00055 m_double_tid = 5,
00056 m_float_tid = 6,
00057 m_string_tid = 7,
00058 m_c_string_tid = 8,
00059 m_char_p_tid = 9,
00060 m_c_char_p_tid = 10,
00061 m_void_p_tid = 11,
00062
00063 mf_void_void_tid = 12,
00064 mf_void_int_tid = 13,
00065 mf_void_char_tid = 14,
00066 mf_void_long_tid = 15,
00067 mf_void_bool_tid = 16,
00068 mf_void_float_tid = 17,
00069 mf_void_double_tid = 18,
00070 mf_void_c_string_r_tid = 19,
00071 mf_void_c_char_p_tid = 20,
00072 mf_void_void_p_tid = 21
00073 };
00074
00077 class Exception : public exception {
00078 public:
00079 virtual ~Exception() throw() {};
00080
00082 virtual const char * what() const throw();
00083
00085 Exception(const string &) throw();
00087 Exception(const Exception &) throw();
00088
00089 protected:
00090 string msg;
00091 };
00092
00099 class TypeMismatch : public Exception {
00100 public:
00102 TypeMismatch() throw();
00108 TypeMismatch(member_typeid_t a, member_typeid_t e) throw();
00115 TypeMismatch(member_typeid_t a,
00116 member_typeid_t e1,
00117 member_typeid_t e2) throw();
00125 TypeMismatch(member_typeid_t a,
00126 member_typeid_t e1,
00127 member_typeid_t e2,
00128 member_typeid_t e3) throw();
00129
00131 TypeMismatch(const string & m) throw();
00132
00133 private:
00134 static const string error_msg;
00135 };
00136
00142 class UnknownMember : public Exception {
00143 public:
00145 UnknownMember() throw();
00147 UnknownMember(const string & s) throw();
00148
00149 private:
00150 static const string error_msg;
00151 };
00152
00153 class Object;
00154
00155
00156
00157 class Member {
00158 private:
00159 const Object * object;
00160 const string & name;
00161
00162 Member(const Object * o, const string & n) : object(o), name(n) {};
00163 friend class Object;
00164
00165 public:
00167 template <typename T>
00168 void operator () (const T & x) throw(TypeMismatch, UnknownMember);
00169
00171 template <typename T>
00172 T operator = (T x) throw(TypeMismatch, UnknownMember);
00173
00175 operator int () const throw(TypeMismatch, UnknownMember);
00177 operator char () const throw(TypeMismatch, UnknownMember);
00179 operator long () const throw(TypeMismatch, UnknownMember);
00181 operator bool () const throw(TypeMismatch, UnknownMember);
00183 operator double () const throw(TypeMismatch, UnknownMember);
00185 operator float () const throw(TypeMismatch, UnknownMember);
00187 operator const char * () const throw(TypeMismatch, UnknownMember);
00189 operator char * () const throw(TypeMismatch, UnknownMember);
00190 };
00191
00192
00193
00194 class Object {
00195
00196
00197
00198
00199
00200
00201
00202 public:
00203 virtual ~Object() {};
00204
00221 virtual void call(const string & name) const
00222 throw(TypeMismatch, UnknownMember) = 0;
00235 virtual void call(const string & name, int x) const
00236 throw(TypeMismatch, UnknownMember) = 0;
00250 virtual void call(const string & name, char x) const
00251 throw(TypeMismatch, UnknownMember) = 0;
00264 virtual void call(const string & name, long x) const
00265 throw(TypeMismatch, UnknownMember) = 0;
00278 virtual void call(const string & name, bool x) const
00279 throw(TypeMismatch, UnknownMember) = 0;
00293 virtual void call(const string & name, float x) const
00294 throw(TypeMismatch, UnknownMember) = 0;
00307 virtual void call(const string & name, double x) const
00308 throw(TypeMismatch, UnknownMember) = 0;
00321 virtual void call(const string & name, const string & x) const
00322 throw(TypeMismatch, UnknownMember) = 0;
00335 virtual void call(const string & name, const char * x) const
00336 throw(TypeMismatch, UnknownMember) = 0;
00349 virtual void call(const string & name, void * x) const
00350 throw(TypeMismatch, UnknownMember) = 0;
00371 virtual void assign(const string & name, int x) const
00372 throw(TypeMismatch, UnknownMember) = 0;
00385 virtual void assign(const string & name, char x) const
00386 throw(TypeMismatch, UnknownMember) = 0;
00392 virtual void assign(const string &, long) const
00393 throw(TypeMismatch, UnknownMember) = 0;
00399 virtual void assign(const string &, bool) const
00400 throw(TypeMismatch, UnknownMember) = 0;
00407 virtual void assign(const string &, float) const
00408 throw(TypeMismatch, UnknownMember) = 0;
00414 virtual void assign(const string &, double) const
00415 throw(TypeMismatch, UnknownMember) = 0;
00421 virtual void assign(const string &, const string &) const
00422 throw(TypeMismatch, UnknownMember) = 0;
00429 virtual void assign(const string &, char *) const
00430 throw(TypeMismatch, UnknownMember) = 0;
00436 virtual void assign(const string &, const char *) const
00437 throw(TypeMismatch, UnknownMember) = 0;
00443 virtual void assign(const string &, void *) const
00444 throw(TypeMismatch, UnknownMember) = 0;
00459 virtual int & int_attribute(const string &) const
00460 throw(TypeMismatch, UnknownMember) = 0;
00466 virtual char & char_attribute(const string &) const
00467 throw(TypeMismatch, UnknownMember) = 0;
00473 virtual long & long_attribute(const string &) const
00474 throw(TypeMismatch, UnknownMember) = 0;
00480 virtual bool & bool_attribute(const string &) const
00481 throw(TypeMismatch, UnknownMember) = 0;
00487 virtual double & double_attribute(const string &) const
00488 throw(TypeMismatch, UnknownMember) = 0;
00494 virtual float & float_attribute(const string &) const
00495 throw(TypeMismatch, UnknownMember) = 0;
00501 virtual char * & char_p_attribute(const string &) const
00502 throw(TypeMismatch, UnknownMember) = 0;
00508 virtual const char * & const_char_p_attribute(const string &) const
00509 throw(TypeMismatch, UnknownMember) = 0;
00515 virtual string & string_attribute(const string &) const
00516 throw(TypeMismatch, UnknownMember) = 0;
00522 virtual const string & const_string_attribute(const string &) const
00523 throw(TypeMismatch, UnknownMember) = 0;
00538 virtual int int_value(const string &) const
00539 throw(TypeMismatch, UnknownMember) = 0;
00545 virtual char char_value(const string &) const
00546 throw(TypeMismatch, UnknownMember) = 0;
00552 virtual long long_value(const string &) const
00553 throw(TypeMismatch, UnknownMember) = 0;
00559 virtual bool bool_value(const string &) const
00560 throw(TypeMismatch, UnknownMember) = 0;
00566 virtual double double_value(const string &) const
00567 throw(TypeMismatch, UnknownMember) = 0;
00573 virtual float float_value(const string &) const
00574 throw(TypeMismatch, UnknownMember) = 0;
00580 virtual char * char_p_value(const string &) const
00581 throw(TypeMismatch, UnknownMember) = 0;
00587 virtual const char * const_char_p_value(const string &) const
00588 throw(TypeMismatch, UnknownMember) = 0;
00596 virtual void * this_pointer() const = 0;
00597
00604 Member member(const string & name) const throw() {
00605 return Member(this, name);
00606 }
00608 };
00609
00620 class Class {
00621 public:
00622 virtual ~Class() {};
00623
00629 virtual Object * new_object() const throw(UnknownMember) = 0;
00635 virtual Object * new_object(int c) const throw(UnknownMember) = 0;
00641 virtual Object * new_object(char c) const throw(UnknownMember) = 0;
00647 virtual Object * new_object(long c) const throw(UnknownMember) = 0;
00653 virtual Object * new_object(bool c) const throw(UnknownMember) = 0;
00659 virtual Object * new_object(float c) const throw(UnknownMember) = 0;
00665 virtual Object * new_object(double c) const throw(UnknownMember) = 0;
00671 virtual Object * new_object(const string & c) const throw(UnknownMember)=0;
00677 virtual Object * new_object(const char * c) const throw(UnknownMember) = 0;
00683 virtual Object * new_object(void * c) const throw(UnknownMember) = 0;
00684 };
00685
00686 extern const char * type_declarator(unsigned int) throw();
00687
00695 template<class T>
00696 class ConcreteClass : public Class {
00697 private:
00698 struct MemberDescr {
00699 member_typeid_t type;
00700 union {
00701 int T::*m_int;
00702 char T::*m_char;
00703 long T::*m_long;
00704 bool T::*m_bool;
00705 double T::*m_double;
00706 float T::*m_float;
00707 string T::*m_string;
00708 const string T::*m_c_string;
00709 char * T::*m_char_p;
00710 const char * T::*m_c_char_p;
00711 void * T::*m_void_p;
00712
00713 void (T::*mf_void_void)(void);
00714 void (T::*mf_void_int)(int);
00715 void (T::*mf_void_char)(char);
00716 void (T::*mf_void_long)(long);
00717 void (T::*mf_void_bool)(bool);
00718 void (T::*mf_void_float)(float);
00719 void (T::*mf_void_double)(double);
00720 void (T::*mf_void_c_string_r)(const string &);
00721 void (T::*mf_void_c_char_p)(const char *);
00722 void (T::*mf_void_void_p)(void *);
00723 };
00724 };
00725
00726 typedef map<string,MemberDescr> MembersMap;
00727 MembersMap members;
00728
00729 T * (*cf_void)(void);
00730 T * (*cf_int)(int);
00731 T * (*cf_char)(char);
00732 T * (*cf_long)(long);
00733 T * (*cf_bool)(bool);
00734 T * (*cf_float)(float);
00735 T * (*cf_double)(double);
00736 T * (*cf_c_string_r)(const string &);
00737 T * (*cf_c_char_p)(const char *);
00738 T * (*cf_void_p)(void *);
00739
00740 class ObjectProxy : public Object {
00741 private:
00742 const MembersMap & members;
00743 T * object;
00744
00745 inline const MemberDescr & member(const string & name) const
00746 throw(UnknownMember) {
00747 typename MembersMap::const_iterator i = members.find(name);
00748 if (i == members.end()) {
00749 throw UnknownMember(name);
00750 } else {
00751 return (*i).second;
00752 }
00753 }
00754 public:
00755 ObjectProxy(const ConcreteClass * c, T * o)
00756 : members(c->members), object(o) {};
00757
00758 virtual void call(const string & name) const
00759 throw(TypeMismatch, UnknownMember) {
00760 const MemberDescr & d = member(name);
00761 switch(d.type) {
00762 case mf_void_void_tid: (object->*(d.mf_void_void))(); break;
00763 default: throw TypeMismatch(d.type, mf_void_void_tid);
00764 }
00765 }
00766 virtual void call(const string & name, int v) const
00767 throw(TypeMismatch, UnknownMember) {
00768 const MemberDescr & d = member(name);
00769 switch(d.type) {
00770 case mf_void_int_tid: (object->*(d.mf_void_int))(v); break;
00771 case mf_void_long_tid: (object->*(d.mf_void_long))(v); break;
00772 default: throw TypeMismatch(d.type,
00773 mf_void_int_tid, mf_void_long_tid);
00774 }
00775 }
00776 virtual void call(const string & name, char v) const
00777 throw(TypeMismatch, UnknownMember) {
00778 const MemberDescr & d = member(name);
00779 switch(d.type) {
00780 case mf_void_char_tid: (object->*(d.mf_void_char))(v); break;
00781 case mf_void_int_tid: (object->*(d.mf_void_int))(v); break;
00782 case mf_void_long_tid: (object->*(d.mf_void_long))(v); break;
00783 default: throw TypeMismatch(d.type, mf_void_char_tid,
00784 mf_void_int_tid, mf_void_long_tid);
00785 }
00786 }
00787 virtual void call(const string & name, long v) const
00788 throw(TypeMismatch, UnknownMember) {
00789 const MemberDescr & d = member(name);
00790 switch(d.type) {
00791 case mf_void_long_tid: (object->*(d.mf_void_long))(v); break;
00792 default: throw TypeMismatch(d.type, mf_void_long_tid);
00793 }
00794 }
00795 virtual void call(const string & name, bool v) const
00796 throw(TypeMismatch, UnknownMember) {
00797 const MemberDescr & d = member(name);
00798 switch(d.type) {
00799 case mf_void_bool_tid: (object->*(d.mf_void_bool))(v); break;
00800 default: throw TypeMismatch(d.type, mf_void_bool_tid);
00801 }
00802 }
00803 virtual void call(const string & name, float v) const
00804 throw(TypeMismatch, UnknownMember) {
00805 const MemberDescr & d = member(name);
00806 switch(d.type) {
00807 case mf_void_float_tid: (object->*(d.mf_void_float))(v); break;
00808 case mf_void_double_tid: (object->*(d.mf_void_double))(v); break;
00809 default: throw TypeMismatch(d.type, mf_void_bool_tid);
00810 }
00811 }
00812 virtual void call(const string & name, double v) const
00813 throw(TypeMismatch, UnknownMember) {
00814 const MemberDescr & d = member(name);
00815 switch(d.type) {
00816 case mf_void_double_tid: (object->*(d.mf_void_double))(v); break;
00817 default: throw TypeMismatch(d.type, mf_void_double_tid);
00818 }
00819 }
00820 virtual void call(const string & name, const string & v) const
00821 throw(TypeMismatch, UnknownMember) {
00822 const MemberDescr & d = member(name);
00823 switch(d.type) {
00824 case mf_void_c_string_r_tid:
00825 (object->*(d.mf_void_c_string_r))(v); break;
00826 default: throw TypeMismatch(d.type, mf_void_c_string_r_tid);
00827 }
00828 }
00829 virtual void call(const string & name, const char * v) const
00830 throw(TypeMismatch, UnknownMember) {
00831 const MemberDescr & d = member(name);
00832 switch(d.type) {
00833 case mf_void_c_string_r_tid:
00834 (object->*(d.mf_void_c_string_r))(string(v)); break;
00835 case mf_void_c_char_p_tid:
00836 (object->*(d.mf_void_c_char_p))(v); break;
00837 default: throw TypeMismatch(d.type, mf_void_c_string_r_tid,
00838 mf_void_c_char_p_tid);
00839 }
00840 }
00841 virtual void call(const string & name, void * v) const
00842 throw(TypeMismatch, UnknownMember) {
00843 const MemberDescr & d = member(name);
00844 switch(d.type) {
00845 case mf_void_void_p_tid:
00846 (object->*(d.mf_void_void_p))(v); break;
00847 default: throw TypeMismatch(d.type, mf_void_void_p_tid);
00848 }
00849 }
00850 virtual void assign(const string & name, int v) const
00851 throw(TypeMismatch, UnknownMember) {
00852 const MemberDescr & d = member(name);
00853 switch(d.type) {
00854 case m_int_tid: (object->*(d.m_int)) = v; break;
00855 case m_long_tid: (object->*(d.m_long)) = v; break;
00856 default: throw TypeMismatch(d.type, m_int_tid, m_long_tid);
00857 }
00858 }
00859 virtual void assign(const string & name, char v) const
00860 throw(TypeMismatch, UnknownMember) {
00861 const MemberDescr & d = member(name);
00862 switch(d.type) {
00863 case m_char_tid: (object->*(d.m_char)) = v; break;
00864 case m_int_tid: (object->*(d.m_int)) = v; break;
00865 case m_long_tid: (object->*(d.m_long)) = v; break;
00866 default: throw TypeMismatch(d.type, m_char_tid,
00867 m_int_tid, m_long_tid);
00868 }
00869 }
00870 virtual void assign(const string & name, long v) const
00871 throw(TypeMismatch, UnknownMember) {
00872 const MemberDescr & d = member(name);
00873 switch(d.type) {
00874 case m_long_tid: (object->*(d.m_long)) = v; break;
00875 default: throw TypeMismatch(d.type, m_long_tid);
00876 }
00877 }
00878 virtual void assign(const string & name, bool v) const
00879 throw(TypeMismatch, UnknownMember) {
00880 const MemberDescr & d = member(name);
00881 switch(d.type) {
00882 case m_bool_tid: (object->*(d.m_bool)) = v; break;
00883 default: throw TypeMismatch(d.type, m_bool_tid);
00884 }
00885 }
00886 virtual void assign(const string & name, float v) const
00887 throw(TypeMismatch, UnknownMember) {
00888 const MemberDescr & d = member(name);
00889 switch(d.type) {
00890 case m_float_tid: (object->*(d.m_float)) = v; break;
00891 case m_double_tid: (object->*(d.m_double)) = v; break;
00892 default: throw TypeMismatch(d.type, m_float_tid, m_double_tid);
00893 }
00894 }
00895 virtual void assign(const string & name, double v) const
00896 throw(TypeMismatch, UnknownMember) {
00897 const MemberDescr & d = member(name);
00898 switch(d.type) {
00899 case m_double_tid: (object->*(d.m_double)) = v; break;
00900 default: throw TypeMismatch(d.type, m_double_tid);
00901 }
00902 }
00903 virtual void assign(const string & name, const string & v) const
00904 throw(TypeMismatch, UnknownMember) {
00905 const MemberDescr & d = member(name);
00906 switch(d.type) {
00907 case m_string_tid: (object->*(d.m_string)) = v; break;
00908 default: throw TypeMismatch(d.type, m_string_tid);
00909 }
00910 }
00911 virtual void assign(const string & name, char * v) const
00912 throw(TypeMismatch, UnknownMember) {
00913 const MemberDescr & d = member(name);
00914 switch(d.type) {
00915 case m_char_p_tid: (object->*(d.m_char_p)) = v; break;
00916 case m_string_tid: (object->*(d.m_string)) = v; break;
00917 case m_c_char_p_tid: (object->*(d.m_c_char_p)) = v; break;
00918 default: throw TypeMismatch(d.type, m_char_p_tid,
00919 m_string_tid, m_c_char_p_tid);
00920 }
00921 }
00922 virtual void assign(const string & name, const char * v) const
00923 throw(TypeMismatch, UnknownMember) {
00924 const MemberDescr & d = member(name);
00925 switch(d.type) {
00926 case m_string_tid: (object->*(d.m_string)) = v; break;
00927 case m_c_char_p_tid: (object->*(d.m_c_char_p)) = v; break;
00928 default: throw TypeMismatch(d.type, m_string_tid, m_c_char_p_tid);
00929 }
00930 }
00931 virtual void assign(const string & name, void * v) const
00932 throw(TypeMismatch, UnknownMember) {
00933 const MemberDescr & d = member(name);
00934 switch(d.type) {
00935 case m_void_p_tid: (object->*(d.m_void_p)) = v;; break;
00936 default: throw TypeMismatch(d.type, m_void_p_tid);
00937 }
00938 }
00939
00940 virtual int & int_attribute(const string & name) const
00941 throw(TypeMismatch, UnknownMember) {
00942 const MemberDescr & d = member(name);
00943 switch(d.type) {
00944 case m_int_tid: return (object->*(d.m_int)); break;
00945 default: throw TypeMismatch(d.type, m_int_tid);
00946 }
00947 }
00948 virtual char & char_attribute(const string & name) const
00949 throw(TypeMismatch, UnknownMember) {
00950 const MemberDescr & d = member(name);
00951 switch(d.type) {
00952 case m_char_tid: return (object->*(d.m_char)); break;
00953 default: throw TypeMismatch(d.type, m_char_tid);
00954 }
00955 }
00956 virtual long & long_attribute(const string & name) const
00957 throw(TypeMismatch, UnknownMember) {
00958 const MemberDescr & d = member(name);
00959 switch(d.type) {
00960 case m_long_tid: return (object->*(d.m_long)); break;
00961 default: throw TypeMismatch(d.type, m_long_tid);
00962 }
00963 }
00964 virtual bool & bool_attribute(const string & name) const
00965 throw(TypeMismatch, UnknownMember) {
00966 const MemberDescr & d = member(name);
00967 switch(d.type) {
00968 case m_bool_tid: return (object->*(d.m_bool)); break;
00969 default: throw TypeMismatch(d.type, m_bool_tid);
00970 }
00971 }
00972 virtual double & double_attribute(const string & name) const
00973 throw(TypeMismatch, UnknownMember) {
00974 const MemberDescr & d = member(name);
00975 switch(d.type) {
00976 case m_double_tid: return (object->*(d.m_double)); break;
00977 default: throw TypeMismatch(d.type, m_double_tid);
00978 }
00979 }
00980 virtual float & float_attribute(const string & name) const
00981 throw(TypeMismatch, UnknownMember) {
00982 const MemberDescr & d = member(name);
00983 switch(d.type) {
00984 case m_float_tid: return (object->*(d.m_float)); break;
00985 default: throw TypeMismatch(d.type, m_float_tid);
00986 }
00987 }
00988 virtual string & string_attribute(const string & name) const
00989 throw(TypeMismatch, UnknownMember) {
00990 const MemberDescr & d = member(name);
00991 switch(d.type) {
00992 case m_string_tid: return (object->*(d.m_string)); break;
00993 default: throw TypeMismatch(d.type, m_string_tid);
00994 }
00995 }
00996 virtual const string & const_string_attribute(const string & name) const
00997 throw(TypeMismatch, UnknownMember) {
00998 const MemberDescr & d = member(name);
00999 switch(d.type) {
01000 case m_c_string_tid: return (object->*(d.m_c_string)); break;
01001 default: throw TypeMismatch(d.type, m_c_string_tid);
01002 }
01003 }
01004 virtual char * & char_p_attribute(const string & name) const
01005 throw(TypeMismatch, UnknownMember) {
01006 const MemberDescr & d = member(name);
01007 switch(d.type) {
01008 case m_char_p_tid: return (object->*(d.m_char_p)); break;
01009 default: throw TypeMismatch(d.type, m_char_p_tid);
01010 }
01011 }
01012 virtual const char * & const_char_p_attribute(const string & name) const
01013 throw(TypeMismatch, UnknownMember) {
01014 const MemberDescr & d = member(name);
01015 switch(d.type) {
01016 case m_c_char_p_tid: return (object->*(d.m_c_char_p)); break;
01017 default: throw TypeMismatch(d.type, m_c_char_p_tid);
01018 }
01019 }
01020
01021 virtual int int_value(const string & name) const
01022 throw(TypeMismatch, UnknownMember) {
01023 const MemberDescr & d = member(name);
01024 switch(d.type) {
01025 case m_int_tid: return (object->*(d.m_int)); break;
01026 case m_char_tid: return (object->*(d.m_char)); break;
01027 default: throw TypeMismatch(d.type, m_int_tid, m_char_tid);
01028 }
01029 }
01030 virtual char char_value(const string & name) const
01031 throw(TypeMismatch, UnknownMember) {
01032 const MemberDescr & d = member(name);
01033 switch(d.type) {
01034 case m_char_tid: return (object->*(d.m_char)); break;
01035 default: throw TypeMismatch(d.type, m_char_tid);
01036 }
01037 }
01038 virtual long long_value(const string & name) const
01039 throw(TypeMismatch, UnknownMember) {
01040 const MemberDescr & d = member(name);
01041 switch(d.type) {
01042 case m_long_tid: return (object->*(d.m_long)); break;
01043 case m_int_tid: return (object->*(d.m_int)); break;
01044 case m_char_tid: return (object->*(d.m_char)); break;
01045 default: throw TypeMismatch(d.type, m_long_tid,
01046 m_int_tid, m_char_tid);
01047 }
01048 }
01049 virtual bool bool_value(const string & name) const
01050 throw(TypeMismatch, UnknownMember) {
01051 const MemberDescr & d = member(name);
01052 switch(d.type) {
01053 case m_bool_tid: return (object->*(d.m_bool)); break;
01054 default: throw TypeMismatch(d.type, m_bool_tid);
01055 }
01056 }
01057 virtual double double_value(const string & name) const
01058 throw(TypeMismatch, UnknownMember) {
01059 const MemberDescr & d = member(name);
01060 switch(d.type) {
01061 case m_float_tid: return (object->*(d.m_float)); break;
01062 case m_double_tid: return (object->*(d.m_double)); break;
01063 default: throw TypeMismatch(d.type, m_double_tid, m_float_tid);
01064 }
01065 }
01066 virtual float float_value(const string & name) const
01067 throw(TypeMismatch, UnknownMember) {
01068 const MemberDescr & d = member(name);
01069 switch(d.type) {
01070 case m_float_tid: return (object->*(d.m_float)); break;
01071 default: throw TypeMismatch(d.type, m_float_tid);
01072 }
01073 }
01074 virtual char * char_p_value(const string & name) const
01075 throw(TypeMismatch, UnknownMember) {
01076 const MemberDescr & d = member(name);
01077 switch(d.type) {
01078 case m_char_p_tid: return (object->*(d.m_char_p)); break;
01079 default: throw TypeMismatch(d.type, m_char_p_tid);
01080 }
01081 }
01082 virtual const char * const_char_p_value(const string & name) const
01083 throw(TypeMismatch, UnknownMember) {
01084 const MemberDescr & d = member(name);
01085 switch(d.type) {
01086 case m_c_char_p_tid: return (object->*(d.m_c_char_p)); break;
01087 case m_string_tid: return (object->*(d.m_string)).c_str(); break;
01088 case m_c_string_tid: return (object->*(d.m_c_string)).c_str(); break;
01089 case m_char_p_tid: return (object->*(d.m_char_p)); break;
01090 default: throw TypeMismatch(d.type, m_c_char_p_tid);
01091 }
01092 }
01093
01094 virtual void * this_pointer() const { return object; }
01095 };
01096
01097 public:
01098 ConcreteClass() throw ()
01099 : members(),
01100 cf_void(0),
01101 cf_int(0),
01102 cf_char(0),
01103 cf_long(0),
01104 cf_bool(0),
01105 cf_float(0),
01106 cf_double(0),
01107 cf_c_string_r(0),
01108 cf_c_char_p(0),
01109 cf_void_p(0)
01110 {}
01111
01112 virtual Object * new_object() const throw(UnknownMember) {
01113 if (cf_void == 0) throw UnknownMember("constructor()");
01114 return new ObjectProxy(this, (cf_void)());
01115 }
01116 virtual Object * new_object(int c) const throw(UnknownMember) {
01117 if (cf_int == 0) throw UnknownMember("constructor(int)");
01118 return new ObjectProxy(this, (cf_int)(c));
01119 }
01120 virtual Object * new_object(char c) const throw(UnknownMember) {
01121 if (cf_char == 0) throw UnknownMember("constructor(char)");
01122 return new ObjectProxy(this, (cf_char)(c));
01123 }
01124 virtual Object * new_object(long c) const throw(UnknownMember) {
01125 if (cf_long == 0) throw UnknownMember("constructor(long)");
01126 return new ObjectProxy(this, (cf_long)(c));
01127 }
01128 virtual Object * new_object(bool c) const throw(UnknownMember) {
01129 if (cf_bool == 0) throw UnknownMember("constructor(bool)");
01130 return new ObjectProxy(this, (cf_bool)(c));
01131 }
01132 virtual Object * new_object(float c) const throw(UnknownMember) {
01133 if (cf_float == 0) throw UnknownMember("constructor(float)");
01134 return new ObjectProxy(this, (cf_float)(c));
01135 }
01136 virtual Object * new_object(double c) const throw(UnknownMember) {
01137 if (cf_double == 0) throw UnknownMember("constructor(double)");
01138 return new ObjectProxy(this, (cf_double)(c));
01139 }
01140 virtual Object * new_object(const string & c) const throw(UnknownMember) {
01141 if (cf_c_string_r == 0) throw UnknownMember("constructor(const string &)");
01142 return new ObjectProxy(this, (cf_c_string_r)(c));
01143 }
01144 virtual Object * new_object(const char * c) const throw(UnknownMember) {
01145 if (cf_c_char_p == 0) throw UnknownMember("constructor(const char *)");
01146 return new ObjectProxy(this, (cf_c_char_p)(c));
01147 }
01148 virtual Object * new_object(void * c) const throw(UnknownMember) {
01149 if (cf_void_p == 0) throw UnknownMember("constructor(void *)");
01150 return new ObjectProxy(this, (cf_void_p)(c));
01151 }
01152
01168 void bind(const string & name, int T::*m) throw() {
01169 MemberDescr & md = members[name];
01170 md.m_int = m;
01171 md.type = m_int_tid;
01172 }
01173
01179 void bind(const string & name, char T::*m) throw() {
01180 MemberDescr & md = members[name];
01181 md.m_char = m;
01182 md.type = m_char_tid;
01183 }
01184
01190 void bind(const string & name, long T::*m) throw() {
01191 MemberDescr & md = members[name];
01192 md.m_long = m;
01193 md.type = m_long_tid;
01194 }
01195
01201 void bind(const string & name, bool T::*m) throw() {
01202 MemberDescr & md = members[name];
01203 md.m_bool = m;
01204 md.type = m_bool_tid;
01205 }
01206
01212 void bind(const string & name, double T::*m) throw() {
01213 MemberDescr & md = members[name];
01214 md.m_double = m;
01215 md.type = m_double_tid;
01216 }
01217
01223 void bind(const string & name, float T::*m) throw() {
01224 MemberDescr & md = members[name];
01225 md.m_float = m;
01226 md.type = m_float_tid;
01227 }
01228
01234 void bind(const string & name, string T::*m) throw() {
01235 MemberDescr & md = members[name];
01236 md.m_string = m;
01237 md.type = m_string_tid;
01238 }
01239
01245 void bind(const string & name, char * T::*m) throw() {
01246 MemberDescr & md = members[name];
01247 md.m_char_p = m;
01248 md.type = m_char_p_tid;
01249 }
01250
01256 void bind(const string & name, const char * T::*m) throw() {
01257 MemberDescr & md = members[name];
01258 md.m_c_char_p = m;
01259 md.type = m_c_char_p_tid;
01260 }
01261
01267 void bind(const string & name, void * T::*m) throw() {
01268 MemberDescr & md = members[name];
01269 md.m_void_p = m;
01270 md.type = m_void_p_tid;
01271 }
01272
01278 void bind(const string & name, void (T::*m)()) throw() {
01279 MemberDescr & md = members[name];
01280 md.mf_void_void = m;
01281 md.type = mf_void_void_tid;
01282 }
01283
01289 void bind(const string & name, void (T::*m)(int)) throw() {
01290 MemberDescr & md = members[name];
01291 md.mf_void_int = m;
01292 md.type = mf_void_int_tid;
01293 }
01294
01300 void bind(const string & name, void (T::*m)(char)) throw() {
01301 MemberDescr & md = members[name];
01302 md.mf_void_char = m;
01303 md.type = mf_void_char_tid;
01304 }
01305
01311 void bind(const string & name, void (T::*m)(long)) throw() {
01312 MemberDescr & md = members[name];
01313 md.mf_void_long = m;
01314 md.type = mf_void_long_tid;
01315 }
01316
01322 void bind(const string & name, void (T::*m)(bool)) throw() {
01323 MemberDescr & md = members[name];
01324 md.mf_void_bool = m;
01325 md.type = mf_void_bool_tid;
01326 }
01327
01333 void bind(const string & name, void (T::*m)(float)) throw() {
01334 MemberDescr & md = members[name];
01335 md.mf_void_float = m;
01336 md.type = mf_void_float_tid;
01337 }
01338
01344 void bind(const string & name, void (T::*m)(double)) throw() {
01345 MemberDescr & md = members[name];
01346 md.mf_void_double = m;
01347 md.type = mf_void_double_tid;
01348 }
01349
01355 void bind(const string & name, void (T::*m)(const string &)) throw() {
01356 MemberDescr & md = members[name];
01357 md.mf_void_c_string_r = m;
01358 md.type = mf_void_c_string_r_tid;
01359 }
01360
01366 void bind(const string & name, void (T::*m)(const char *)) throw() {
01367 MemberDescr & md = members[name];
01368 md.mf_void_c_char_p = m;
01369 md.type = mf_void_c_char_p_tid;
01370 }
01371
01377 void bind(const string & name, void (T::*m)(void *)) throw() {
01378 MemberDescr & md = members[name];
01379 md.mf_void_void_p = m;
01380 md.type = mf_void_void_p_tid;
01381 }
01395 void set_constructor(T* (c)(void)) throw() { cf_void = c; }
01397 void set_constructor(T* (c)(int)) throw() { cf_int = c; }
01399 void set_constructor(T* (c)(char)) throw() { cf_char = c; }
01401 void set_constructor(T* (c)(long)) throw() { cf_long = c; }
01403 void set_constructor(T* (c)(bool)) throw() { cf_bool = c; }
01405 void set_constructor(T* (c)(float)) throw() { cf_float = c; }
01407 void set_constructor(T* (c)(double)) throw() { cf_double = c; }
01409 void set_constructor(T* (c)(const string &)) throw() { cf_c_string_r = c; }
01411 void set_constructor(T* (c)(const char *)) throw() { cf_c_char_p = c; }
01413 void set_constructor(T* (c)(void *)) throw() { cf_void_p = c; }
01415 };
01416
01434 extern Class * load_class(const string & classname,
01435 const string & libname) throw(Exception);
01436
01439 extern void close_libraries();
01440
01441 template <typename T>
01442 inline void Member::operator () (const T & x) throw(TypeMismatch,
01443 UnknownMember) {
01444 object->call(name, x);
01445 }
01446
01447 template <typename T>
01448 T Member::operator = (T x) throw(TypeMismatch, UnknownMember) {
01449 object->assign(name, x);
01450 return x;
01451 }
01452
01453 inline Member::operator int () const throw(TypeMismatch, UnknownMember) {
01454 return object->int_value(name);
01455 }
01456 inline Member::operator char () const throw(TypeMismatch, UnknownMember) {
01457 return object->char_value(name);
01458 }
01459 inline Member::operator long () const throw(TypeMismatch, UnknownMember) {
01460 return object->long_value(name);
01461 }
01462 inline Member::operator bool () const throw(TypeMismatch, UnknownMember) {
01463 return object->bool_value(name);
01464 }
01465 inline Member::operator double () const throw(TypeMismatch, UnknownMember) {
01466 return object->double_value(name);
01467 }
01468 inline Member::operator float () const throw(TypeMismatch, UnknownMember) {
01469 return object->float_value(name);
01470 }
01471 inline Member::operator const char * () const throw(TypeMismatch, UnknownMember) {
01472 return object->const_char_p_value(name);
01473 }
01474 inline Member::operator char * () const throw(TypeMismatch, UnknownMember) {
01475 return object->char_p_value(name);
01476 }
01477 };
01478
01479 #endif
01480