00001 #ifndef ADDRESS_V_H_
00002 #define ADDRESS_V_H_
00003
00004 #include <string>
00005 #include <iostream>
00006
00007 #include "vfacade.hpp"
00008
00009 #include "to_bytes_v.hpp"
00010 #include "to_string_v.hpp"
00011 #include "comparable_v.hpp"
00012
00013 #include "../detail/address_convenience.hpp"
00014
00015 namespace ariba {
00016 namespace addressing {
00017
00018 using std::string;
00019
00025 class address_v: public detail::address_convenience<address_v> {
00026 public:
00027
00028
00030 virtual string to_string() const = 0;
00031
00033 virtual bool assign(const std::string& text) = 0;
00034
00035
00036
00038 virtual bool is_bytes_size_static() const = 0;
00039
00041 virtual size_t to_bytes_size() const = 0;
00042
00044 virtual void to_bytes(uint8_t* bytes) const = 0;
00045
00047 virtual bool assign(const uint8_t* bytes, size_t size) = 0;
00048
00049
00050
00052 virtual int compare_to(const address_v& rhs) const = 0;
00053
00054
00055
00057 virtual bool assign(const address_v& rhs) = 0;
00058
00059
00060
00062 virtual const string& type_name() const = 0;
00063
00065 virtual uint16_t type_id() const = 0;
00066
00067
00068
00070 virtual void* data(const std::type_info& type) = 0;
00071
00073 virtual address_v* clone() const = 0;
00074
00075
00076
00077 template<class T>
00078 bool instanceof() const {
00079 void* value = const_cast<address_v*>(this)->data(typeid(T));
00080 return value!=NULL;
00081 }
00082
00084 template<class T>
00085 inline operator T&() {
00086 void* value = data(typeid(T));
00087 assert (value!=NULL);
00088 return *((T*) value);
00089 }
00090
00092 template<class T>
00093 inline operator T () const {
00094 return T( (const T&)*this );
00095 }
00096
00098 template<class T>
00099 inline operator const T& () const {
00100 void* value = const_cast<address_v*>(this)->data(typeid(T));
00101 assert (value!=NULL);
00102 return *((const T*) value);
00103 }
00104 };
00105
00107 std::ostream& operator<<(std::ostream& s, const address_v* addr);
00108
00110 typedef vfacade<address_v> address_vf;
00111
00112 }}
00113
00115 template<class NonVirtual, class AdaptorType>
00116 class vobject_hull<NonVirtual, ariba::addressing::address_v, AdaptorType> : public ariba::addressing::address_v {
00117
00118 private:
00119 typedef ariba::addressing::address_v self;
00120 typename AdaptorType::template adaptor_type<NonVirtual> obj;
00121
00122 static inline NonVirtual& conv(ariba::addressing::address_v* obj) {
00123 return *((NonVirtual*) obj->data(typeid(NonVirtual)));
00124 }
00125
00126 static inline const NonVirtual& conv(const ariba::addressing::address_v* obj) {
00127 const NonVirtual* v =
00128 (const NonVirtual*) const_cast<ariba::addressing::address_v*> (obj)->data(
00129 typeid(NonVirtual));
00130 return *v;
00131 }
00132
00133 public:
00134 template<typename T>
00135 explicit vobject_hull(T& obj) :
00136 obj(obj) {
00137 }
00138 explicit vobject_hull() :
00139 obj() {
00140 }
00141
00142
00143
00145 virtual bool assign(const self& rhs) {
00146 return obj->assign(conv(&rhs));
00147 }
00148
00149
00150
00152 virtual const string& type_name() const {
00153 return obj->type_name();
00154 }
00155
00157 virtual uint16_t type_id() const {
00158 return obj->type_id();
00159 }
00160
00162 virtual address_v* clone() const {
00163 return vcapsule<address_v> (*obj);
00164 }
00165
00167 virtual void* data(const std::type_info& type) {
00168 if (typeid(NonVirtual)!=type) return NULL;
00169 return &(*obj);
00170 }
00171
00172
00173
00175 virtual string to_string() const {
00176 return obj->to_string();
00177 }
00178
00180 virtual bool assign(const std::string& text) {
00181 return obj->assign(text);
00182 }
00183
00184
00185
00187 virtual int compare_to(const self& rhs) const {
00188 const address_v* compare = dynamic_cast<const address_v*> (&rhs);
00189 return obj->compare_to(conv(compare));
00190 }
00191
00192
00193
00195 virtual bool is_bytes_size_static() const {
00196 return obj->is_bytes_size_static();
00197 }
00198
00200 virtual size_t to_bytes_size() const {
00201 return obj->to_bytes_size();
00202 }
00203
00205 virtual void to_bytes(uint8_t* bytes) const {
00206 obj->to_bytes(bytes);
00207 }
00208
00210 virtual bool assign(const uint8_t* bytes, size_t size) {
00211 return obj->assign(bytes, size);
00212 }
00213
00214 };
00215
00216
00217 #endif