Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

cxx_args.h

00001 #ifndef __UPF_CXX_ARGS_H__
00002 #define __UPF_CXX_ARGS_H__
00003 
00004 
00005 namespace upf
00006 {
00007 
00008 class Arguments
00009 {
00010 public:
00011     Arguments(upf_Arguments *args) : m_data(args) {}
00012     
00013     void write(void *data, size_t len)
00014     {
00015         upf_middleware->funcs.marchaller_write(m_data, data, len);
00016     }
00017 
00018     void read(void *data, size_t len)
00019     {
00020         upf_middleware->funcs.marchaller_read(m_data, data, len);
00021     }
00022     
00023     void seek0()
00024     {
00025         upf_middleware->funcs.marchaller_seek0(m_data);
00026     }
00027 
00028     upf_Arguments *getMarchalled() const { return m_data; }
00029     
00030 protected:
00031     upf_Arguments *m_data;
00032 };
00033 
00034 class ArgumentsOwned : public Arguments
00035 {
00036 public:
00037     ArgumentsOwned() : Arguments(&m_stackData)
00038         { upf_middleware->funcs.marchaller_init(&m_stackData); }
00039     
00040     ~ArgumentsOwned()
00041         { upf_middleware->funcs.marchaller_destroy(&m_stackData); }
00042     
00043 private:
00044     upf_Arguments  m_stackData;
00045 };
00046 
00047 
00048 
00049 inline Arguments& operator<<(Arguments& holder, const InterfacePtr& value)
00050 {
00051     holder.write((void*)&value, sizeof(value));
00052     return holder;
00053 }
00054 inline Arguments& operator>>(Arguments& holder, InterfacePtr& value)
00055 {
00056     holder.read(&value, sizeof(value));
00057     return holder;
00058 }
00059 
00060 inline Arguments& operator<<(Arguments& holder, const IID& value)
00061 {
00062     holder.write((void*)&value, sizeof(IID));
00063     return holder;
00064 }
00065 
00066 inline Arguments& operator>>(Arguments& holder, IID& value)
00067 {
00068     holder.read(&value, sizeof(IID));
00069     return holder;
00070 }
00071 
00072 #define _UPF_DECLARE_SIMPLE_ARG_OP(type) \
00073     inline Arguments& operator<<(Arguments& holder, type value) \
00074     { \
00075         holder.write(&value, sizeof(type)); \
00076         return holder; \
00077     } \
00078     inline Arguments& operator>>(Arguments& holder, type& value) \
00079     { \
00080         holder.read(&value, sizeof(type)); \
00081         return holder; \
00082     }
00083 
00084 _UPF_DECLARE_SIMPLE_ARG_OP(short)
00085 _UPF_DECLARE_SIMPLE_ARG_OP(long)
00086 _UPF_DECLARE_SIMPLE_ARG_OP(unsigned short)
00087 _UPF_DECLARE_SIMPLE_ARG_OP(unsigned long)
00088 _UPF_DECLARE_SIMPLE_ARG_OP(float)
00089 _UPF_DECLARE_SIMPLE_ARG_OP(double)
00090 _UPF_DECLARE_SIMPLE_ARG_OP(long double)
00091 _UPF_DECLARE_SIMPLE_ARG_OP(upf_uint8_t)
00092 _UPF_DECLARE_SIMPLE_ARG_OP(char)
00093 #ifdef __GNUC__
00094 _UPF_DECLARE_SIMPLE_ARG_OP(long long)
00095 _UPF_DECLARE_SIMPLE_ARG_OP(unsigned long long)
00096 // FIXME : define upf::LongLong and upf::ULongLong !!!
00097 #endif
00098 
00099 #undef _UPF_DECLARE_SIMPLE_ARG_OP
00100 
00101 
00102 inline Arguments& operator<<(Arguments& holder, bool value)
00103 {
00104     return holder << (upf_uint8_t)(value ? 1 : 0);
00105 }
00106 
00107 inline Arguments& operator>>(Arguments& holder, bool& value)
00108 {
00109     upf_uint8_t temp;
00110     holder >> temp;
00111     value = (temp != 0);
00112     return holder;
00113 }
00114 
00115 
00116 // Teplate for storing lists of elements of any type that has operator<< defined
00117 template<typename T>
00118 Arguments& operator<<(Arguments& holder, const ::std::vector<T>& arr)
00119 {
00120     holder << (unsigned long)arr.size();
00121     for (typename std::vector<T>::const_iterator i = arr.begin(); i != arr.end(); i++)
00122         holder << *i;
00123     return holder;
00124 }
00125 
00126 template<typename T>
00127 Arguments& operator>>(Arguments& holder, ::std::vector<T>& arr)
00128 {
00129     unsigned long size;
00130     T value;
00131     holder >> size;
00132     arr.clear();
00133     arr.reserve(size);
00134     for (; size != 0; size--)
00135     {
00136         holder >> value;
00137         arr.push_back(value);
00138     }
00139     return holder;
00140 }
00141 
00142 inline Arguments& operator<<(Arguments& holder, const ::std::string& value)
00143 {
00144     unsigned long wr, len = value.length();
00145     holder << len;
00146     const char *str = value.c_str();
00147     while (len > 0)
00148     {
00149         wr = len < 64 ? len : 64;
00150         holder.write((void*)str, wr);
00151         str += wr;
00152         len -= wr;
00153     }
00154     return holder;
00155 }
00156 
00157 inline Arguments& operator>>(Arguments& holder, ::std::string& value)
00158 {
00159     unsigned long len, rd;
00160     char str[64];
00161 #if (defined(__GNUC__) && __GNUC__ == 2) || defined(_MSC_VER)
00162     // gcc 2.95 doesn't have std::string::clear() (required by standard)
00163     value = ::std::string();
00164 #else
00165     value.clear();
00166 #endif
00167 
00168     holder >> len;
00169     while (len > 0)
00170     {
00171         rd = len < 64 ? len : 64;
00172         holder.read(&str, rd);
00173         value.append(str, rd);
00174         len -= rd;
00175     }
00176     
00177     return holder;
00178 }
00179 
00180 
00181 // upf object I/O:
00182 inline Arguments& operator<<(Arguments& holder, ::upf::IObject* obj);
00183 template<class T> inline Arguments& operator>>(Arguments& holder, ::upf::Ptr<T>& obj);
00184 
00185 
00186 
00187 } // end of namespace 'upf'
00188 
00189 
00190 #endif

Generated on Wed Jan 15 23:10:55 2003 for Universal Plugins Framework by doxygen1.2.18