00001 #ifndef _IT_BUS_ANY_SIMPLE_TYPE_T_CXX_
00002 #define _IT_BUS_ANY_SIMPLE_TYPE_T_CXX_
00003
00004
00005
00006
00007 #include <assert.h>
00008 #include <it_bus/any_simple_type.h>
00009 #include <it_bus/any_simple_type_reader.h>
00010 #include <it_bus/any_simple_type_writer.h>
00011 #include <it_bus/complex_type_reader.h>
00012 #include <it_bus/complex_type_writer.h>
00013 #include <it_bus/schema_type_traits.h>
00014 #include <it_bus/reflect/value_ref.h>
00015
00016 namespace IT_Bus
00017 {
00023 template <class T>
00024 class AnySimpleTypeBaseT : public AnySimpleType
00025 {
00026 public:
00027 virtual ~AnySimpleTypeBaseT()
00028 throw(());
00029
00030 virtual const QName&
00031 get_type() const;
00032
00033 virtual AnyType::Kind
00034 get_kind() const;
00035
00036 virtual IT_Reflect::Reflection*
00037 get_reflection()
00038 throw(());
00039
00040 virtual const IT_Reflect::Reflection*
00041 get_reflection() const
00042 throw(());
00043
00044 virtual void
00045 write(
00046 const QName& name,
00047 ComplexTypeWriter& writer
00048 ) const throw((SerializationException));
00049
00050 virtual void
00051 write_value(
00052 AnySimpleTypeWriter& writer
00053 ) const throw((SerializationException));
00054
00055 virtual const T&
00056 get_value() const = 0;
00057 };
00058
00064 template <class T>
00065 class AnySimpleTypeT : public AnySimpleTypeBaseT<T>
00066 {
00067 public:
00068 AnySimpleTypeT()
00069 throw(());
00070
00071 AnySimpleTypeT(
00072 const T& value
00073 ) throw(());
00074
00075 virtual ~AnySimpleTypeT()
00076 throw(());
00077
00078 virtual void
00079 read(
00080 const QName& name,
00081 ComplexTypeReader& reader
00082 ) throw((DeserializationException));
00083
00084 virtual void
00085 read_value(
00086 AnySimpleTypeReader& reader
00087 ) throw((DeserializationException));
00088
00089 virtual
00090 AnyType&
00091 copy(
00092 const AnyType & rhs
00093 );
00094
00095 virtual const T&
00096 get_value() const;
00097
00098 T&
00099 get_value();
00100
00101 private:
00102 T m_value;
00103 };
00104
00110 template <class T>
00111 class AnySimpleTypeRefT : public AnySimpleTypeBaseT<T>
00112 {
00113 public:
00114 AnySimpleTypeRefT(
00115 T& value
00116 ) throw(());
00117
00118 virtual ~AnySimpleTypeRefT()
00119 throw(());
00120
00121 virtual void
00122 read(
00123 const QName& name,
00124 ComplexTypeReader& reader
00125 ) throw((DeserializationException));
00126
00127 virtual void
00128 read_value(
00129 AnySimpleTypeReader& reader
00130 ) throw((DeserializationException));
00131
00132 virtual
00133 AnyType&
00134 copy(
00135 const AnyType & rhs
00136 );
00137
00138 virtual const T&
00139 get_value() const;
00140
00141 T&
00142 get_value();
00143
00144 private:
00145 T& m_value;
00146 };
00147
00153 template <class T>
00154 class AnySimpleTypeConstRefT : public AnySimpleTypeBaseT<T>
00155 {
00156 public:
00157 AnySimpleTypeConstRefT(
00158 const T& value
00159 ) throw(());
00160
00161 virtual ~AnySimpleTypeConstRefT()
00162 throw(());
00163
00164
00165
00166 virtual void
00167 read(
00168 const QName& name,
00169 ComplexTypeReader& reader
00170 ) throw((DeserializationException));
00171
00172
00173
00174 virtual void
00175 read_value(
00176 AnySimpleTypeReader& reader
00177 ) throw((DeserializationException));
00178
00179
00180
00181 virtual
00182 AnyType&
00183 copy(
00184 const AnyType & rhs
00185 );
00186
00187 virtual const T&
00188 get_value() const;
00189
00190 private:
00191 const T& m_value;
00192 };
00193
00194
00195
00196
00197
00198 template <class T>
00199 inline
00200 AnySimpleTypeBaseT<T>::~AnySimpleTypeBaseT() throw(())
00201 {
00202
00203 }
00204
00205 template <class T>
00206 inline const QName&
00207 AnySimpleTypeBaseT<T>::get_type() const
00208 {
00209 return SchemaTypeTraits<T>::type_name();
00210 }
00211
00212 template <class T>
00213 inline AnyType::Kind
00214 AnySimpleTypeBaseT<T>::get_kind() const
00215 {
00216 return AnyType::BUILT_IN;
00217 }
00218
00219 template <class T>
00220 inline IT_Reflect::Reflection*
00221 AnySimpleTypeBaseT<T>::get_reflection() throw(())
00222 {
00223 return new IT_Reflect::ValueRef<T>(get_value());
00224 }
00225
00226 template <class T>
00227 inline const IT_Reflect::Reflection*
00228 AnySimpleTypeBaseT<T>::get_reflection() const throw(())
00229 {
00230 return new IT_Reflect::ValueRef<T>(get_value());
00231 }
00232
00233 template <class T>
00234 inline void
00235 AnySimpleTypeBaseT<T>::write(
00236 const QName& name,
00237 ComplexTypeWriter& writer
00238 ) const throw((SerializationException))
00239 {
00240 writer.write(name, get_value());
00241 }
00242
00243 template <class T>
00244 inline void
00245 AnySimpleTypeBaseT<T>::write_value(
00246 AnySimpleTypeWriter& writer
00247 ) const throw((SerializationException))
00248 {
00249 writer.write(get_value());
00250 }
00251
00252
00253
00254
00255
00256 template <class T>
00257 inline
00258 AnySimpleTypeT<T>::AnySimpleTypeT() throw(())
00259 {
00260
00261 }
00262
00263 template <class T>
00264 inline
00265 AnySimpleTypeT<T>::AnySimpleTypeT(
00266 const T& value
00267 ) throw(()) :
00268 m_value(value)
00269 {
00270
00271 }
00272
00273 template <class T>
00274 inline
00275 AnySimpleTypeT<T>::~AnySimpleTypeT() throw(())
00276 {
00277
00278 }
00279
00280 template <class T>
00281 inline void
00282 AnySimpleTypeT<T>::read(
00283 const QName& name,
00284 ComplexTypeReader& reader
00285 ) throw((DeserializationException))
00286 {
00287 reader.read(name, get_value());
00288 }
00289
00290 template <class T>
00291 inline void
00292 AnySimpleTypeT<T>::read_value(
00293 AnySimpleTypeReader& reader
00294 ) throw((DeserializationException))
00295 {
00296 reader.read(get_value());
00297 }
00298
00299 template <class T>
00300 inline AnyType&
00301 AnySimpleTypeT<T>::copy(
00302 const AnyType & rhs
00303 )
00304 {
00305 const AnySimpleTypeBaseT<T>* tmp =
00306 IT_DYNAMIC_CAST(const AnySimpleTypeBaseT<T>*, &rhs);
00307 if (tmp != 0)
00308 {
00309 m_value = tmp->get_value();
00310 }
00311 else
00312 {
00313 IT_Reflect::copy(*this, rhs);
00314 }
00315
00316 return *this;
00317 }
00318
00319 template <class T>
00320 inline const T&
00321 AnySimpleTypeT<T>::get_value() const
00322 {
00323 return m_value;
00324 }
00325
00326 template <class T>
00327 inline T&
00328 AnySimpleTypeT<T>::get_value()
00329 {
00330 return m_value;
00331 }
00332
00333
00334
00335
00336
00337 template <class T>
00338 inline
00339 AnySimpleTypeRefT<T>::AnySimpleTypeRefT(
00340 T& value
00341 ) throw(()) :
00342 m_value(value)
00343 {
00344
00345 }
00346
00347 template <class T>
00348 inline
00349 AnySimpleTypeRefT<T>::~AnySimpleTypeRefT() throw(())
00350 {
00351
00352 }
00353
00354 template <class T>
00355 inline void
00356 AnySimpleTypeRefT<T>::read(
00357 const QName& name,
00358 ComplexTypeReader& reader
00359 ) throw((DeserializationException))
00360 {
00361 reader.read(name, get_value());
00362 }
00363
00364 template <class T>
00365 inline void
00366 AnySimpleTypeRefT<T>::read_value(
00367 AnySimpleTypeReader& reader
00368 ) throw((DeserializationException))
00369 {
00370 reader.read(get_value());
00371 }
00372
00373 template <class T>
00374 inline AnyType&
00375 AnySimpleTypeRefT<T>::copy(
00376 const AnyType & rhs
00377 )
00378 {
00379 const AnySimpleTypeBaseT<T>* tmp =
00380 IT_DYNAMIC_CAST(const AnySimpleTypeBaseT<T>*, &rhs);
00381 assert(tmp != 0);
00382
00383 m_value = tmp->get_value();
00384 return *this;
00385 }
00386
00387 template <class T>
00388 inline const T&
00389 AnySimpleTypeRefT<T>::get_value() const
00390 {
00391 return m_value;
00392 }
00393
00394 template <class T>
00395 inline T&
00396 AnySimpleTypeRefT<T>::get_value()
00397 {
00398 return m_value;
00399 }
00400
00401
00402
00403
00404
00405 template <class T>
00406 inline
00407 AnySimpleTypeConstRefT<T>::AnySimpleTypeConstRefT(
00408 const T& value
00409 ) throw(()) :
00410 m_value(value)
00411 {
00412
00413 }
00414
00415 template <class T>
00416 inline
00417 AnySimpleTypeConstRefT<T>::~AnySimpleTypeConstRefT() throw(())
00418 {
00419
00420 }
00421
00422 template <class T>
00423 inline void
00424 AnySimpleTypeConstRefT<T>::read(
00425 const QName& ,
00426 ComplexTypeReader&
00427 ) throw((DeserializationException))
00428 {
00429 throw DeserializationException(
00430 "AnySimpleTypeConstRefT<T>::read() not supported"
00431 );
00432 }
00433
00434 template <class T>
00435 inline void
00436 AnySimpleTypeConstRefT<T>::read_value(
00437 AnySimpleTypeReader&
00438 ) throw((DeserializationException))
00439 {
00440 throw DeserializationException(
00441 "AnySimpleTypeConstRefT<T>::read_value() not supported"
00442 );
00443 }
00444
00445 template <class T>
00446 inline AnyType&
00447 AnySimpleTypeConstRefT<T>::copy(
00448 const AnyType &
00449 )
00450 {
00451 throw Exception(
00452 "AnySimpleTypeConstRefT<T>::copy() not supported"
00453 );
00454 IT_UNREACHABLE_RETURN(*this);
00455 }
00456
00457 template <class T>
00458 inline const T&
00459 AnySimpleTypeConstRefT<T>::get_value() const
00460 {
00461 return m_value;
00462 }
00463 }
00464
00465
00466 #endif