KeySerialize.cc

Go to the documentation of this file.
00001 #include "KeySerialize.h"
00002 
00003 namespace oasys {
00004 
00006 KeyMarshal::KeyMarshal(ExpandableBuffer* buf,
00007                        const char*       border)
00008     : SerializeAction(Serialize::MARSHAL, Serialize::CONTEXT_LOCAL),
00009       buf_(buf),
00010       border_(border)
00011 {}
00012     
00014 void 
00015 KeyMarshal::process(const char* name,
00016                     u_int32_t*  i)
00017 {
00018     (void)name;
00019     process_int(*i, 8, "%08x");
00020     border();
00021 }
00022 
00024 void 
00025 KeyMarshal::process(const char* name,
00026                     u_int16_t*  i)
00027 {
00028     (void)name;
00029     process_int(*i, 4, "%04x");
00030     border();
00031 }
00032 
00034 void 
00035 KeyMarshal::process(const char* name,
00036                     u_int8_t*   i)
00037 {
00038     (void)name;
00039     process_int(*i, 2, "%02x");
00040     border();
00041 }
00042 
00044 void 
00045 KeyMarshal::process(const char* name,
00046                     bool*       b)
00047 {
00048     (void)name;
00049     process_int( (*b) ? 1 : 0, 1, "%1u");
00050     border();
00051 }
00052 
00054 void 
00055 KeyMarshal::process(const char* name,
00056                     u_char*     bp,
00057                     size_t      len)
00058 {
00059     (void)name;
00060     if (error()) 
00061         return;
00062 
00063     buf_->reserve(buf_->len() + len);
00064     memcpy(buf_->end(), bp, len);
00065     buf_->set_len(buf_->len() + len);
00066     border();
00067 }
00068 
00070 void 
00071 KeyMarshal::process(const char* name,
00072                     u_char**    bp,
00073                     size_t*     lenp,
00074                     int         flags)
00075 {
00076     (void)name;
00077     if (error()) 
00078         return;
00079 
00080     ASSERT(! (lenp == 0 && ! (flags & Serialize::NULL_TERMINATED)));
00081 
00082     size_t len;
00083     if (flags & Serialize::NULL_TERMINATED) {
00084         len = strlen(reinterpret_cast<char*>(*bp));
00085     } else {
00086         len = *lenp;
00087     }
00088 
00089     process_int(len, 8, "%08x");
00090 
00091     buf_->reserve(buf_->len() + len);
00092     memcpy(buf_->end(), *bp, len);
00093     buf_->set_len(buf_->len() + len);
00094     border();
00095 }
00096 
00098 void 
00099 KeyMarshal::process(const char*  name,
00100                     std::string* s)
00101 {
00102     (void)name;
00103     if (error()) 
00104         return;
00105 
00106     process_int(s->length(), 8, "%08x");
00107     buf_->reserve(buf_->len() + s->size());
00108     memcpy(buf_->end(), s->c_str(), s->size());
00109     buf_->set_len(buf_->len() + s->size());
00110     border();
00111 }
00112 
00114 void 
00115 KeyMarshal::process(const char*         name,
00116                     SerializableObject* object)
00117 {
00118     (void)name;
00119     if (error()) 
00120         return;
00121 
00122     int err = action(object);
00123     if (err != 0) {
00124         signal_error();
00125     }
00126     border();
00127 }
00128 
00130 void
00131 KeyMarshal::end_action()
00132 {
00133     buf_->reserve(1);
00134     *(buf_->end()) = '\0';
00135 }
00136 
00138 void
00139 KeyMarshal::process_int(u_int32_t i, size_t size, const char* format)
00140 {
00141     if (error()) 
00142         return;
00143 
00144     buf_->reserve(buf_->len() + size + 1);
00145     int cc = snprintf(buf_->end(), size + 1, format, i);
00146     ASSERT(cc == (int)size);
00147     buf_->set_len(buf_->len() + size);
00148 }
00149 
00150 void
00151 KeyMarshal::border()
00152 {
00153     if (error() || border_ == 0) {
00154         return;
00155     }
00156 
00157     size_t border_len = strlen(border_);
00158     buf_->reserve(border_len);
00159     memcpy(buf_->end(), border_, border_len);
00160     buf_->set_len(buf_->len() + border_len);
00161 }
00162 
00164 KeyUnmarshal::KeyUnmarshal(const char* buf,
00165                            size_t      buf_len,
00166                            const char* border)
00167     : SerializeAction(Serialize::UNMARSHAL, Serialize::CONTEXT_LOCAL),
00168       buf_(buf),
00169       buf_len_(buf_len),
00170       border_len_( (border == 0) ? 0 : strlen(border)),
00171       cur_(0)
00172 {}
00173 
00175 void 
00176 KeyUnmarshal::process(const char* name, u_int32_t* i)
00177 {
00178     (void)name;
00179     u_int32_t val = process_int(8);
00180     if (! error()) {
00181         *i = val;
00182     }
00183     border();
00184 }
00185 
00187 void 
00188 KeyUnmarshal::process(const char* name, u_int16_t* i)
00189 {
00190     (void)name;
00191     u_int16_t val = static_cast<u_int16_t>(process_int(4));
00192     if (! error()) {
00193         *i = val;
00194     }
00195     border();
00196 }
00197 
00199 void 
00200 KeyUnmarshal::process(const char* name, u_int8_t* i)
00201 {
00202     (void)name;
00203     u_int8_t val = static_cast<u_int8_t>(process_int(2));
00204     if (! error()) {
00205         *i = val;
00206     }
00207     border();
00208 }
00209 
00211 void 
00212 KeyUnmarshal::process(const char* name, bool* b)
00213 {
00214     (void)name;
00215     if (error()) {
00216         return;
00217     }
00218 
00219     if (cur_ + 1 > buf_len_) {
00220         signal_error();
00221         return;
00222     }
00223     
00224     *b = (buf_[cur_] == '1') ? true : false;
00225     cur_ += 1;
00226     border();
00227 }
00228 
00230 void 
00231 KeyUnmarshal::process(const char* name, u_char* bp, size_t len)
00232 {
00233     (void)name;
00234     if (error()) {
00235         return;
00236     }
00237 
00238     if (cur_ + len > buf_len_) {
00239         signal_error();
00240         return;
00241     }
00242 
00243     memcpy(bp, &buf_[cur_], len);
00244     cur_ += len;
00245     border();
00246 }
00247 
00249 void 
00250 KeyUnmarshal::process(const char* name, u_char** bp, 
00251                       size_t* lenp, int flags)
00252 {
00253     (void)name;
00254     if (error()) {
00255         return;
00256     }
00257 
00258     size_t len = process_int(8);
00259     if (error()) {
00260         return;
00261     }
00262     
00263     if (flags & Serialize::ALLOC_MEM) {
00264         size_t malloc_len = (flags & Serialize::NULL_TERMINATED) ? 
00265                             len + 1 : len;
00266         *bp = static_cast<u_char*>(malloc(malloc_len));
00267         if (*bp == 0) {
00268             signal_error();
00269             return;
00270         }
00271     }
00272 
00273     ASSERT(*bp);
00274     if (lenp) {
00275         *lenp = len;
00276     }
00277     
00278     if (cur_ + len > buf_len_) {
00279         signal_error();
00280         return;
00281     }
00282 
00283     if (flags & Serialize::NULL_TERMINATED) {
00284         memcpy(*bp, &buf_[cur_], len);
00285         (*bp)[len] = '\0';
00286     } else {
00287         memcpy(*bp, &buf_[cur_], len);
00288     }
00289     
00290     cur_ += len;
00291     border();
00292 }
00293 
00295 void 
00296 KeyUnmarshal::process(const char* name, std::string* s) 
00297 {
00298     (void)name;
00299     if (error()) {
00300         return;
00301     }
00302 
00303     size_t len = process_int(8);
00304     if (error()) {
00305         return;
00306     }
00307 
00308     s->assign(&buf_[cur_], len);
00309     cur_ += len;
00310     border();
00311 }
00312 
00314 void 
00315 KeyUnmarshal::process(const char* name, SerializableObject* object)
00316 {
00317     (void)name;
00318     if (error()) {
00319         return;
00320     }
00321 
00322     if (action(object) != 0) {
00323         signal_error();
00324     }
00325     border();
00326 }
00327 
00329 u_int32_t
00330 KeyUnmarshal::process_int(size_t size)
00331 {
00332     char buf[9];
00333 
00334     if (cur_ + size > buf_len_) {
00335         signal_error();
00336         return 0;
00337     }
00338 
00339     memset(buf, 0, 9);
00340     memcpy(buf, &buf_[cur_], size);
00341     
00342     char* endptr;
00343     u_int32_t val = strtoul(buf, &endptr, 16);
00344     
00345     if (endptr == &buf_[cur_]) {
00346         signal_error();
00347         return 0;
00348     }
00349 
00350     cur_ += size;
00351 
00352     return val;
00353 }
00354 
00356 void
00357 KeyUnmarshal::border()
00358 {
00359     cur_ += border_len_;
00360 }
00361 
00362 } // namespace oasys

Generated on Fri Dec 22 14:47:59 2006 for DTN Reference Implementation by  doxygen 1.5.1