sandbox / mbed-client

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-client by Christopher Haster

source/m2mstring.cpp@4:ae5178938864, 2016-04-02 (annotated)

Committer:
Yogesh Pande
Date:
Sat Apr 02 00:31:13 2016 +0300
Revision:
4:ae5178938864
Parent:
1:79b6cc67d8b4 
Latest updated sources from Github and some trace group refactor.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Christopher Haster 1:79b6cc67d8b4 1 /*
Christopher Haster 1:79b6cc67d8b4 2 * Copyright (c) 2015 ARM Limited. All rights reserved.
Christopher Haster 1:79b6cc67d8b4 3 * SPDX-License-Identifier: Apache-2.0
Christopher Haster 1:79b6cc67d8b4 4 * Licensed under the Apache License, Version 2.0 (the License); you may
Christopher Haster 1:79b6cc67d8b4 5 * not use this file except in compliance with the License.
Christopher Haster 1:79b6cc67d8b4 6 * You may obtain a copy of the License at
Christopher Haster 1:79b6cc67d8b4 7 *
Christopher Haster 1:79b6cc67d8b4 8 * http://www.apache.org/licenses/LICENSE-2.0
Christopher Haster 1:79b6cc67d8b4 9 *
Christopher Haster 1:79b6cc67d8b4 10 * Unless required by applicable law or agreed to in writing, software
Christopher Haster 1:79b6cc67d8b4 11 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
Christopher Haster 1:79b6cc67d8b4 12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Christopher Haster 1:79b6cc67d8b4 13 * See the License for the specific language governing permissions and
Christopher Haster 1:79b6cc67d8b4 14 * limitations under the License.
Christopher Haster 1:79b6cc67d8b4 15 */
Christopher Haster 1:79b6cc67d8b4 16 #include "mbed-client/m2mstring.h"
Christopher Haster 1:79b6cc67d8b4 17 #include <string.h> // strlen
Christopher Haster 1:79b6cc67d8b4 18 #include <stdlib.h> // malloc, realloc
Christopher Haster 1:79b6cc67d8b4 19 #include <assert.h>
Christopher Haster 1:79b6cc67d8b4 20 #include <algorithm> // min
Christopher Haster 1:79b6cc67d8b4 21
Christopher Haster 1:79b6cc67d8b4 22 namespace m2m {
Christopher Haster 1:79b6cc67d8b4 23
Yogesh Pande 4:ae5178938864 24 const String::size_type String::npos = static_cast<size_t>(-1);
Christopher Haster 1:79b6cc67d8b4 25
Yogesh Pande 4:ae5178938864 26 char* String::strdup(const char* s)
Yogesh Pande 4:ae5178938864 27 {
Yogesh Pande 4:ae5178938864 28 const size_t len = strlen(s)+1;
Yogesh Pande 4:ae5178938864 29 char *p2 = static_cast<char*>(malloc(len));
Yogesh Pande 4:ae5178938864 30 memcpy(p2, s, len);
Yogesh Pande 4:ae5178938864 31 allocated_ = len;
Yogesh Pande 4:ae5178938864 32 size_ = len-1;
Yogesh Pande 4:ae5178938864 33 return p2;
Yogesh Pande 4:ae5178938864 34 }
Christopher Haster 1:79b6cc67d8b4 35
Yogesh Pande 4:ae5178938864 36 String::String()
Yogesh Pande 4:ae5178938864 37 : p( strdup("") )
Yogesh Pande 4:ae5178938864 38 {
Yogesh Pande 4:ae5178938864 39 _return_value = '\0';
Yogesh Pande 4:ae5178938864 40 }
Christopher Haster 1:79b6cc67d8b4 41
Yogesh Pande 4:ae5178938864 42 String::~String()
Yogesh Pande 4:ae5178938864 43 {
Yogesh Pande 4:ae5178938864 44 free(p);
Yogesh Pande 4:ae5178938864 45 p = 0;
Yogesh Pande 4:ae5178938864 46 }
Christopher Haster 1:79b6cc67d8b4 47
Yogesh Pande 4:ae5178938864 48 String::String(const String& s)
Yogesh Pande 4:ae5178938864 49 : p(0)
Yogesh Pande 4:ae5178938864 50 {
Yogesh Pande 4:ae5178938864 51 if( &s != NULL ) {
Yogesh Pande 4:ae5178938864 52 p = static_cast<char*>(malloc(s.size_ + 1));
Christopher Haster 1:79b6cc67d8b4 53
Christopher Haster 1:79b6cc67d8b4 54 allocated_ = s.size_ + 1;
Christopher Haster 1:79b6cc67d8b4 55 size_ = s.size_;
Christopher Haster 1:79b6cc67d8b4 56 memcpy(p, s.p, size_ + 1);
Christopher Haster 1:79b6cc67d8b4 57 }
Christopher Haster 1:79b6cc67d8b4 58 _return_value = '\0';
Yogesh Pande 4:ae5178938864 59 }
Christopher Haster 1:79b6cc67d8b4 60
Yogesh Pande 4:ae5178938864 61 String::String(const char* s)
Yogesh Pande 4:ae5178938864 62 : p(strdup(s))
Yogesh Pande 4:ae5178938864 63 {
Yogesh Pande 4:ae5178938864 64 _return_value = '\0';
Yogesh Pande 4:ae5178938864 65 }
Christopher Haster 1:79b6cc67d8b4 66
Yogesh Pande 4:ae5178938864 67 String& String::operator=(const char* s)
Yogesh Pande 4:ae5178938864 68 {
Yogesh Pande 4:ae5178938864 69 if ( p != s ) {
Yogesh Pande 4:ae5178938864 70 // s could point into our own string, so we have to allocate a new string
Yogesh Pande 4:ae5178938864 71 const size_t len = strlen(s);
Yogesh Pande 4:ae5178938864 72 char* copy = (char*) malloc( len + 1);
Yogesh Pande 4:ae5178938864 73 memmove(copy, s, len+1); // trailing 0
Yogesh Pande 4:ae5178938864 74 free( p );
Yogesh Pande 4:ae5178938864 75 p = copy;
Yogesh Pande 4:ae5178938864 76 size_ = len;
Yogesh Pande 4:ae5178938864 77 allocated_ = len+1;
Christopher Haster 1:79b6cc67d8b4 78 }
Christopher Haster 1:79b6cc67d8b4 79 return *this;
Yogesh Pande 4:ae5178938864 80 }
Yogesh Pande 4:ae5178938864 81
Yogesh Pande 4:ae5178938864 82 String& String::operator=(const String& s)
Yogesh Pande 4:ae5178938864 83 {
Yogesh Pande 4:ae5178938864 84 return operator=(s.p);
Yogesh Pande 4:ae5178938864 85 }
Christopher Haster 1:79b6cc67d8b4 86
Yogesh Pande 4:ae5178938864 87 String& String::operator+=(const String& s)
Yogesh Pande 4:ae5178938864 88 {
Yogesh Pande 4:ae5178938864 89 if (s.size_ > 0) {
Yogesh Pande 4:ae5178938864 90 this->reserve(size_ + s.size_);
Yogesh Pande 4:ae5178938864 91 memmove(p+size_, s.p, s.size_+1); // trailing 0
Yogesh Pande 4:ae5178938864 92 size_ += s.size_;
Yogesh Pande 4:ae5178938864 93 }
Yogesh Pande 4:ae5178938864 94 return *this;
Yogesh Pande 4:ae5178938864 95 }
Yogesh Pande 4:ae5178938864 96
Yogesh Pande 4:ae5178938864 97 // since p and s may overlap, we have to copy our own string first
Yogesh Pande 4:ae5178938864 98 String& String::operator+=(const char* s)
Yogesh Pande 4:ae5178938864 99 {
Yogesh Pande 4:ae5178938864 100 const size_type lens = strlen(s);
Yogesh Pande 4:ae5178938864 101 if (lens > 0) {
Christopher Haster 1:79b6cc67d8b4 102 if (size_ + lens + 1 <= allocated_) {
Yogesh Pande 4:ae5178938864 103 memmove(p+size_, s, lens+1); // trailing 0
Yogesh Pande 4:ae5178938864 104 size_ += lens;
Christopher Haster 1:79b6cc67d8b4 105 } else {
Yogesh Pande 4:ae5178938864 106 String s2( *this ); // copy own data
Yogesh Pande 4:ae5178938864 107 s2.reserve(size_ + lens);
Yogesh Pande 4:ae5178938864 108 memmove(s2.p+size_, s, lens+1); // trailing 0
Yogesh Pande 4:ae5178938864 109 s2.size_ = size_ + lens;
Yogesh Pande 4:ae5178938864 110 this->swap( s2 );
Christopher Haster 1:79b6cc67d8b4 111 }
Yogesh Pande 4:ae5178938864 112 }
Yogesh Pande 4:ae5178938864 113 return *this;
Yogesh Pande 4:ae5178938864 114 }
Christopher Haster 1:79b6cc67d8b4 115
Yogesh Pande 4:ae5178938864 116 String& String::operator+=(const char c)
Yogesh Pande 4:ae5178938864 117 {
Yogesh Pande 4:ae5178938864 118 push_back(c);
Yogesh Pande 4:ae5178938864 119 return *this;
Yogesh Pande 4:ae5178938864 120 }
Christopher Haster 1:79b6cc67d8b4 121
Yogesh Pande 4:ae5178938864 122 void String::push_back(const char c) {
Christopher Haster 1:79b6cc67d8b4 123
Christopher Haster 1:79b6cc67d8b4 124 if (size_ == allocated_ - 1) {
Yogesh Pande 4:ae5178938864 125 size_t more = (allocated_* 3) / 2; // factor 1.5
Yogesh Pande 4:ae5178938864 126 if ( more < 4 ) more = 4;
Yogesh Pande 4:ae5178938864 127 reserve( size_ + more );
Christopher Haster 1:79b6cc67d8b4 128 }
Christopher Haster 1:79b6cc67d8b4 129
Christopher Haster 1:79b6cc67d8b4 130 p[size_] = c;
Christopher Haster 1:79b6cc67d8b4 131 size_++;
Christopher Haster 1:79b6cc67d8b4 132 p[size_] = 0;
Yogesh Pande 4:ae5178938864 133 }
Christopher Haster 1:79b6cc67d8b4 134
Yogesh Pande 4:ae5178938864 135 bool String::operator==(const char* s) const
Yogesh Pande 4:ae5178938864 136 {
Yogesh Pande 4:ae5178938864 137 if( s == NULL ) {
Yogesh Pande 4:ae5178938864 138 if( p == NULL ) {
Yogesh Pande 4:ae5178938864 139 return true;
Yogesh Pande 4:ae5178938864 140 }
Yogesh Pande 4:ae5178938864 141 return false;
Yogesh Pande 4:ae5178938864 142 }
Yogesh Pande 4:ae5178938864 143 bool ret = strcmp(p, s);
Yogesh Pande 4:ae5178938864 144 return !ret;
Yogesh Pande 4:ae5178938864 145 }
Christopher Haster 1:79b6cc67d8b4 146
Yogesh Pande 4:ae5178938864 147 bool String::operator==(const String& s) const
Yogesh Pande 4:ae5178938864 148 {
Yogesh Pande 4:ae5178938864 149 bool ret = strcmp(p, s.p);
Yogesh Pande 4:ae5178938864 150 return !ret;
Yogesh Pande 4:ae5178938864 151 }
Christopher Haster 1:79b6cc67d8b4 152
Yogesh Pande 4:ae5178938864 153 void String::clear()
Yogesh Pande 4:ae5178938864 154 {
Yogesh Pande 4:ae5178938864 155 size_ = 0;
Yogesh Pande 4:ae5178938864 156 p[0] = 0;
Yogesh Pande 4:ae5178938864 157 }
Christopher Haster 1:79b6cc67d8b4 158
Yogesh Pande 4:ae5178938864 159 String String::substr(const size_type pos, size_type length) const
Yogesh Pande 4:ae5178938864 160 {
Yogesh Pande 4:ae5178938864 161 String s;
Yogesh Pande 4:ae5178938864 162 const size_type len = size_;
Christopher Haster 1:79b6cc67d8b4 163
Yogesh Pande 4:ae5178938864 164 if ( pos <= len ) {
Christopher Haster 1:79b6cc67d8b4 165
Yogesh Pande 4:ae5178938864 166 size_type remain = len - pos;
Christopher Haster 1:79b6cc67d8b4 167
Yogesh Pande 4:ae5178938864 168 if ( length > remain )
Yogesh Pande 4:ae5178938864 169 length = remain;
Christopher Haster 1:79b6cc67d8b4 170
Yogesh Pande 4:ae5178938864 171 s.reserve( length );
Christopher Haster 1:79b6cc67d8b4 172
Yogesh Pande 4:ae5178938864 173 memcpy(s.p, p + pos, length);
Yogesh Pande 4:ae5178938864 174 s.p[length] = '\0';
Yogesh Pande 4:ae5178938864 175 s.size_ = length;
Yogesh Pande 4:ae5178938864 176 }
Yogesh Pande 4:ae5178938864 177 return s;
Yogesh Pande 4:ae5178938864 178 }
Christopher Haster 1:79b6cc67d8b4 179
Christopher Haster 1:79b6cc67d8b4 180
Yogesh Pande 4:ae5178938864 181 // checked access, accessing the NUL at end is allowed
Yogesh Pande 4:ae5178938864 182 char& String::at(const size_type i)
Yogesh Pande 4:ae5178938864 183 {
Yogesh Pande 4:ae5178938864 184 if ( i <= strlen(p) ) {
Christopher Haster 1:79b6cc67d8b4 185 _return_value = p[i];
Yogesh Pande 4:ae5178938864 186 } else {
Yogesh Pande 4:ae5178938864 187 _return_value = '\0';
Yogesh Pande 4:ae5178938864 188 }
Yogesh Pande 4:ae5178938864 189 return _return_value;
Yogesh Pande 4:ae5178938864 190 }
Christopher Haster 1:79b6cc67d8b4 191
Yogesh Pande 4:ae5178938864 192 char String::at(const size_type i) const
Yogesh Pande 4:ae5178938864 193 {
Yogesh Pande 4:ae5178938864 194 if ( i <= strlen(p) ) {
Christopher Haster 1:79b6cc67d8b4 195 return p[i];
Yogesh Pande 4:ae5178938864 196 } else {
Yogesh Pande 4:ae5178938864 197 return '\0';
Yogesh Pande 4:ae5178938864 198 }
Yogesh Pande 4:ae5178938864 199 }
Christopher Haster 1:79b6cc67d8b4 200
Yogesh Pande 4:ae5178938864 201 String& String::erase(size_type pos, size_type len)
Yogesh Pande 4:ae5178938864 202 {
Christopher Haster 1:79b6cc67d8b4 203 if (len > 0) {
Christopher Haster 1:79b6cc67d8b4 204
Yogesh Pande 4:ae5178938864 205 if ( pos < size_ ) { // user must not remove trailing 0
Christopher Haster 1:79b6cc67d8b4 206
Yogesh Pande 4:ae5178938864 207 size_type s2 = size_;
Yogesh Pande 4:ae5178938864 208 size_type remain = s2 - pos - len;
Christopher Haster 1:79b6cc67d8b4 209
Yogesh Pande 4:ae5178938864 210 if (remain > 0) {
Yogesh Pande 4:ae5178938864 211 // erase by overwriting
Yogesh Pande 4:ae5178938864 212 memmove(p + pos, p + pos + len, remain);
Yogesh Pande 4:ae5178938864 213 }
Christopher Haster 1:79b6cc67d8b4 214
Yogesh Pande 4:ae5178938864 215 //if ( remain < 0 ) remain = 0;
Christopher Haster 1:79b6cc67d8b4 216
Yogesh Pande 4:ae5178938864 217 // remove unused space
Yogesh Pande 4:ae5178938864 218 this->resize( pos+remain );
Christopher Haster 1:79b6cc67d8b4 219
Christopher Haster 1:79b6cc67d8b4 220 }
Christopher Haster 1:79b6cc67d8b4 221 }
Christopher Haster 1:79b6cc67d8b4 222 return *this;
Yogesh Pande 4:ae5178938864 223 }
Christopher Haster 1:79b6cc67d8b4 224
Yogesh Pande 4:ae5178938864 225 String& String::append( const char* str, size_type n) {
Christopher Haster 1:79b6cc67d8b4 226 if (str && n > 0) {
Yogesh Pande 4:ae5178938864 227 size_t lens = strlen(str);
Yogesh Pande 4:ae5178938864 228 if (n > lens)
Yogesh Pande 4:ae5178938864 229 n = lens;
Yogesh Pande 4:ae5178938864 230 size_t newlen = size_ + n;
Yogesh Pande 4:ae5178938864 231 this->reserve( newlen );
Yogesh Pande 4:ae5178938864 232 memmove(p+size_, str, n); // p and s.p MAY overlap
Yogesh Pande 4:ae5178938864 233 p[newlen] = 0; // add NUL termination
Yogesh Pande 4:ae5178938864 234 size_ = newlen;
Christopher Haster 1:79b6cc67d8b4 235 }
Christopher Haster 1:79b6cc67d8b4 236 return *this;
Yogesh Pande 4:ae5178938864 237 }
Christopher Haster 1:79b6cc67d8b4 238
Yogesh Pande 4:ae5178938864 239 int String::compare( size_type pos, size_type len, const String& str ) const {
Christopher Haster 1:79b6cc67d8b4 240 int r = -1;
Christopher Haster 1:79b6cc67d8b4 241 if (pos <= size_) {
Christopher Haster 1:79b6cc67d8b4 242 if ( len > size_ - pos)
Yogesh Pande 4:ae5178938864 243 len = size_ - pos; // limit len to available length
Christopher Haster 1:79b6cc67d8b4 244
Christopher Haster 1:79b6cc67d8b4 245 const size_type osize = str.size();
Christopher Haster 1:79b6cc67d8b4 246 const size_type len2 = std::min(len, osize);
Christopher Haster 1:79b6cc67d8b4 247 r = strncmp( p + pos, str.p, len2);
Christopher Haster 1:79b6cc67d8b4 248 if (r==0) // equal so far, now compare sizes
Christopher Haster 1:79b6cc67d8b4 249 r = len < osize ? -1 : ( len == osize ? 0 : +1 );
Christopher Haster 1:79b6cc67d8b4 250 }
Christopher Haster 1:79b6cc67d8b4 251 return r;
Yogesh Pande 4:ae5178938864 252 }
Christopher Haster 1:79b6cc67d8b4 253
Yogesh Pande 4:ae5178938864 254 int String::compare( size_type pos, size_type len, const char* str ) const {
Yogesh Pande 4:ae5178938864 255 int r = -1;
Yogesh Pande 4:ae5178938864 256 if (pos <= size_) {
Christopher Haster 1:79b6cc67d8b4 257
Christopher Haster 1:79b6cc67d8b4 258 if ( len > size_ - pos)
Yogesh Pande 4:ae5178938864 259 len = size_ - pos; // limit len to available length
Christopher Haster 1:79b6cc67d8b4 260
Christopher Haster 1:79b6cc67d8b4 261 const size_type osize = strlen(str);
Christopher Haster 1:79b6cc67d8b4 262 const size_type len2 = std::min(len, osize);
Christopher Haster 1:79b6cc67d8b4 263 r = strncmp( p + pos, str, len2);
Christopher Haster 1:79b6cc67d8b4 264 if (r==0) // equal so far, now compare sizes
Christopher Haster 1:79b6cc67d8b4 265 r = len < osize ? -1 : ( len == osize ? 0 : +1 );
Christopher Haster 1:79b6cc67d8b4 266 }
Christopher Haster 1:79b6cc67d8b4 267 return r;
Yogesh Pande 4:ae5178938864 268 }
Christopher Haster 1:79b6cc67d8b4 269
Yogesh Pande 4:ae5178938864 270 int String::find_last_of(char c) const {
Christopher Haster 1:79b6cc67d8b4 271 int r = -1;
Christopher Haster 1:79b6cc67d8b4 272 char *v;
Christopher Haster 1:79b6cc67d8b4 273 v = strrchr(p,c);
Yogesh Pande 4:ae5178938864 274 if (v != NULL) {
Christopher Haster 1:79b6cc67d8b4 275 r = 0;
Christopher Haster 1:79b6cc67d8b4 276 char* i = p;
Yogesh Pande 4:ae5178938864 277 while (v != i) {
Christopher Haster 1:79b6cc67d8b4 278 i++;
Christopher Haster 1:79b6cc67d8b4 279 r++;
Christopher Haster 1:79b6cc67d8b4 280 }
Christopher Haster 1:79b6cc67d8b4 281 }
Christopher Haster 1:79b6cc67d8b4 282 return r;
Yogesh Pande 4:ae5178938864 283 }
Christopher Haster 1:79b6cc67d8b4 284
Yogesh Pande 4:ae5178938864 285 void String::new_realloc( size_type n) {
Christopher Haster 1:79b6cc67d8b4 286 if (n > 0 ) {
Yogesh Pande 4:ae5178938864 287 char* pnew = static_cast<char*>(realloc(p, n)); // could return NULL
Yogesh Pande 4:ae5178938864 288 if (pnew)
Yogesh Pande 4:ae5178938864 289 p = pnew;
Christopher Haster 1:79b6cc67d8b4 290 }
Yogesh Pande 4:ae5178938864 291 }
Christopher Haster 1:79b6cc67d8b4 292
Yogesh Pande 4:ae5178938864 293 void String::reserve( const size_type n) {
Christopher Haster 1:79b6cc67d8b4 294 if (n >= allocated_ ) {
Yogesh Pande 4:ae5178938864 295 this->new_realloc(n + 1);
Yogesh Pande 4:ae5178938864 296 allocated_ = n + 1;
Christopher Haster 1:79b6cc67d8b4 297 }
Yogesh Pande 4:ae5178938864 298 }
Christopher Haster 1:79b6cc67d8b4 299
Yogesh Pande 4:ae5178938864 300 void String::resize( const size_type n) {
Christopher Haster 1:79b6cc67d8b4 301 this->resize( n, 0 );
Yogesh Pande 4:ae5178938864 302 }
Christopher Haster 1:79b6cc67d8b4 303
Yogesh Pande 4:ae5178938864 304 void String::resize( const size_type n, const char c) {
Christopher Haster 1:79b6cc67d8b4 305 if (n < size_ ) {
Yogesh Pande 4:ae5178938864 306 p[n] = 0;
Yogesh Pande 4:ae5178938864 307 size_ = n;
Christopher Haster 1:79b6cc67d8b4 308 }
Christopher Haster 1:79b6cc67d8b4 309 else if (n > size_ ) {
Yogesh Pande 4:ae5178938864 310 this->reserve( n );
Yogesh Pande 4:ae5178938864 311 for (size_type i=size_; i < n; ++i )
Yogesh Pande 4:ae5178938864 312 p[i] = c;
Yogesh Pande 4:ae5178938864 313 p[n] = 0;
Yogesh Pande 4:ae5178938864 314 size_ = n;
Christopher Haster 1:79b6cc67d8b4 315 }
Yogesh Pande 4:ae5178938864 316 }
Christopher Haster 1:79b6cc67d8b4 317
Yogesh Pande 4:ae5178938864 318 void String::swap( String& s ) {
Christopher Haster 1:79b6cc67d8b4 319 std::swap( allocated_, s.allocated_ );
Christopher Haster 1:79b6cc67d8b4 320 std::swap( size_, s.size_ );
Christopher Haster 1:79b6cc67d8b4 321 std::swap( p, s.p );
Yogesh Pande 4:ae5178938864 322 }
Christopher Haster 1:79b6cc67d8b4 323
Christopher Haster 1:79b6cc67d8b4 324
Yogesh Pande 4:ae5178938864 325 // Comparison
Yogesh Pande 4:ae5178938864 326 bool operator<( const String& s1, const String& s2 ) {
Christopher Haster 1:79b6cc67d8b4 327 return strcmp( s1.c_str(), s2.c_str() ) < 0;
Yogesh Pande 4:ae5178938864 328 }
Yogesh Pande 4:ae5178938864 329
Yogesh Pande 4:ae5178938864 330 void reverse(char s[], uint32_t length)
Yogesh Pande 4:ae5178938864 331 {
Yogesh Pande 4:ae5178938864 332 uint32_t i, j;
Yogesh Pande 4:ae5178938864 333 char c;
Yogesh Pande 4:ae5178938864 334
Yogesh Pande 4:ae5178938864 335 for (i = 0, j = length-1; i<j; i++, j--) {
Yogesh Pande 4:ae5178938864 336 c = s[i];
Yogesh Pande 4:ae5178938864 337 s[i] = s[j];
Yogesh Pande 4:ae5178938864 338 s[j] = c;
Yogesh Pande 4:ae5178938864 339 }
Yogesh Pande 4:ae5178938864 340 }
Yogesh Pande 4:ae5178938864 341
Yogesh Pande 4:ae5178938864 342 uint32_t itoa_c (int64_t n, char s[])
Yogesh Pande 4:ae5178938864 343 {
Yogesh Pande 4:ae5178938864 344 int64_t sign;
Yogesh Pande 4:ae5178938864 345 uint32_t i;
Yogesh Pande 4:ae5178938864 346
Yogesh Pande 4:ae5178938864 347 if ((sign = n) < 0)
Yogesh Pande 4:ae5178938864 348 n = -n;
Yogesh Pande 4:ae5178938864 349
Yogesh Pande 4:ae5178938864 350 i = 0;
Yogesh Pande 4:ae5178938864 351
Yogesh Pande 4:ae5178938864 352 do {
Yogesh Pande 4:ae5178938864 353 s[i++] = n % 10 + '0';
Yogesh Pande 4:ae5178938864 354 }
Yogesh Pande 4:ae5178938864 355 while ((n /= 10) > 0);
Yogesh Pande 4:ae5178938864 356
Yogesh Pande 4:ae5178938864 357 if (sign < 0)
Yogesh Pande 4:ae5178938864 358 s[i++] = '-';
Yogesh Pande 4:ae5178938864 359
Yogesh Pande 4:ae5178938864 360 s[i] = '\0';
Yogesh Pande 4:ae5178938864 361
Yogesh Pande 4:ae5178938864 362 m2m::reverse(s, i);
Yogesh Pande 4:ae5178938864 363 return i;
Yogesh Pande 4:ae5178938864 364 }
Yogesh Pande 4:ae5178938864 365
Yogesh Pande 4:ae5178938864 366 uint8_t* String::convert_integer_to_array(int64_t value, uint8_t &size, uint8_t *array, uint32_t array_size)
Yogesh Pande 4:ae5178938864 367 {
Yogesh Pande 4:ae5178938864 368 uint8_t* buffer = NULL;
Yogesh Pande 4:ae5178938864 369 size = 0;
Yogesh Pande 4:ae5178938864 370 if (array) {
Yogesh Pande 4:ae5178938864 371 value = String::convert_array_to_integer(array, array_size);
Yogesh Pande 4:ae5178938864 372 }
Yogesh Pande 4:ae5178938864 373
Yogesh Pande 4:ae5178938864 374 if(value < 0xFF) {
Yogesh Pande 4:ae5178938864 375 size = 1;
Yogesh Pande 4:ae5178938864 376 } else if(value < 0xFFFF) {
Yogesh Pande 4:ae5178938864 377 size = 2;
Yogesh Pande 4:ae5178938864 378 } else if(value < 0xFFFFFF) {
Yogesh Pande 4:ae5178938864 379 size = 3;
Yogesh Pande 4:ae5178938864 380 } else if(value < 0xFFFFFFFF) {
Yogesh Pande 4:ae5178938864 381 size = 4;
Yogesh Pande 4:ae5178938864 382 } else if(value < 0xFFFFFFFFFF) {
Yogesh Pande 4:ae5178938864 383 size = 5;
Yogesh Pande 4:ae5178938864 384 } else if(value < 0xFFFFFFFFFFFF) {
Yogesh Pande 4:ae5178938864 385 size = 6;
Yogesh Pande 4:ae5178938864 386 } else if(value < 0xFFFFFFFFFFFFFF) {
Yogesh Pande 4:ae5178938864 387 size = 7;
Yogesh Pande 4:ae5178938864 388 } else {
Yogesh Pande 4:ae5178938864 389 size = 8;
Yogesh Pande 4:ae5178938864 390 }
Yogesh Pande 4:ae5178938864 391
Yogesh Pande 4:ae5178938864 392 buffer = (uint8_t*)malloc(size);
Yogesh Pande 4:ae5178938864 393 if (buffer) {
Yogesh Pande 4:ae5178938864 394 for (int i = 0; i < size; i++) {
Yogesh Pande 4:ae5178938864 395 buffer[i] = (value >> ((size - i - 1) * 8));
Yogesh Pande 4:ae5178938864 396 }
Yogesh Pande 4:ae5178938864 397 } else {
Yogesh Pande 4:ae5178938864 398 size = 0;
Yogesh Pande 4:ae5178938864 399 }
Yogesh Pande 4:ae5178938864 400 return buffer;
Yogesh Pande 4:ae5178938864 401 }
Yogesh Pande 4:ae5178938864 402
Yogesh Pande 4:ae5178938864 403 int64_t String::convert_array_to_integer(uint8_t *value, uint32_t size)
Yogesh Pande 4:ae5178938864 404 {
Yogesh Pande 4:ae5178938864 405 int64_t temp_64 = 0;
Yogesh Pande 4:ae5178938864 406 for (int i = size - 1; i >= 0; i--) {
Yogesh Pande 4:ae5178938864 407 temp_64 += (uint64_t)(*value++) << i * 8;
Yogesh Pande 4:ae5178938864 408 }
Yogesh Pande 4:ae5178938864 409 return temp_64;
Yogesh Pande 4:ae5178938864 410 }
Christopher Haster 1:79b6cc67d8b4 411
Christopher Haster 1:79b6cc67d8b4 412 } // namespace