Payload.h

00001 /* mbed Microcontroller Library
00002 * Copyright (c) 2006-2013 ARM Limited
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 "debug.h"
00019 
00020 #ifndef __PAYLOAD_H__
00021 #define __PAYLOAD_H__
00022 
00023 class UnitPayload
00024 {
00025 public:
00026     uint8_t length;
00027     uint8_t id;    
00028     uint8_t *data;
00029     uint8_t *idptr;    
00030 
00031     
00032     
00033     void set_length(uint8_t l) {
00034         length=l;   
00035     }
00036 
00037     void set_id(uint8_t i) {
00038         id=i;
00039     }
00040 
00041     void set_data(uint8_t* data1) {
00042         for(int j=0;j<length;j++)
00043         {
00044             data[j]=data1[j];
00045         }   
00046     }
00047 
00048     uint8_t get_length()  {
00049         return length;      
00050     }
00051 
00052     uint8_t get_id()  {
00053         return id;      
00054     }
00055 
00056     uint8_t* get_data() {
00057         return data;        
00058     }
00059 
00060 };
00061 
00062 class Payload {
00063     UnitPayload *payload;
00064     int stringLength;
00065     int payloadUnitCount;
00066     
00067 public:
00068     Payload(const uint8_t *tokenString, uint8_t string_ength);
00069     Payload();
00070     uint8_t getPayloadUnitCount();
00071     
00072     uint8_t getIDAtIndex(int index);  
00073     uint8_t getLengthAtIndex(int index);   
00074     uint8_t* getDataAtIndex(int index);    
00075     int8_t getInt8AtIndex(int index);  
00076     uint16_t getUint16AtIndex(int index); 
00077     uint8_t* getSerializedAdDataAtIndex(int index);         
00078 };
00079 
00080 
00081 class PayloadUnit {
00082 private:        
00083     uint8_t* lenPtr;
00084     uint8_t* adTypePtr;
00085     uint8_t* dataPtr;
00086     
00087 public:
00088     PayloadUnit() {
00089         lenPtr = NULL;
00090         adTypePtr = NULL;
00091         dataPtr = NULL;
00092     }
00093     
00094     PayloadUnit(uint8_t *len, uint8_t *adType, uint8_t* data) {
00095         lenPtr = len;
00096         adTypePtr = adType;
00097         dataPtr = data;
00098     }    
00099     
00100     void setLenPtr(uint8_t *len)   {
00101         lenPtr = len;
00102     } 
00103     
00104     void setAdTypePtr(uint8_t *adType)   {
00105         adTypePtr = adType;
00106     }  
00107     
00108     void setDataPtr(uint8_t *data)   {
00109         dataPtr = data;
00110     }      
00111     
00112     uint8_t* getLenPtr()   {
00113         return lenPtr;
00114     } 
00115     
00116     uint8_t* getAdTypePtr()   {
00117         return adTypePtr;
00118     }  
00119     
00120     uint8_t* getDataPtr()   {
00121         return dataPtr;
00122     }   
00123     
00124     void printDataAsHex()   {
00125         int i = 0;
00126         PRINTF("AdData=");
00127         for(i=0; i<*lenPtr-1; i++) {
00128             PRINTF("0x%x ", dataPtr[i]);
00129         }
00130         PRINTF("\n");
00131     }     
00132     
00133     void printDataAsString()   {
00134         int i = 0;
00135         PRINTF("AdData=");
00136         for(i=0; i<*lenPtr; i++) {
00137             PRINTF("%c", dataPtr[i]);
00138         }
00139         PRINTF("\n");
00140     }                                                   
00141     
00142 };
00143 
00144 class PayloadPtr {
00145 private:
00146     PayloadUnit *unit;
00147     int payloadUnitCount;
00148 public:    
00149     PayloadPtr(const uint8_t *tokenString, uint8_t string_ength) {
00150         // initialize private data members
00151         int stringLength = string_ength;
00152         payloadUnitCount = 0;
00153         
00154         int index = 0;
00155         while(index!=stringLength) {
00156             int len=tokenString[index];
00157             index=index+1+len;
00158             payloadUnitCount++;               
00159         }
00160         
00161         // allocate memory to unit
00162         unit = new PayloadUnit[payloadUnitCount];
00163         int i = 0;
00164         int nextUnitOffset = 0;
00165         
00166         while(i<payloadUnitCount) {           
00167             unit[i].setLenPtr((uint8_t *)tokenString+nextUnitOffset);
00168             unit[i].setAdTypePtr((uint8_t *)tokenString+nextUnitOffset+1);
00169             unit[i].setDataPtr((uint8_t *)tokenString+nextUnitOffset+2);
00170             
00171             nextUnitOffset += *unit[i].getLenPtr()+1;
00172             i++;
00173 
00174         }
00175     }
00176     
00177     PayloadUnit getUnitAtIndex(int index) {
00178         return unit[index];
00179     }
00180     
00181     int getPayloadUnitCount() { return payloadUnitCount; }
00182     
00183     
00184 };    
00185 
00186 #endif // __PAYLOAD_H__