00001
00002
00003
00004
00005
00006 #ifdef _MSC_VER
00007 # pragma warning(disable:4101)
00008 # pragma warning(disable:4065)
00009 #endif
00010
00011 #include <iostream>
00012 #include <sstream>
00013 #include "RAWEtherFrame_m.h"
00014
00015
00016 template<typename T>
00017 std::ostream& operator<<(std::ostream& out,const T&) {return out;}
00018
00019
00020 template<typename T>
00021 void doPacking(cCommBuffer *, T& t) {
00022 throw cRuntimeError("Parsim error: no doPacking() function for type %s or its base class (check .msg and _m.cc/h files!)",opp_typename(typeid(t)));
00023 }
00024
00025 template<typename T>
00026 void doUnpacking(cCommBuffer *, T& t) {
00027 throw cRuntimeError("Parsim error: no doUnpacking() function for type %s or its base class (check .msg and _m.cc/h files!)",opp_typename(typeid(t)));
00028 }
00029
00030
00031
00032
00033 RAWEtherFrame_Base::RAWEtherFrame_Base(const char *name, int kind) : cPacket(name,kind)
00034 {
00035 rawBytes_arraysize = 0;
00036 this->rawBytes_var = 0;
00037 }
00038
00039 RAWEtherFrame_Base::RAWEtherFrame_Base(const RAWEtherFrame_Base& other) : cPacket()
00040 {
00041 setName(other.getName());
00042 rawBytes_arraysize = 0;
00043 this->rawBytes_var = 0;
00044 operator=(other);
00045 }
00046
00047 RAWEtherFrame_Base::~RAWEtherFrame_Base()
00048 {
00049 delete [] rawBytes_var;
00050 }
00051
00052 RAWEtherFrame_Base& RAWEtherFrame_Base::operator=(const RAWEtherFrame_Base& other)
00053 {
00054 if (this==&other) return *this;
00055 cPacket::operator=(other);
00056 delete [] this->rawBytes_var;
00057 this->rawBytes_var = (other.rawBytes_arraysize==0) ? NULL : new char[other.rawBytes_arraysize];
00058 rawBytes_arraysize = other.rawBytes_arraysize;
00059 for (unsigned int i=0; i<rawBytes_arraysize; i++)
00060 this->rawBytes_var[i] = other.rawBytes_var[i];
00061 return *this;
00062 }
00063
00064 void RAWEtherFrame_Base::parsimPack(cCommBuffer *b)
00065 {
00066 cPacket::parsimPack(b);
00067 b->pack(rawBytes_arraysize);
00068 doPacking(b,this->rawBytes_var,rawBytes_arraysize);
00069 }
00070
00071 void RAWEtherFrame_Base::parsimUnpack(cCommBuffer *b)
00072 {
00073 cPacket::parsimUnpack(b);
00074 delete [] this->rawBytes_var;
00075 b->unpack(rawBytes_arraysize);
00076 if (rawBytes_arraysize==0) {
00077 this->rawBytes_var = 0;
00078 } else {
00079 this->rawBytes_var = new char[rawBytes_arraysize];
00080 doUnpacking(b,this->rawBytes_var,rawBytes_arraysize);
00081 }
00082 }
00083
00084 void RAWEtherFrame_Base::setRawBytesArraySize(unsigned int size)
00085 {
00086 char *rawBytes_var2 = (size==0) ? NULL : new char[size];
00087 unsigned int sz = rawBytes_arraysize < size ? rawBytes_arraysize : size;
00088 for (unsigned int i=0; i<sz; i++)
00089 rawBytes_var2[i] = this->rawBytes_var[i];
00090 for (unsigned int i=sz; i<size; i++)
00091 rawBytes_var2[i] = 0;
00092 rawBytes_arraysize = size;
00093 delete [] this->rawBytes_var;
00094 this->rawBytes_var = rawBytes_var2;
00095 }
00096
00097 unsigned int RAWEtherFrame_Base::getRawBytesArraySize() const
00098 {
00099 return rawBytes_arraysize;
00100 }
00101
00102 char RAWEtherFrame_Base::getRawBytes(unsigned int k) const
00103 {
00104 if (k>=rawBytes_arraysize) throw cRuntimeError("Array of size %d indexed by %d", rawBytes_arraysize, k);
00105 return rawBytes_var[k];
00106 }
00107
00108 void RAWEtherFrame_Base::setRawBytes(unsigned int k, char rawBytes_var)
00109 {
00110 if (k>=rawBytes_arraysize) throw cRuntimeError("Array of size %d indexed by %d", rawBytes_arraysize, k);
00111 this->rawBytes_var[k]=rawBytes_var;
00112 }
00113
00114 class RAWEtherFrameDescriptor : public cClassDescriptor
00115 {
00116 public:
00117 RAWEtherFrameDescriptor();
00118 virtual ~RAWEtherFrameDescriptor();
00119
00120 virtual bool doesSupport(cObject *obj) const;
00121 virtual const char *getProperty(const char *propertyname) const;
00122 virtual int getFieldCount(void *object) const;
00123 virtual const char *getFieldName(void *object, int field) const;
00124 virtual unsigned int getFieldTypeFlags(void *object, int field) const;
00125 virtual const char *getFieldTypeString(void *object, int field) const;
00126 virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
00127 virtual int getArraySize(void *object, int field) const;
00128
00129 virtual bool getFieldAsString(void *object, int field, int i, char *resultbuf, int bufsize) const;
00130 virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;
00131
00132 virtual const char *getFieldStructName(void *object, int field) const;
00133 virtual void *getFieldStructPointer(void *object, int field, int i) const;
00134 };
00135
00136 Register_ClassDescriptor(RAWEtherFrameDescriptor);
00137
00138 RAWEtherFrameDescriptor::RAWEtherFrameDescriptor() : cClassDescriptor("RAWEtherFrame", "cPacket")
00139 {
00140 }
00141
00142 RAWEtherFrameDescriptor::~RAWEtherFrameDescriptor()
00143 {
00144 }
00145
00146 bool RAWEtherFrameDescriptor::doesSupport(cObject *obj) const
00147 {
00148 return dynamic_cast<RAWEtherFrame_Base *>(obj)!=NULL;
00149 }
00150
00151 const char *RAWEtherFrameDescriptor::getProperty(const char *propertyname) const
00152 {
00153 if (!strcmp(propertyname,"customize")) return "true";
00154 cClassDescriptor *basedesc = getBaseClassDescriptor();
00155 return basedesc ? basedesc->getProperty(propertyname) : NULL;
00156 }
00157
00158 int RAWEtherFrameDescriptor::getFieldCount(void *object) const
00159 {
00160 cClassDescriptor *basedesc = getBaseClassDescriptor();
00161 return basedesc ? 1+basedesc->getFieldCount(object) : 1;
00162 }
00163
00164 unsigned int RAWEtherFrameDescriptor::getFieldTypeFlags(void *object, int field) const
00165 {
00166 cClassDescriptor *basedesc = getBaseClassDescriptor();
00167 if (basedesc) {
00168 if (field < basedesc->getFieldCount(object))
00169 return basedesc->getFieldTypeFlags(object, field);
00170 field -= basedesc->getFieldCount(object);
00171 }
00172 switch (field) {
00173 case 0: return FD_ISARRAY | FD_ISEDITABLE;
00174 default: return 0;
00175 }
00176 }
00177
00178 const char *RAWEtherFrameDescriptor::getFieldName(void *object, int field) const
00179 {
00180 cClassDescriptor *basedesc = getBaseClassDescriptor();
00181 if (basedesc) {
00182 if (field < basedesc->getFieldCount(object))
00183 return basedesc->getFieldName(object, field);
00184 field -= basedesc->getFieldCount(object);
00185 }
00186 switch (field) {
00187 case 0: return "rawBytes";
00188 default: return NULL;
00189 }
00190 }
00191
00192 const char *RAWEtherFrameDescriptor::getFieldTypeString(void *object, int field) const
00193 {
00194 cClassDescriptor *basedesc = getBaseClassDescriptor();
00195 if (basedesc) {
00196 if (field < basedesc->getFieldCount(object))
00197 return basedesc->getFieldTypeString(object, field);
00198 field -= basedesc->getFieldCount(object);
00199 }
00200 switch (field) {
00201 case 0: return "char";
00202 default: return NULL;
00203 }
00204 }
00205
00206 const char *RAWEtherFrameDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
00207 {
00208 cClassDescriptor *basedesc = getBaseClassDescriptor();
00209 if (basedesc) {
00210 if (field < basedesc->getFieldCount(object))
00211 return basedesc->getFieldProperty(object, field, propertyname);
00212 field -= basedesc->getFieldCount(object);
00213 }
00214 switch (field) {
00215 default: return NULL;
00216 }
00217 }
00218
00219 int RAWEtherFrameDescriptor::getArraySize(void *object, int field) const
00220 {
00221 cClassDescriptor *basedesc = getBaseClassDescriptor();
00222 if (basedesc) {
00223 if (field < basedesc->getFieldCount(object))
00224 return basedesc->getArraySize(object, field);
00225 field -= basedesc->getFieldCount(object);
00226 }
00227 RAWEtherFrame_Base *pp = (RAWEtherFrame_Base *)object; (void)pp;
00228 switch (field) {
00229 case 0: return pp->getRawBytesArraySize();
00230 default: return 0;
00231 }
00232 }
00233
00234 bool RAWEtherFrameDescriptor::getFieldAsString(void *object, int field, int i, char *resultbuf, int bufsize) const
00235 {
00236 cClassDescriptor *basedesc = getBaseClassDescriptor();
00237 if (basedesc) {
00238 if (field < basedesc->getFieldCount(object))
00239 return basedesc->getFieldAsString(object,field,i,resultbuf,bufsize);
00240 field -= basedesc->getFieldCount(object);
00241 }
00242 RAWEtherFrame_Base *pp = (RAWEtherFrame_Base *)object; (void)pp;
00243 switch (field) {
00244 case 0: long2string(pp->getRawBytes(i),resultbuf,bufsize); return true;
00245 default: return false;
00246 }
00247 }
00248
00249 bool RAWEtherFrameDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
00250 {
00251 cClassDescriptor *basedesc = getBaseClassDescriptor();
00252 if (basedesc) {
00253 if (field < basedesc->getFieldCount(object))
00254 return basedesc->setFieldAsString(object,field,i,value);
00255 field -= basedesc->getFieldCount(object);
00256 }
00257 RAWEtherFrame_Base *pp = (RAWEtherFrame_Base *)object; (void)pp;
00258 switch (field) {
00259 case 0: pp->setRawBytes(i,string2long(value)); return true;
00260 default: return false;
00261 }
00262 }
00263
00264 const char *RAWEtherFrameDescriptor::getFieldStructName(void *object, int field) const
00265 {
00266 cClassDescriptor *basedesc = getBaseClassDescriptor();
00267 if (basedesc) {
00268 if (field < basedesc->getFieldCount(object))
00269 return basedesc->getFieldStructName(object, field);
00270 field -= basedesc->getFieldCount(object);
00271 }
00272 switch (field) {
00273 default: return NULL;
00274 }
00275 }
00276
00277 void *RAWEtherFrameDescriptor::getFieldStructPointer(void *object, int field, int i) const
00278 {
00279 cClassDescriptor *basedesc = getBaseClassDescriptor();
00280 if (basedesc) {
00281 if (field < basedesc->getFieldCount(object))
00282 return basedesc->getFieldStructPointer(object, field, i);
00283 field -= basedesc->getFieldCount(object);
00284 }
00285 RAWEtherFrame_Base *pp = (RAWEtherFrame_Base *)object; (void)pp;
00286 switch (field) {
00287 default: return NULL;
00288 }
00289 }
00290
00291