BlynkParam.h

00001 /**
00002  * @file       BlynkParam.h
00003  * @author     Volodymyr Shymanskyy
00004  * @license    This project is released under the MIT License (MIT)
00005  * @copyright  Copyright (c) 2015 Volodymyr Shymanskyy
00006  * @date       Jan 2015
00007  * @brief      Container for handler parameters
00008  *
00009  */
00010 
00011 #ifndef BlynkParam_h
00012 #define BlynkParam_h
00013 
00014 #include <string.h>
00015 #include <stdlib.h>
00016 #include <Blynk/BlynkConfig.h>
00017 #include <Blynk/BlynkDebug.h>
00018 
00019 #define BLYNK_PARAM_KV(k, v) k "\0" v "\0"
00020 
00021 class BlynkParam
00022 {
00023 public:
00024     class iterator
00025     {
00026     public:
00027         iterator(char* c) : ptr(c) {}
00028         static iterator invalid() { return iterator(NULL); }
00029 
00030         operator const char* () const   { return asStr(); }
00031         operator int () const           { return asInt(); }
00032         const char* asStr() const       { return ptr; }
00033         const char* asString() const    { return ptr; }
00034         int         asInt() const       { return atoi(ptr); }
00035         long        asLong() const      { return atol(ptr); }
00036 #ifndef BLYNK_NO_FLOAT
00037         double      asDouble() const    { return atof(ptr); }
00038 #endif
00039         bool isValid() const            { return ptr != NULL; }
00040 
00041         bool operator <  (const iterator& it) const { return ptr < it.ptr; }
00042         bool operator >= (const iterator& it) const { return ptr >= it.ptr; }
00043 
00044         iterator& operator ++() {
00045             ptr += strlen(ptr)+1;
00046             return *this;
00047         }
00048     private:
00049         const char* ptr;
00050     };
00051 
00052 public:
00053     explicit
00054     BlynkParam(void* addr, size_t length)
00055         : buff((char*)addr), len(length), buff_size(length)
00056     {}
00057 
00058     explicit
00059     BlynkParam(void* addr, size_t length, size_t buffsize)
00060         : buff((char*)addr), len(length), buff_size(buffsize)
00061     {}
00062 
00063     const char* asStr() const       { return buff; }
00064     const char* asString() const    { return buff; }
00065     int         asInt() const       { return atoi(buff); }
00066     long        asLong() const      { return atol(buff); }
00067 #ifndef BLYNK_NO_FLOAT
00068     double      asDouble() const    { return atof(buff); }
00069 #endif
00070 
00071     iterator begin() const { return iterator(buff); }
00072     iterator end() const   { return iterator(buff+len); }
00073 
00074     iterator operator[](int index) const;
00075     iterator operator[](const char* key) const;
00076 
00077     void*  getBuffer() const { return (void*)buff; }
00078     size_t getLength() const { return len; }
00079 
00080     // Modification
00081     void add(int value);
00082     void add(unsigned int value);
00083     void add(long value);
00084     void add(unsigned long value);
00085 #ifndef BLYNK_NO_FLOAT
00086     void add(float value);
00087     void add(double value);
00088 #endif
00089     void add(const char* str);
00090     void add(const void* b, size_t l);
00091 #if defined(ARDUINO) || defined(SPARK) || defined(PARTICLE)
00092     void add(const String& str);
00093     void add(String& str);
00094 #endif
00095 
00096     template <typename TV>
00097     void add_key(const char* key, const TV& val) {
00098         add(key);
00099         add(val);
00100     }
00101 
00102 private:
00103     char*   buff;
00104     size_t  len;
00105     size_t  buff_size;
00106 };
00107 
00108 inline
00109 BlynkParam::iterator BlynkParam::operator[](int index) const
00110 {
00111     const iterator e = end();
00112     for (iterator it = begin(); it < e; ++it) {
00113         if (!index--) {
00114             return it;
00115         }
00116     }
00117     return iterator::invalid();
00118 }
00119 
00120 inline
00121 BlynkParam::iterator BlynkParam::operator[](const char* key) const
00122 {
00123     const iterator e = end();
00124     for (iterator it = begin(); it < e; ++it) {
00125         if (!strcmp(it.asStr(), key)) {
00126             return ++it;
00127         }
00128         ++it;
00129         if (it >= e) break;
00130     }
00131     return iterator::invalid();
00132 }
00133 
00134 inline
00135 void BlynkParam::add(const void* b, size_t l)
00136 {
00137     if (len + l > buff_size)
00138         return;
00139     memcpy(buff+len, b, l);
00140     len += l;
00141 }
00142 
00143 inline
00144 void BlynkParam::add(const char* str)
00145 {
00146     add(str, strlen(str)+1);
00147 }
00148 
00149 #if defined(ARDUINO) || defined(SPARK) || defined(PARTICLE)
00150 inline
00151 void BlynkParam::add(const String& str)
00152 {
00153     size_t len = str.length()+1;
00154     char buff[len];
00155 #if defined(ARDUINO_AVR_DIGISPARK)
00156     const_cast<String&>(str).toCharArray(buff, len);
00157 #else
00158     str.toCharArray(buff, len);
00159 #endif
00160     BlynkParam::add(buff, len);
00161 }
00162 
00163 inline
00164 void BlynkParam::add(String& str)
00165 {
00166     size_t len = str.length()+1;
00167     char buff[len];
00168     str.toCharArray(buff, len);
00169     BlynkParam::add(buff, len);
00170 }
00171 #endif
00172 
00173 #if defined(__AVR__) || defined (ARDUINO_ARCH_ARC32)
00174 
00175     #include <stdlib.h>
00176 
00177     inline
00178     void BlynkParam::add(int value)
00179     {
00180         char str[2 + 8 * sizeof(value)];
00181         itoa(value, str, 10);
00182         add(str);
00183     }
00184 
00185     inline
00186     void BlynkParam::add(unsigned int value)
00187     {
00188         char str[1 + 8 * sizeof(value)];
00189         utoa(value, str, 10);
00190         add(str);
00191     }
00192 
00193     inline
00194     void BlynkParam::add(long value)
00195     {
00196         char str[2 + 8 * sizeof(value)];
00197         ltoa(value, str, 10);
00198         add(str);
00199     }
00200 
00201     inline
00202     void BlynkParam::add(unsigned long value)
00203     {
00204         char str[1 + 8 * sizeof(value)];
00205         ultoa(value, str, 10);
00206         add(str);
00207     }
00208 
00209 #ifndef BLYNK_NO_FLOAT
00210 
00211     inline
00212     void BlynkParam::add(float value)
00213     {
00214         char str[33];
00215         dtostrf(value, 5, 3, str);
00216         add(str);
00217     }
00218 
00219     inline
00220     void BlynkParam::add(double value)
00221     {
00222         char str[33];
00223         dtostrf(value, 5, 3, str);
00224         add(str);
00225     }
00226 #endif
00227 
00228 #else
00229 
00230     #include <stdio.h>
00231 
00232     inline
00233     void BlynkParam::add(int value)
00234     {
00235         len += snprintf(buff+len, buff_size-len, "%i", value)+1;
00236     }
00237 
00238     inline
00239     void BlynkParam::add(unsigned int value)
00240     {
00241         len += snprintf(buff+len, buff_size-len, "%u", value)+1;
00242     }
00243 
00244     inline
00245     void BlynkParam::add(long value)
00246     {
00247         len += snprintf(buff+len, buff_size-len, "%li", value)+1;
00248     }
00249 
00250     inline
00251     void BlynkParam::add(unsigned long value)
00252     {
00253         len += snprintf(buff+len, buff_size-len, "%lu", value)+1;
00254     }
00255 
00256 #ifndef BLYNK_NO_FLOAT
00257 
00258 #if defined(ESP8266)
00259 
00260     extern char* dtostrf_internal(double number, signed char width, unsigned char prec, char *s);
00261 
00262     inline
00263     void BlynkParam::add(float value)
00264     {
00265         char str[33];
00266         dtostrf_internal(value, 5, 3, str);
00267         add(str);
00268     }
00269 
00270     inline
00271     void BlynkParam::add(double value)
00272     {
00273         char str[33];
00274         dtostrf_internal(value, 5, 3, str);
00275         add(str);
00276     }
00277 
00278 #else
00279 
00280     inline
00281     void BlynkParam::add(float value)
00282     {
00283         len += snprintf(buff+len, buff_size-len, "%2.3f", value)+1;
00284     }
00285 
00286     inline
00287     void BlynkParam::add(double value)
00288     {
00289         len += snprintf(buff+len, buff_size-len, "%2.3f", value)+1;
00290     }
00291 
00292 #endif
00293 
00294 #endif
00295 
00296 #endif
00297 
00298 
00299 #endif
00300