ffead.server.doc
AMEFEncoder.h
1 /*
2  Copyright 2009-2012, Sumeet Chhetri
3 
4  Licensed under the Apache License, Version 2.0 (the "License");
5  you may not use this file except in compliance with the License.
6  You may obtain a copy of the License at
7 
8  http://www.apache.org/licenses/LICENSE-2.0
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 */
16 
17 #ifndef AMEFENCODER_H_
18 #define AMEFENCODER_H_
19 
20 #include "AMEFObject.h"
21 #include "iostream"
22 
24 {
25  /*The default delimiter for single object representation*/
26  //string delim = ",";
27 
34  /*char* encode(AMEFObject packet,boolean ignoreName) throws AMEFEncodeException
35  {
36  string dat = encodeSinglePacket(packet,ignoreName);
37  int l = dat.length();
38  return (intTocharArrayS(l, 4) + dat).getchars();
39  } */
40 public:
41  AMEFEncoder();
42  ~AMEFEncoder();
43  static char* longTocharArray(long l,int ind)
44  {
45  char* result = new char[ind];
46  for (int i = 0; i<ind; i++)
47  {
48  int offset = (ind - 1 - i) * 8;
49  result[i] = (char) ((l >> offset) & 0xFF);
50  }
51  return result;
52  }
53 
54  static string longTocharArrayS(long l,int ind)
55  {
56  char* result = new char[ind];
57  for (int i = 0; i<ind; i++)
58  {
59  int offset = (ind - 1 - i) * 8;
60  result[i] = (char) ((l >> offset) & 0xFF);
61  }
62  string tem(result);
63  return tem;
64  }
65 
66  static string intTocharArray(int l,int ind)
67  {
68  string result;
69  for (int i = 0; i<ind; i++)
70  {
71  int offset = (ind - 1 - i) * 8;
72  result.push_back((char) ((l >> offset) & 0xFF));
73  }
74  return result;
75  }
76 
77  static string intTocharArrayWI(int l)
78  {
79  int ind = 1;
80  if(l<256)
81  ind =1;
82  else if(l<65536)
83  ind = 2;
84  else if(l<16777216)
85  ind =3;
86  else
87  ind =4;
88  string result;
89  for (int i = 0; i<ind; i++)
90  {
91  int offset = (ind - 1 - i) * 8;
92  result.push_back((char) ((l >> offset) & 0xFF));
93  }
94  return result;
95  }
96 
97  static int charArrayToInt(char l[])
98  {
99  int t = 0;
100  int ind = sizeof l;
101  for (int i = 0; i < ind; i++)
102  {
103  int offset = (ind -1 - i) * 8;
104  t += (l[i] & 0x000000FF) << offset;
105  }
106  return t;
107  }
108 
109  static int charArrayToInt(char* l,int off,int ind)
110  {
111  int t = 0;
112  for (int i = 0; i < ind; i++)
113  {
114  int offset = (ind -1 - i) * 8;
115  t += (l[off+i] & 0x000000FF) << offset;
116  }
117  return t;
118  }
119 
120  static long charArrayToLong(char l[])
121  {
122  long t = 0;
123  int ind = sizeof l;
124  for (int i = 0; i < ind; i++)
125  {
126  int offset = (ind -1 - i) * 8;
127  t += (l[i] & 0x000000FF) << offset;
128  }
129  return t;
130  }
131  static long charArrayToLong(char* l,int off,int ind)
132  {
133  long t = 0;
134  for (int i = 0; i < ind; i++)
135  {
136  int offset = (ind -1 - i) * 8;
137  t += (l[off+i] & 0x000000FF) << offset;
138  }
139  return t;
140  }
141  static long charArrayToLong(char* l,int ind)
142  {
143  long t = 0;
144  for (int i = 0; i < ind; i++)
145  {
146  int offset = (ind -1 - i) * 8;
147  t += (l[i] & 0x000000FF) << offset;
148  }
149  return t;
150  }
151 
152  static string intTocharArrayS(int l, int ind)
153  {
154  char* result = new char[ind];
155  for (int i = 0; i<ind; i++)
156  {
157  int offset = (ind - 1 - i) * 8;
158  result[i] = (char) ((l >> offset) & 0xFF);
159  }
160  string tem;
161  for (int i = 0; i < ind; i++)
162  tem.push_back(result[ind]);
163  delete result;
164  return tem;
165  }
166 
167  string encodeB(AMEFObject* packet,bool ignoreName)
168  {
169  //char* dat = new char[packet->getNamedLength(ignoreName) + 4];
170  string enc = encodeSinglePacketB(packet, ignoreName);
171  string len = intTocharArray(enc.length(), 4);
172  string temp;
173  temp.append(len);
174  temp.append(enc);
175  return temp;
176  }
177 
178  string encodeWL(AMEFObject* packet,bool ignoreName)
179  {
180  //char* dat = new char[packet->getNamedLength(ignoreName)];
181  string enc = encodeSinglePacketB(packet, ignoreName);
182  return enc;
183  }
184 
185  /*char* encodeWL(AMEFObject packet,boolean ignoreName) throws AMEFEncodeException
186  {
187  string dat = encodeSinglePacket(packet,ignoreName);
188  int l = dat.length();
189  return dat.getchars();
190  }
191 
192  *//*
198  string encodeS(AMEFObject packet,boolean ignoreName) throws AMEFEncodeException
199  {
200  string dat = null;
201  if(ignoreName)
202  dat = encodeJDBObject(packet);
203  else
204  dat = encodeSinglePacket(packet,ignoreName);
205  int l = dat.length();
206  return (intTocharArrayS(l, 4) + dat);
207  }
208 
209  string encodeJDBObject(AMEFObject packet) throws AMEFEncodeException
210  {
211  string dat = encodeSingleJDBPacket(packet);
212  int l = dat.length();
213  return (dat);
214  //return dat;
215  }
216 
217  string getValue(int val,int ind)
218  {
219  char* buf = new char[ind];
220  for (int i = 0; i < buf.length; i++)
221  {
222 
223  }
224  }*/
225 
226 
227  void getValue(string value,char type,string buffer)
228  {
229  /*if(type==AMEFObject::DATE_TYPE || type==AMEFObject::STRING_65536_TYPE
230  || type==AMEFObject::STRING_256_TYPE || type==AMEFObject::DOUBLE_FLOAT_TYPE
231  || type==AMEFObject::STRING_16777216_TYPE || type==AMEFObject::STRING_TYPE
232  || type==AMEFObject::BOOLEAN_TYPE || type==AMEFObject::CHAR_TYPE)
233  {
234  buffer.append(value);
235  }
236  else if(type==AMEFObject::VERY_SMALL_INT_TYPE)
237  {
238  buffer.append(value);
239  }
240  else if(type==AMEFObject::SMALL_INT_TYPE)
241  {
242  int intvalue = Integer.parseInt(value);
243  buffer.append(intTocharArray(intvalue, 2));
244  }
245  else if(type==AMEFObject::BIG_INT_TYPE)
246  {
247  int intvalue = Integer.parseInt(value);
248  buffer.append(new string(intTocharArray(intvalue, 3)));
249  }
250  else if(type==AMEFObject::INT_TYPE)
251  {
252  int intvalue = Integer.parseInt(value);
253  buffer.append(new string(intTocharArray(intvalue, 4)));
254  }
255  else if(type==AMEFObject::VS_LONG_INT_TYPE)
256  {
257  long l = Long.parseLong(value);
258  buffer.append(new string(longTocharArray(l, 5)));
259  }
260  else if(type==AMEFObject::S_LONG_INT_TYPE)
261  {
262  long l = Long.parseLong(value);
263  buffer.append(new string(longTocharArray(l, 6)));
264  }
265  else if(type==AMEFObject::B_LONG_INT_TYPE)
266  {
267  long l = Long.parseLong(value);
268  buffer.append(new string(longTocharArray(l, 7)));
269  }
270  else if(type==AMEFObject::LONG_INT_TYPE)
271  {
272  long l = Long.parseLong(value);
273  buffer.append(new string(longTocharArray(l, 8)));
274  }*/
275  buffer.append(value);
276  }
277 
278  string getFinalVal(char type,string buffer,int length,string delim, string name)
279  {
280  string retval = type + delim + name + delim;
281  if(type==AMEFObject::DATE_TYPE || type==AMEFObject::STRING_256_TYPE
282  || type==AMEFObject::DOUBLE_FLOAT_TYPE)
283  {
284  retval += intTocharArrayS(length, 1) + buffer;
285  }
286  else if(type==AMEFObject::STRING_65536_TYPE)
287  {
288  retval += intTocharArrayS(length, 2) + buffer;
289  }
290  else if(type==AMEFObject::STRING_16777216_TYPE)
291  {
292  retval += intTocharArrayS(length, 3) + buffer;
293  }
294  else if(type==AMEFObject::STRING_TYPE)
295  {
296  retval += intTocharArrayS(length, 4) + buffer;
297  }
298  else if(type==AMEFObject::BOOLEAN_TYPE || type==AMEFObject::CHAR_TYPE
299  || type==AMEFObject::SMALL_INT_TYPE || type==AMEFObject::VERY_SMALL_INT_TYPE
300  || type==AMEFObject::BIG_INT_TYPE || type==AMEFObject::INT_TYPE
301  || type==AMEFObject::VS_LONG_INT_TYPE || type==AMEFObject::S_LONG_INT_TYPE
302  || type==AMEFObject::B_LONG_INT_TYPE || type==AMEFObject::LONG_INT_TYPE)
303  {
304  retval += buffer;
305  }
306  else if(type==AMEFObject::OBJECT_TYPE)
307  {
308  if(length<256)
309  {
310  retval = AMEFObject::VS_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 1) + buffer;
311  }
312  else if(length<65536)
313  {
314  retval = AMEFObject::S_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 2) + buffer;
315  }
316  else if(length<16777216)
317  {
318  retval = AMEFObject::B_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 3) + buffer;
319  }
320  else
321  {
322  retval = AMEFObject::OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 4) + buffer;
323  }
324  }
325  else if(type==AMEFObject::VS_OBJECT_TYPE)
326  {
327  retval = AMEFObject::VS_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 1) + buffer;
328  }
329  else if(type==AMEFObject::S_OBJECT_TYPE)
330  {
331  retval = AMEFObject::S_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 2) + buffer;
332  }
333  else if(type==AMEFObject::B_OBJECT_TYPE)
334  {
335  retval = AMEFObject::B_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 3) + buffer;
336  }
337  //else
338  //{
339  // throw new AMEFEncodeException("Not a valid AMEF Object type,only types string,number,boolean,character,date allowed");
340  //}
341  return retval;
342  }
343 
344  /*string encodeSingleJDBPacket(AMEFObject packet) throws AMEFEncodeException
345  {
346  stringBuilder buffer = new stringBuilder();
347  if(packet==null)
348  {
349  throw new AMEFEncodeException("Objcet to be encoded is null");
350  }
351  int length = packet->getLength();
352  for (AMEFObject pack : packet->getPackets())
353  {
354  buffer.append(encodeSingleJDBPacket(pack));
355  }
356  if(packet->getPackets().size()==0)
357  getValue(new string(packet->getValue()),packet->getType(), buffer);
358  if(bufferlength()>0)
359  {
360  length = bufferlength();
361  }
362  return getFinalVal(packet->getType(), buffer, length, "","");
363  }
364 
365  *//*
371  string encodeSinglePacket(AMEFObject packet,boolean ignoreName) throws AMEFEncodeException
372  {
373  stringBuilder buffer = new stringBuilder();
374  if(packet==null)
375  {
376  throw new AMEFEncodeException("Objcet to be encoded is null");
377  }
378  int length = packet->getLength();
379  for (AMEFObject pack : packet->getPackets())
380  {
381  buffer.append(encodeSinglePacket(pack,ignoreName));
382  }
383  if(packet->getPackets().size()==0)
384  getValue(new string(packet->getValue()),packet->getType(), buffer);
385  if(bufferlength()>0)
386  {
387  length = bufferlength();
388  }
389  string retval = "";
390  if(!ignoreName)
391  retval += packet->getName();
392  return getFinalVal(packet->getType(), buffer, length, delim, retval);
393  }
394 
395 
396  char* encodeSinglePacketB(AMEFObject packet,boolean ignoreName) throws AMEFEncodeException
397  {
398  charArrayOutputStream buffer = new charArrayOutputStream();
399  if(packet==null)
400  {
401  throw new AMEFEncodeException("Objcet to be encoded is null");
402  }
403  int length = packet->getLength();
404  for (AMEFObject pack : packet->getPackets())
405  {
406  buffer.write(encodeSinglePacketB(pack,ignoreName));
407  }
408  if(packet->getPackets().size()==0)
409  {
410  buffer.write(packet->getValue().getchars());
411  }
412  string retval = "";
413  if(!ignoreName)
414  retval += packet->getName();
415  char type = packet->getType();
416  if(type==AMEFObject::DATE_TYPE || type==AMEFObject::STRING_256_TYPE
417  || type==AMEFObject::DOUBLE_FLOAT_TYPE)
418  {
419  buffer.write(intTocharArray(length, 1));
420  }
421  else if(type==AMEFObject::STRING_65536_TYPE)
422  {
423  buffer.write(intTocharArray(length, 2));
424  }
425  else if(type==AMEFObject::STRING_16777216_TYPE)
426  {
427  buffer.write(intTocharArray(length, 3));
428  }
429  else if(type==AMEFObject::STRING_TYPE)
430  {
431  buffer.write(intTocharArray(length, 4));
432  }
433  else if(type==AMEFObject::BOOLEAN_TYPE || type==AMEFObject::CHAR_TYPE
434  || type==AMEFObject::SMALL_INT_TYPE || type==AMEFObject::VERY_SMALL_INT_TYPE
435  || type==AMEFObject::BIG_INT_TYPE || type==AMEFObject::INT_TYPE
436  || type==AMEFObject::VS_LONG_INT_TYPE || type==AMEFObject::S_LONG_INT_TYPE
437  || type==AMEFObject::B_LONG_INT_TYPE || type==AMEFObject::LONG_INT_TYPE)
438  {
439  retval += buffer;
440  }
441  else if(type==AMEFObject::OBJECT_TYPE)
442  {
443  if(length<256)
444  {
445  retval = AMEFObject::VS_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 1) + buffer;
446  }
447  else if(length<65536)
448  {
449  retval = AMEFObject::S_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 2) + buffer;
450  }
451  else if(length<16777216)
452  {
453  retval = AMEFObject::B_OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 3) + buffer;
454  }
455  else
456  {
457  retval = AMEFObject::OBJECT_TYPE + delim + name + delim + intTocharArrayS(length, 4) + buffer;
458  }
459  }
460  return getFinalVal(packet->getType(), buffer, length, delim, retval);
461  }*/
462 
463 
464  string getPacketValue(string value)
465  {
466  string arr;
467  char type;
468  if(value.length()<=256)
469  type = AMEFObject::STRING_256_TYPE;
470  else if(value.length()<=65536)
471  type = AMEFObject::STRING_65536_TYPE;
472  else if(value.length()<=16777216)
473  type = AMEFObject::STRING_16777216_TYPE;
474  else
475  type = AMEFObject::STRING_TYPE;
476 
477  if(type==AMEFObject::DATE_TYPE || type==AMEFObject::STRING_256_TYPE
478  || type==AMEFObject::DOUBLE_FLOAT_TYPE)
479  {
480  arr.push_back((char)type);
481  string len = intTocharArray(value.length(), 1);
482  arr.append(len);
483  arr.append(value);
484  }
485  else if(type==AMEFObject::STRING_65536_TYPE)
486  {
487  arr.push_back((char)type);
488  string len = intTocharArray(value.length(), 2);
489  arr.append(len);arr.append(value);
490  }
491  else if(type==AMEFObject::STRING_16777216_TYPE)
492  {
493  arr.push_back((char)type);
494  string len = intTocharArray(value.length(), 3);
495  arr.append(len);arr.append(value);
496  }
497  else if(type==AMEFObject::STRING_TYPE)
498  {
499  arr.push_back((char)type);
500  string len = intTocharArray(value.length(), 4);
501  arr.append(len);arr.append(value);
502  }
503  else if(type==AMEFObject::BOOLEAN_TYPE || type==AMEFObject::CHAR_TYPE
504  || type==AMEFObject::SMALL_INT_TYPE || type==AMEFObject::VERY_SMALL_INT_TYPE
505  || type==AMEFObject::BIG_INT_TYPE || type==AMEFObject::INT_TYPE
506  || type==AMEFObject::VS_LONG_INT_TYPE || type==AMEFObject::S_LONG_INT_TYPE
507  || type==AMEFObject::B_LONG_INT_TYPE || type==AMEFObject::LONG_INT_TYPE)
508  {
509 
510  }
511  else if(type==AMEFObject::OBJECT_TYPE)
512  {
513  int length = value.length();
514  if(length<256)
515  {
516  arr[0] = (char)AMEFObject::VS_OBJECT_TYPE;
517  string len = intTocharArray(value.length(), 1);
518  arr.append(len);arr.append(value);
519  }
520  else if(length<65536)
521  {
522  arr[0] = (char)AMEFObject::S_OBJECT_TYPE;
523  string len = intTocharArray(value.length(), 2);
524  arr.append(len);
525  }
526  else if(length<16777216)
527  {
528  arr[0] = (char)AMEFObject::B_OBJECT_TYPE;
529  string len = intTocharArray(value.length(),3);
530  arr.append(len);
531  }
532  else
533  {
534  arr[0] = (char)AMEFObject::OBJECT_TYPE;
535  string len = intTocharArray(value.length(),4);
536  arr.append(len);
537  }
538  }
539  return arr;
540  }
541 
542  string getPacketValue(int integer)
543  {
544  char type;
545  int ind = 1;
546  if(integer<256)
547  type = AMEFObject::VERY_SMALL_INT_TYPE;
548  else if(integer<65536)
549  {
550  type = AMEFObject::SMALL_INT_TYPE;
551  ind = 2;
552  }
553  else if(integer<16777216)
554  {
555  type = AMEFObject::BIG_INT_TYPE;
556  ind = 3;
557  }
558  else
559  {
560  type = AMEFObject::INT_TYPE;
561  ind = 4;
562  }
563  string arr;
564  arr.push_back((char)type);
565  string len = intTocharArray(integer, ind);
566  arr.append(len);
567  return arr;
568  }
569 
570  #ifdef IS_64_BIT
571  string getPacketValue(unsigned long long lon)
572  {
573  char type;
574  int ind = 1;
575  if(lon<256)
576  type = AMEFObject::VERY_SMALL_INT_TYPE;
577  else if(lon<65536)
578  {
579  type = AMEFObject::SMALL_INT_TYPE;
580  ind = 2;
581  }
582  else if(lon<16777216)
583  {
584  type = AMEFObject::BIG_INT_TYPE;
585  ind = 3;
586  }
587  else if(lon<4294967296ULL)
588  {
589  type = AMEFObject::INT_TYPE;
590  ind = 4;
591  }
592  else if(lon<1099511627776ULL)
593  {
594  type = AMEFObject::VS_LONG_INT_TYPE;
595  ind = 5;
596  }
597  else if(lon<281474976710656ULL)
598  {
599  type = AMEFObject::S_LONG_INT_TYPE;
600  ind = 6;
601  }
602  else if(lon<72057594037927936ULL)
603  {
604  type = AMEFObject::B_LONG_INT_TYPE;
605  ind = 7;
606  }
607  else
608  {
609  type = AMEFObject::LONG_INT_TYPE;
610  ind = 8;
611  }
612  string arr;
613  arr.push_back((char)type);
614  char* len = longTocharArray(lon, ind);
615  arr.append(len);
616  return arr;
617  }
618  string getPacketValue(long lon)
619  {
620  char type;
621  int ind = 1;
622  if(lon<256)
623  type = AMEFObject::VERY_SMALL_INT_TYPE;
624  else if(lon<65536)
625  {
626  type = AMEFObject::SMALL_INT_TYPE;
627  ind = 2;
628  }
629  else if(lon<16777216)
630  {
631  type = AMEFObject::BIG_INT_TYPE;
632  ind = 3;
633  }
634  else if(lon<(long)4294967296ULL)
635  {
636  type = AMEFObject::INT_TYPE;
637  ind = 4;
638  }
639  else if(lon<(long)1099511627776ULL)
640  {
641  type = AMEFObject::VS_LONG_INT_TYPE;
642  ind = 5;
643  }
644  else if(lon<(long)281474976710656ULL)
645  {
646  type = AMEFObject::S_LONG_INT_TYPE;
647  ind = 6;
648  }
649  else if(lon<(long)72057594037927936ULL)
650  {
651  type = AMEFObject::B_LONG_INT_TYPE;
652  ind = 7;
653  }
654  else
655  {
656  type = AMEFObject::LONG_INT_TYPE;
657  ind = 8;
658  }
659  string arr;
660  arr.push_back((char)type);
661  char* len = longTocharArray(lon, ind);
662  arr.append(len);
663  return arr;
664  }
665  #else
666  string getPacketValue(unsigned long long lon)
667  {
668  char type;
669  int ind = 1;
670  if(lon<256)
671  type = AMEFObject::VERY_SMALL_INT_TYPE;
672  else if(lon<65536)
673  {
674  type = AMEFObject::SMALL_INT_TYPE;
675  ind = 2;
676  }
677  else if(lon<16777216)
678  {
679  type = AMEFObject::BIG_INT_TYPE;
680  ind = 3;
681  }
682  else if(lon<4294967296ULL)
683  {
684  type = AMEFObject::INT_TYPE;
685  ind = 4;
686  }
687  else if(lon<1099511627776ULL)
688  {
689  type = AMEFObject::VS_LONG_INT_TYPE;
690  ind = 5;
691  }
692  else if(lon<281474976710656ULL)
693  {
694  type = AMEFObject::S_LONG_INT_TYPE;
695  ind = 6;
696  }
697  else if(lon<72057594037927936ULL)
698  {
699  type = AMEFObject::B_LONG_INT_TYPE;
700  ind = 7;
701  }
702  else
703  {
704  type = AMEFObject::LONG_INT_TYPE;
705  ind = 8;
706  }
707  string arr;
708  arr.push_back((char)type);
709  char* len = longTocharArray(lon, ind);
710  arr.append(len);
711  return arr;
712  }
713  string getPacketValue(long lon)
714  {
715  char type;
716  int ind = 1;
717  if(lon<256)
718  type = AMEFObject::VERY_SMALL_INT_TYPE;
719  else if(lon<65536)
720  {
721  type = AMEFObject::SMALL_INT_TYPE;
722  ind = 2;
723  }
724  else if(lon<16777216)
725  {
726  type = AMEFObject::BIG_INT_TYPE;
727  ind = 3;
728  }
729  else
730  {
731  type = AMEFObject::INT_TYPE;
732  ind = 4;
733  }
734  string arr;
735  arr.push_back((char)type);
736  char* len = longTocharArray(lon, ind);
737  arr.append(len);
738  return arr;
739  }
740  #endif
741 
742  string getPacketValue(double lon)
743  {
744  string buffer;
745  char type = AMEFObject::DOUBLE_FLOAT_TYPE;
746  //getValue(string.valueOf(lon),type, buffer);
747  string retVal = getFinalVal(type, buffer, 1, "", "");
748  return retVal;
749  }
750 
751  string getPacketValue(float lon)
752  {
753  string buffer;
754  char type = AMEFObject::DOUBLE_FLOAT_TYPE;
755  //getValue(string.valueOf(lon),type, buffer);
756  string retVal = getFinalVal(type, buffer, 1, "", "");
757  return retVal;
758  }
759 
760  string getPacketValue(bool lon)
761  {
762  return (AMEFObject::BOOLEAN_TYPE+(lon?"1":"0"));
763  }
764 
765  string getPacketValue(char lon)
766  {
767  return (AMEFObject::CHAR_TYPE+""+lon);
768  }
769 
770 
771 
772 
773 
774 
775 
776 
777 
778  //---------------------------------------------------------------------------------------//
779  string encodeSinglePacketB(AMEFObject *packet,bool ignoreName)
780  {
781  int bufferlength = packet->getNamedLength(ignoreName);
782  string buffer;
783  int pos = 0;
784  if(!ignoreName)
785  {
786  if(packet->getType()=='o')
787  {
788  if(bufferlength+4<256)
789  {
790  buffer.push_back(AMEFObject::VS_OBJECT_TYPE);
791  }
792  else if(bufferlength+4<65536)
793  {
794  buffer.push_back(AMEFObject::S_OBJECT_TYPE);
795  }
796  else if(bufferlength+4<16777216)
797  {
798  buffer.push_back(AMEFObject::B_OBJECT_TYPE);
799  }
800  }
801  else
802  buffer.push_back((char)packet->getType());
803  buffer.push_back((char)',');
804  buffer.append(packet->getName());
805  //System.arraycopy(packet->getName(), 0, buffer, 2, packet->getName().length);
806  //pos = packet->getName().length() + 2;
807  buffer.push_back((char)',');
808  pos ++;
809  if(packet->getType()!='n' && packet->getType()!='w' && packet->getType()!='r'
810  && packet->getType()!='i' && packet->getType()!='f' && packet->getType()!='x'
811  && packet->getType()!='e' && packet->getType()!='l' && packet->getType()!='b'
812  && packet->getType()!='c' && packet->getType()!='a' && packet->getType()!='g'
813  && packet->getType()!='j' && packet->getType()!='v' && packet->getType()!='z')
814  {
815  string lengthb = intTocharArrayWI(packet->getlength());
816  buffer.append(lengthb);
817  //System.arraycopy(lengthb, 0, buffer, pos, lengthb.length);
818  //pos += lengthb.length;
819  }
820  }
821  else
822  {
823  buffer.push_back((char)packet->getType());
824  pos++;
825  if(packet->getType()!='n' && packet->getType()!='w' && packet->getType()!='r'
826  && packet->getType()!='i' && packet->getType()!='f' && packet->getType()!='x'
827  && packet->getType()!='e' && packet->getType()!='l' && packet->getType()!='b'
828  && packet->getType()!='c' && packet->getType()!='a' && packet->getType()!='g'
829  && packet->getType()!='j' && packet->getType()!='v' && packet->getType()!='z')
830  {
831  string lengthb = intTocharArrayWI(packet->getlength());
832  buffer.append(lengthb);
833  //System.arraycopy(lengthb, 0, buffer, pos, lengthb.length);
834  //pos += lengthb.length;
835  }
836  }
837 
838  for (int i=0;i<(int)packet->getPackets().size();i++)
839  {
840  AMEFObject *pack = packet->getPackets().at(i);
841  string val = encodeSinglePacketB(pack,ignoreName);
842  buffer.append(val);
843  //System.arraycopy(val, 0, buffer, pos, val.length);
844  //pos += val.length;
845  }
846  if(packet->getPackets().size()==0 && packet->getType()!='a' && packet->getType()!='g'
847  && packet->getType()!='j' && packet->getType()!='v' && packet->getType()!='z')
848  {
849  buffer.append(packet->getValue());
850  //System.arraycopy(packet->getValue(), 0, buffer, pos, packet->getValue().length);
851  }
852  return buffer;
853  }
854 }
855 ;
856 
857 #endif /* AMEFENCODER_H_ */