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     ~Payload();
00071     uint8_t getPayloadUnitCount();
00072     
00073     uint8_t getIDAtIndex(int index);  
00074     uint8_t getLengthAtIndex(int index);   
00075     uint8_t* getDataAtIndex(int index);    
00076     int8_t getInt8AtIndex(int index);  
00077     uint16_t getUint16AtIndex(int index); 
00078     uint8_t* getSerializedAdDataAtIndex(int index);         
00079 };
00080 
00081 
00082 class PayloadUnit {
00083 private:        
00084     uint8_t* lenPtr;
00085     uint8_t* adTypePtr;
00086     uint8_t* dataPtr;
00087     
00088 public:
00089     PayloadUnit() {
00090         lenPtr = NULL;
00091         adTypePtr = NULL;
00092         dataPtr = NULL;
00093     }
00094     
00095     PayloadUnit(uint8_t *len, uint8_t *adType, uint8_t* data) {
00096         lenPtr = len;
00097         adTypePtr = adType;
00098         dataPtr = data;
00099     }    
00100     
00101     void setLenPtr(uint8_t *len)   {
00102         lenPtr = len;
00103     } 
00104     
00105     void setAdTypePtr(uint8_t *adType)   {
00106         adTypePtr = adType;
00107     }  
00108     
00109     void setDataPtr(uint8_t *data)   {
00110         dataPtr = data;
00111     }      
00112     
00113     uint8_t* getLenPtr()   {
00114         return lenPtr;
00115     } 
00116     
00117     uint8_t* getAdTypePtr()   {
00118         return adTypePtr;
00119     }  
00120     
00121     uint8_t* getDataPtr()   {
00122         return dataPtr;
00123     }   
00124     
00125     void printDataAsHex()   {
00126         int i = 0;
00127         PRINTF("AdData=");
00128         for(i=0; i<*lenPtr-1; i++) {
00129             PRINTF("0x%x ", dataPtr[i]);
00130         }
00131         PRINTF("\n");
00132     }     
00133     
00134     void printDataAsString()   {
00135         int i = 0;
00136         PRINTF("AdData=");
00137         for(i=0; i<*lenPtr; i++) {
00138             PRINTF("%c", dataPtr[i]);
00139         }
00140         PRINTF("\n");
00141     }                                                   
00142     
00143 };
00144 
00145 class PayloadPtr {
00146 private:
00147     PayloadUnit *unit;
00148     int payloadUnitCount;
00149 public:    
00150     PayloadPtr(const uint8_t *tokenString, uint8_t string_ength) {
00151         // initialize private data members
00152         int stringLength = string_ength;
00153         payloadUnitCount = 0;
00154         
00155         int index = 0;
00156         while(index!=stringLength) {
00157             int len=tokenString[index];
00158             index=index+1+len;
00159             payloadUnitCount++;               
00160         }
00161         
00162         // allocate memory to unit
00163         unit = new PayloadUnit[payloadUnitCount];
00164         int i = 0;
00165         int nextUnitOffset = 0;
00166         
00167         while(i<payloadUnitCount) {           
00168             unit[i].setLenPtr((uint8_t *)tokenString+nextUnitOffset);
00169             unit[i].setAdTypePtr((uint8_t *)tokenString+nextUnitOffset+1);
00170             unit[i].setDataPtr((uint8_t *)tokenString+nextUnitOffset+2);
00171             
00172             nextUnitOffset += *unit[i].getLenPtr()+1;
00173             i++;
00174 
00175         }
00176     }
00177     
00178     PayloadUnit getUnitAtIndex(int index) {
00179         return unit[index];
00180     }
00181     
00182     int getPayloadUnitCount() { return payloadUnitCount; }
00183     
00184     ~PayloadPtr() {
00185         if(unit) delete[] unit;
00186 
00187         unit = NULL;
00188     }
00189 };    
00190 
00191 #endif // __PAYLOAD_H__