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
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
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
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
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 }
00188
00189
00190 #endif