00001 #ifndef ADDRESS_V_H_
00002 #define ADDRESS_V_H_
00003
00004 #include <stdint.h>
00005 #include <string>
00006 #include <iostream>
00007
00008 #include "vfacade.hpp"
00009
00010 #include "to_bytes_v.hpp"
00011 #include "to_string_v.hpp"
00012 #include "comparable_v.hpp"
00013
00014 #include "../detail/address_convenience.hpp"
00015
00016 namespace ariba {
00017 namespace addressing {
00018
00019 using std::string;
00020
00026 class address_v: public detail::address_convenience<address_v> {
00027 public:
00028
00029
00031 virtual string to_string() const = 0;
00032
00034 virtual bool assign(const std::string& text) = 0;
00035
00036
00037
00039 virtual bool is_bytes_size_static() const = 0;
00040
00042 virtual size_t to_bytes_size() const = 0;
00043
00045 virtual void to_bytes(uint8_t* bytes) const = 0;
00046
00048 virtual bool assign(const uint8_t* bytes, size_t size) = 0;
00049
00050
00051
00053 virtual int compare_to(const address_v& rhs) const = 0;
00054
00055
00056
00058 virtual bool assign(const address_v& rhs) = 0;
00059
00060
00061
00063 virtual const string& type_name() const = 0;
00064
00066 virtual uint16_t type_id() const = 0;
00067
00068
00069
00071 virtual void* data(const std::type_info& type) = 0;
00072
00074 virtual address_v* clone() const = 0;
00075
00076
00077
00078 template<class T>
00079 bool instanceof() const {
00080 void* value = const_cast<address_v*>(this)->data(typeid(T));
00081 return value!=NULL;
00082 }
00083
00085 template<class T>
00086 inline operator T&() {
00087 void* value = data(typeid(T));
00088 assert (value!=NULL);
00089 return *((T*) value);
00090 }
00091
00093 template<class T>
00094 inline operator T () const {
00095 return T( (const T&)*this );
00096 }
00097
00099 template<class T>
00100 inline operator const T& () const {
00101 void* value = const_cast<address_v*>(this)->data(typeid(T));
00102 assert (value!=NULL);
00103 return *((const T*) value);
00104 }
00105 };
00106
00108 std::ostream& operator<<(std::ostream& s, const address_v* addr);
00109
00111 typedef vfacade<address_v> address_vf;
00112
00113 }}
00114
00116 template<class NonVirtual, class AdaptorType>
00117 class vobject_hull<NonVirtual, ariba::addressing::address_v, AdaptorType> : public ariba::addressing::address_v {
00118
00119 private:
00120 typedef ariba::addressing::address_v self;
00121 typename AdaptorType::template adaptor_type<NonVirtual> obj;
00122
00123 static inline NonVirtual& conv(ariba::addressing::address_v* obj) {
00124 return *((NonVirtual*) obj->data(typeid(NonVirtual)));
00125 }
00126
00127 static inline const NonVirtual& conv(const ariba::addressing::address_v* obj) {
00128 const NonVirtual* v =
00129 (const NonVirtual*) const_cast<ariba::addressing::address_v*> (obj)->data(
00130 typeid(NonVirtual));
00131 return *v;
00132 }
00133
00134 public:
00135 template<typename T>
00136 explicit vobject_hull(T& obj) :
00137 obj(obj) {
00138 }
00139 explicit vobject_hull() :
00140 obj() {
00141 }
00142
00143
00144
00146 virtual bool assign(const self& rhs) {
00147 return obj->assign(conv(&rhs));
00148 }
00149
00150
00151
00153 virtual const string& type_name() const {
00154 return obj->type_name();
00155 }
00156
00158 virtual uint16_t type_id() const {
00159 return obj->type_id();
00160 }
00161
00163 virtual address_v* clone() const {
00164 return vcapsule<address_v> (*obj);
00165 }
00166
00168 virtual void* data(const std::type_info& type) {
00169 if (typeid(NonVirtual)!=type) return NULL;
00170 return &(*obj);
00171 }
00172
00173
00174
00176 virtual string to_string() const {
00177 return obj->to_string();
00178 }
00179
00181 virtual bool assign(const std::string& text) {
00182 return obj->assign(text);
00183 }
00184
00185
00186
00188 virtual int compare_to(const self& rhs) const {
00189 const address_v* compare = dynamic_cast<const address_v*> (&rhs);
00190 return obj->compare_to(conv(compare));
00191 }
00192
00193
00194
00196 virtual bool is_bytes_size_static() const {
00197 return obj->is_bytes_size_static();
00198 }
00199
00201 virtual size_t to_bytes_size() const {
00202 return obj->to_bytes_size();
00203 }
00204
00206 virtual void to_bytes(uint8_t* bytes) const {
00207 obj->to_bytes(bytes);
00208 }
00209
00211 virtual bool assign(const uint8_t* bytes, size_t size) {
00212 return obj->assign(bytes, size);
00213 }
00214
00215 };
00216
00217
00218 #endif