uMP.cpp

00001 /* uMP - micro MessagePack class
00002  * Copyright (c) 2014 Yuuichi Akagawa
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *      http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #include "mbed.h"
00018 #include "uMP.h"
00019 
00020 uMP::uMP() :
00021 _ptr(0), _nbuf(DEFAULT_BUFFSIZE)
00022 {
00023     _buf = new uint8_t[_nbuf]; 
00024 }
00025 
00026 uMP::uMP(uint32_t size) :
00027 _ptr(0), _nbuf(size)
00028 {
00029   _buf = new uint8_t[_nbuf]; 
00030 }
00031 
00032 uMP::~uMP()
00033 {
00034     delete[] _buf;
00035 }
00036 
00037 /* MessagePack funcions (Subset) */
00038 bool uMP::set_nil()
00039 {
00040     return set_buffer(TAG_NIL);
00041 }
00042 
00043 bool uMP::set_true()
00044 {
00045     return set_buffer(TAG_TRUE);
00046 }
00047 
00048 bool uMP::set_false()
00049 {
00050     return set_buffer(TAG_FALSE);
00051 }
00052 
00053 bool uMP::start_array(uint32_t size)
00054 {
00055     if (size <= 0x0f) {
00056         return set_buffer((uint8_t)(TAG_FIXARRAY | size));
00057     }
00058     return false;
00059 }
00060 
00061 bool uMP::start_map(uint32_t size)
00062 {
00063     if (size <= 0x0f) {
00064         return set_buffer((uint8_t)(TAG_FIXMAP | size));
00065     }
00066 #if 0
00067     if (size <= 0xffff) {
00068         return cmp_write_map16(ctx, size);
00069     }
00070 #endif
00071     return false;
00072 }
00073 
00074 bool uMP::set_uint(uint32_t u)
00075 {
00076     if (u <= 0x7f) {
00077         return set_buffer((uint8_t)u);
00078     }
00079     if (u <= 0xff) {
00080         return set_u8((uint8_t)u);
00081     }
00082     if (u <= 0xffff) {
00083         return set_u16((uint16_t)u);
00084     }
00085     if (u <= 0xffffffff) {
00086         return set_u32(u);
00087     }
00088     return false;
00089 }
00090 
00091 bool uMP::set_u8(uint8_t u)
00092 {
00093     if (!set_buffer((uint8_t)TAG_U8)) {
00094         return false;
00095     }
00096     return set_buffer(u);
00097 }
00098 
00099 bool uMP::set_u16(uint16_t u)
00100 {
00101     if (!set_buffer((uint8_t)TAG_U16)) {
00102         return false;
00103     }
00104 
00105     u = to_be16(u);
00106     return set_buffer((uint8_t*)&u, sizeof(uint16_t));
00107 }
00108 
00109 bool uMP::set_u32(uint32_t u)
00110 {
00111     if (!set_buffer((uint8_t)TAG_U32)) {
00112         return false;
00113     }
00114 
00115     u = to_be32(u);
00116     return set_buffer((uint8_t*)&u, sizeof(uint32_t));
00117 }
00118 
00119 bool uMP::set_u64(uint64_t u)
00120 {
00121     if (!set_buffer((uint8_t)TAG_U64)) {
00122         return false;
00123     }
00124 
00125     u = to_be64(u);
00126     return set_buffer((uint8_t*)&u, sizeof(uint64_t));
00127 }
00128 
00129 bool uMP::set_sint(int32_t i)
00130 {
00131     if (i >=0) {
00132         return set_uint((uint32_t)i);
00133     }
00134     if (i >= -32) {
00135         return set_buffer((uint8_t)i);
00136     }
00137     if (i >= -128) {
00138         return set_s8(i);
00139     }
00140     if (i >= -32768) {
00141         return set_s16(i);
00142     }
00143     if (i >= -2147483648) {
00144         return set_s32(i);
00145     }
00146     return false;
00147 }
00148 
00149 bool uMP::set_s8(int8_t i)
00150 {
00151     if (!set_buffer((uint8_t)TAG_S8)) {
00152         return false;
00153     }
00154     return set_buffer((uint8_t)i);
00155 }
00156 
00157 bool uMP::set_s16(int16_t i)
00158 {
00159     if (!set_buffer((uint8_t)TAG_S16)) {
00160         return false;
00161     }
00162 
00163     i = to_be16(i);
00164     return set_buffer((uint8_t*)&i, sizeof(int16_t));
00165 }
00166 
00167 bool uMP::set_s32(int32_t i)
00168 {
00169     if (!set_buffer((uint8_t)TAG_S32)) {
00170         return false;
00171     }
00172 
00173     i = to_be32(i);
00174     return set_buffer((uint8_t*)&i, sizeof(int32_t));
00175 }
00176 
00177 bool uMP::set_s64(int64_t i)
00178 {
00179     if (!set_buffer((uint8_t)TAG_S64)) {
00180         return false;
00181     }
00182 
00183     i = to_be64(i);
00184     return set_buffer((uint8_t*)&i, sizeof(int64_t));
00185 }
00186 
00187 bool uMP::set_str(const char *data, uint32_t size)
00188 {
00189     if (size <= 0x1f) {
00190         return set_fixstr(data, size);
00191     }
00192     if (size <= 0xff) {
00193         return set_str8(data, size);
00194     }
00195     return false;
00196 }
00197 
00198 bool uMP::set_str(const std::string& str)
00199 {
00200     return set_str(str.c_str(), (uint32_t)str.size());
00201 }
00202 
00203 bool uMP::set_fixstr(const char *data, uint8_t size)
00204 {
00205     if (size > 0x1f) {
00206         return false;
00207     }
00208     if (!set_buffer((uint8_t)(TAG_FIXSTR | size))) {
00209         return false;
00210     }
00211     if (!set_buffer((uint8_t*)data, size)) {
00212         return false;
00213     }
00214     return true;
00215 }
00216 
00217 bool uMP::set_str8(const char *data, uint8_t size)
00218 {
00219     if (size > 0xff) {
00220         return false;
00221     }
00222     if (!set_buffer((uint8_t)TAG_STR8)) {
00223         return false;
00224     }
00225     if (!set_buffer((uint8_t)size)) {
00226         return false;
00227     }
00228     if (!set_buffer((uint8_t*)data, size)) {
00229         return false;
00230     }
00231     return true;
00232 }
00233 
00234 bool uMP::set_raw(const char *data, uint8_t size)
00235 {
00236     if (!set_buffer((uint8_t*)data, size)) {
00237         return false;
00238     }
00239     return true;
00240 }
00241 
00242 bool uMP::set_float(float f)
00243 {
00244     if (!set_buffer((uint8_t)TAG_FLOAT32)) {
00245         return false;
00246     }
00247     f = to_be32(f);
00248     if (!set_buffer((uint8_t*)&f, sizeof(float))) {
00249         return false;
00250     }
00251     return true;
00252 }
00253 
00254 bool uMP::set_double(double d)
00255 {
00256     if (!set_buffer((uint8_t)TAG_FLOAT64)) {
00257         return false;
00258     }
00259     d = to_be64(d);
00260     if (!set_buffer((uint8_t*)&d, sizeof(double))) {
00261         return false;
00262     }
00263     return true;
00264 }
00265 
00266 bool uMP::set_buffer(const uint8_t c)
00267 {
00268     //buffer overflow?
00269     if ( _ptr == _nbuf) {
00270         return false;
00271     }
00272     *(_buf+_ptr) = c;
00273     _ptr++;
00274     return true;
00275 }
00276 
00277 bool uMP::set_buffer(const uint8_t *c, size_t size)
00278 {
00279     //buffer overflow?
00280     if ( (_ptr+size) > _nbuf) {
00281         return false;
00282     }
00283     while (size--) {
00284         *(_buf+_ptr) = *c++;
00285         _ptr++;
00286     }
00287     return true;
00288 }
00289 
00290 //ByteOrder
00291 template<typename T> T uMP::to_be16(T t)
00292 {
00293     uint16_t *x = (uint16_t *)&t;
00294     *x = __REV16(*x);
00295     return t;
00296 }
00297 
00298 template<typename T> T uMP::to_be32(T t)
00299 {
00300     uint32_t *x = (uint32_t *)&t;
00301     *x = __REV(*x);
00302     return t;
00303 }
00304 
00305 template<typename T> T uMP::to_be64(T t)
00306 {
00307     uint32_t *x = (uint32_t *)&t;
00308     uint32_t h = __REV(*x);
00309     uint32_t l = __REV(*(x+1));
00310     //swap
00311     *x     = l;
00312     *(x+1) = h;
00313     return t;
00314 }
00315 
00316 // map functions
00317 bool uMP::map(const std::string& k, uint8_t v)
00318 {
00319     if( set_str(k) == false )
00320         return false;
00321     return set_u8(v);
00322 }
00323 
00324 bool uMP::map(const std::string& k, uint16_t v)
00325 {
00326     if( set_str(k) == false )
00327         return false;
00328     return set_u16(v);
00329 }
00330 
00331 bool uMP::map(const std::string& k, uint32_t v)
00332 {
00333     if( set_str(k) == false )
00334         return false;
00335     return set_uint(v);
00336 }
00337 
00338 bool uMP::map(const std::string& k, int8_t v)
00339 {
00340     if( set_str(k) == false )
00341         return false;
00342     return set_s8(v);
00343 }
00344 
00345 bool uMP::map(const std::string& k, int16_t v)
00346 {
00347     if( set_str(k) == false )
00348         return false;
00349     return set_s16(v);
00350 }
00351 
00352 bool uMP::map(const std::string& k, int32_t v)
00353 {
00354     if( set_str(k) == false )
00355         return false;
00356     return set_sint(v);
00357 }
00358 
00359 bool uMP::map(const std::string& k, float v)
00360 {
00361     if( set_str(k) == false )
00362         return false;
00363     return set_float(v);
00364 }
00365 
00366 bool uMP::map(const std::string& k, double v)
00367 {
00368     if( set_str(k) == false )
00369         return false;
00370     return set_double(v);
00371 }
00372 
00373 bool uMP::map(const std::string& k, const char *v)
00374 {
00375     if( set_str(k) == false )
00376         return false;
00377     return set_str(v);
00378 }
00379 
00380 bool uMP::map(const std::string& k, const std::string& v)
00381 {
00382     if( set_str(k) == false )
00383         return false;
00384     return set_str(v);
00385 }