Develop and Download Open Source Software

JYUGEM

Browse CVS Repository

/[OSDN]/jyugem/jyusecs/bee/b_value.h

Contents of /jyugem/jyusecs/bee/b_value.h

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph

Revision 1.9 - (show annotations) (download) (as text)
Sat Aug 14 14:48:42 2004 UTC (19 years, 7 months ago) by fukasawa
Branch: MAIN
CVS Tags: HEAD
Changes since 1.8: +4 -4 lines
File MIME type: text/x-chdr 
メモリリークの解消。
接続モード（ACTIVE/PASSIVE）をパラメータで指定可能とした。
ダンプメッセージをVERBOSE_LITEモードで出力。
1 // $Id: b_value.h,v 1.8 2004/06/27 08:07:24 fukasawa Exp $
2
3 //=============================================================================
4 /**
5 * @file b_value.h
6 *
7 * @author Fukasawa Mitsuo
8 *
9 *
10 * Copyright (C) 1998-2004 BEE Co.,Ltd. All rights reserved.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 */
26 //=============================================================================
27
28 #ifndef B_VALUE_H
29 #define B_VALUE_H
30
31 #include "b_ace.h"
32
33 #ifndef FORMAT_CODE_DEFINED
34 #define FORMAT_CODE_DEFINED
35 enum
36 {
37 ATOM_LIST = 000,
38 ATOM_BINARY = 010,
39 ATOM_BOOLEAN = 011,
40 ATOM_ASCII = 020,
41 ATOM_JIS = 021,
42 ATOM_UNICODE = 022,
43 ATOM_INT8 = 030,
44 ATOM_INT1 = 031,
45 ATOM_INT2 = 032,
46 ATOM_INT4 = 034,
47 ATOM_FLOAT8 = 040,
48 ATOM_FLOAT4 = 044,
49 ATOM_UINT8 = 050,
50 ATOM_UINT1 = 051,
51 ATOM_UINT2 = 052,
52 ATOM_UINT4 = 054,
53 ATOM_STRUCT = 070,
54 ATOM_ARRAY = 0100,
55 ATOM_VECTOR = 0170,
56 };
57 #endif
58
59 class b_id;
60 class b_value;
61 typedef vector<b_value *> b_valvect;
62
63 //
64 // Value class
65 //
66 class BEE_Export b_value
67 {
68 public:
69 short m_t; // type
70 short m_sz; // byte size
71 size_t m_q; // quantity
72 union { // value
73 bool _bo;
74 char _ch;
75 BYTE _uc;
76 int _in;
77 UINT _ui;
78 short _sh;
79 USHORT _us;
80 float _fl;
81 double _do;
82 LONGLONG _llo;
83 ULONGLONG _ull;
84 string * _str;
85 BYTE * _bin;
86 b_valvect * _vec;
87 void * _ptr;
88 } m;
89
90 // Constructor
91 b_value(): m_t(ATOM_INT4), m_sz(0), m_q(0) { m._in = 0; }
92 b_value(bool val): m_t(ATOM_BOOLEAN), m_sz(sizeof(bool)), m_q(1) {
93 m._bo = val;
94 }
95 b_value(char val): m_t(ATOM_INT1), m_sz(sizeof(char)), m_q(1) {
96 m._ch = val;
97 }
98 b_value(BYTE val): m_t(ATOM_UINT1), m_sz(sizeof(BYTE)), m_q(1) {
99 m._uc = val;
100 }
101 b_value(short val): m_t(ATOM_INT2), m_sz(sizeof(short)), m_q(1) {
102 m._sh = val;
103 }
104 b_value(USHORT val): m_t(ATOM_UINT2), m_sz(sizeof(USHORT)), m_q(1) {
105 m._us = val;
106 }
107 b_value(int val): m_t(ATOM_INT4), m_sz(sizeof(int)), m_q(1) {
108 m._in = val;
109 }
110 b_value(UINT val): m_t(ATOM_UINT4), m_sz(sizeof(UINT)), m_q(1) {
111 m._ui = val;
112 }
113 b_value(float val): m_t(ATOM_FLOAT4), m_sz(sizeof(float)), m_q(1) {
114 m._fl = val;
115 }
116 b_value(double val): m_t(ATOM_FLOAT8), m_sz(sizeof(double)), m_q(1) {
117 m._do = val;
118 }
119 b_value(BYTE * val, size_t q): m_t(ATOM_BINARY), m_sz(sizeof(BYTE)), m_q(q) {
120 if (val != NULL && q > 0) {
121 m._bin = (BYTE *)malloc(q);
122 memmove(m._bin, val, q);
123 } else {
124 m._bin = NULL;
125 }
126 }
127 b_value(const BCHAR * val): m_t(ATOM_ASCII), m_sz(sizeof(BCHAR)) {
128 if (val != NULL) {
129 m._str = new string(val);
130 m_q = m._str->size();
131 } else {
132 m._str = NULL;
133 m_q = 0;
134 }
135 }
136 b_value(const string& val): m_t(ATOM_ASCII), m_sz(sizeof(BCHAR)) {
137 m._str = (val.size() > 0) ? new string(val) : NULL;
138 m_q = val.size();
139 }
140 b_value(LONGLONG val): m_t(ATOM_INT8), m_sz(sizeof(LONGLONG)), m_q(1) {
141 m._llo = val;
142 }
143 b_value(ULONGLONG val): m_t(ATOM_UINT8), m_sz(sizeof(ULONGLONG)), m_q(1) {
144 m._ull = val;
145 }
146 b_value(const b_valvect& val): m_t(ATOM_LIST), m_sz(0) {
147 m._vec = (val.size() > 0) ? new b_valvect(val) : new b_valvect();
148 m_q = val.size();
149 }
150 b_value(b_valvect * any, int type): m_t(type), m_sz(0) { // type is STRUCT or VECTOR
151 m._vec = any;
152 m_q = (any != NULL) ? any->size() : 0;
153 }
154 b_value(const b_value& rhs) { copy(rhs); }
155 b_value(const b_id& id);
156
157 // Destructor
158 inline void clean() {
159 if (m_t == ATOM_ASCII && m._str != NULL) {
160 delete m._str; m._str = NULL;
161 } else if (m_t == ATOM_LIST && m._vec != NULL) {
162 delete m._vec; m._vec = NULL;
163 } else if (m_t == ATOM_BINARY && m._bin != NULL) {
164 free(m._bin); m._bin = NULL;
165 } else if ((m_t == ATOM_STRUCT || m_t == ATOM_VECTOR) &&
166 m_q > 0 && m._vec != NULL) {
167 delete m._vec; m._vec = NULL;
168 } else if ((m_t & ATOM_ARRAY) && m_q > 0 && m._ptr != NULL) {
169 free(m._ptr); m._ptr = NULL;
170 } else if ((m_t == ATOM_JIS || m_t == ATOM_UNICODE) &&
171 m._str != NULL) {
172 delete m._str; m._str = NULL;
173 }
174 }
175 virtual ~b_value() { clean(); }
176
177 b_value& operator=(bool val) {
178 clean();
179 m_t = ATOM_BOOLEAN; m_q = 1; m_sz = sizeof(bool);
180 m._bo = val; return *this;
181 }
182 b_value& operator=(char val) {
183 clean();
184 m_t = ATOM_INT1; m_q = 1; m_sz = sizeof(char);
185 m._ch = val; return *this;
186 }
187 b_value& operator=(BYTE val) {
188 clean();
189 m_t = ATOM_UINT1; m_q = 1; m_sz = sizeof(BYTE);
190 m._uc = val; return *this;
191 }
192 b_value& operator=(short val) {
193 clean();
194 m_t = ATOM_INT2; m_q = 1; m_sz = sizeof(short);
195 m._sh = val; return *this;
196 }
197 b_value& operator=(USHORT val) {
198 clean();
199 m_t = ATOM_UINT2; m_q = 1; m_sz = sizeof(USHORT);
200 m._us = val; return *this;
201 }
202 b_value& operator=(int val) {
203 clean();
204 m_t = ATOM_INT4; m_q = 1; m_sz = sizeof(int);
205 m._in = val; return *this;
206 }
207 b_value& operator=(UINT val) {
208 clean();
209 m_t = ATOM_UINT4; m_q = 1; m_sz = sizeof(UINT);
210 m._ui = val; return *this;
211 }
212 b_value& operator=(float val) {
213 clean();
214 m_t = ATOM_FLOAT4; m_q = 1; m_sz = sizeof(float);
215 m._fl = val; return *this;
216 }
217 b_value& operator=(double val) {
218 clean();
219 m_t = ATOM_FLOAT8; m_q = 1; m_sz = sizeof(double);
220 m._do = val; return *this;
221 }
222 b_value& operator=(const string& val) {
223 clean();
224 m_t = ATOM_ASCII; m_q = val.size(); m_sz = sizeof(char);
225 m._str = (val.size() > 0) ? new string(val) : NULL;
226 return *this;
227 }
228 b_value& operator=(LONGLONG val) {
229 clean();
230 m_t = ATOM_INT8; m_q = 1; m_sz = sizeof(LONGLONG);
231 m._llo = val; return *this;
232 }
233 b_value& operator=(ULONGLONG val) {
234 clean();
235 m_t = ATOM_UINT8; m_q = 1; m_sz = sizeof(ULONGLONG);
236 m._ull = val; return *this;
237 }
238 b_value& operator=(const BCHAR * val) {
239 clean();
240 m_t = ATOM_ASCII; m_q = (val != NULL) ? strlen(val) : 0;
241 m_sz = sizeof(BCHAR);
242 m._str = (val != NULL) ? new string(val) : NULL;
243 return *this;
244 }
245 b_value& operator=(const b_valvect& val) {
246 clean();
247 m_t = ATOM_LIST; m_q = val.size(); m_sz = 0;
248 m._vec = (val.size() > (size_t)0) ? new b_valvect(val) :
249 new b_valvect();
250 return *this;
251 }
252 b_value& operator=(const b_value& rhs) {
253 if (this == &rhs)
254 return *this;
255 clean();
256 copy(rhs);
257 return *this;
258 }
259 b_value& operator=(const b_id& id);
260
261 inline int format() const { return m_t; }
262 inline void format(int t) { m_t = t; }
263 size_t size() const {
264 if (m_t == ATOM_LIST || m_t == ATOM_STRUCT || m_t == ATOM_VECTOR)
265 return total();
266 else if (m_t == ATOM_ASCII || m_t == ATOM_JIS || m_t == ATOM_UNICODE)
267 return ((m._str) ? m._str->size() + 1 : 0);
268 return (m_sz * m_q);
269 }
270 size_t dataq() const {
271 if (m_t == ATOM_LIST || m_t == ATOM_STRUCT || m_t == ATOM_VECTOR) {
272 size_t q = 0;
273 for (int i = 0; i < (int)m._vec->size(); i++) {
274 b_value * valptr = (*m._vec)[i];
275 q += valptr->dataq();
276 }
277 return (q + 1); // Add own
278 } else {
279 return 1;
280 }
281 }
282 const BCHAR * formatName() { return b_value::formatStr(m_t); }
283 const BCHAR * smlName() { return b_value::smlStr(m_t); }
284 bool isEmpty() const { return (m_q == 0); }
285 bool isNil() const {
286 if (m_q == 0) {
287 return true;
288 } else if (m_t == ATOM_ASCII) {
289 return (m._str->size() == 0);
290 } else if (m_t == ATOM_UINT4) {
291 return (m._ui == 0);
292 } else if (m_t == ATOM_INT4) {
293 return (m._in == 0);
294 } else if (m_t == ATOM_UINT2) {
295 return (m._us == 0);
296 } else if (m_t == ATOM_INT2) {
297 return (m._sh == 0);
298 } else if (m_t == ATOM_UINT1) {
299 return (m._uc == 0);
300 } else if (m_t == ATOM_INT1) {
301 return (m._ch == 0);
302 } else if (m_t == ATOM_FLOAT4) {
303 return (m._fl == 0.0);
304 } else if (m_t == ATOM_FLOAT8) {
305 return (m._do == 0.0);
306 } else if (m_t == ATOM_INT8) {
307 return (m._llo == 0);
308 } else if (m_t == ATOM_UINT8) {
309 return (m._ull == 0);
310 } else if (m_t == ATOM_JIS || m_t == ATOM_UNICODE) {
311 return (m._str->size() == 0);
312 } else if (m_t == ATOM_LIST || m_t == ATOM_STRUCT ||
313 m_t == ATOM_VECTOR) {
314 if (m._vec == NULL)
315 return true;
316 return (m._vec->size() == 0);
317 } else /* if (lhs.m_t == ATOM_BOOLEAN) */ {
318 return false;
319 }
320 }
321 bool getBool() const {
322 if (m_t == ATOM_BOOLEAN) { return m._bo; }
323 else if (m_t == ATOM_INT4) { return (m._in != 0); }
324 else if (m_t == ATOM_UINT4) { return (m._ui != 0); }
325 else if (m_t == ATOM_INT2) { return (m._sh != 0); }
326 else if (m_t == ATOM_UINT2) { return (m._us != 0); }
327 else if (m_t == ATOM_INT1) { return (m._ch != 0); }
328 else if (m_t == ATOM_UINT1) { return (m._uc != 0); }
329 else if (m_t == ATOM_INT8) { return (m._llo != 0L); }
330 else if (m_t == ATOM_UINT8) { return (m._ull != 0L); }
331 else if (m_t == ATOM_FLOAT4) { return (m._fl != 0.0); }
332 else if (m_t == ATOM_FLOAT8) { return (m._do != 0.0); }
333 return false;
334 }
335
336 int getInt() const {
337 if (m_t == ATOM_INT4) { return m._in; }
338 else if (m_t == ATOM_UINT4) { return (int)m._ui; }
339 else if (m_t == ATOM_INT2) { return (int)m._sh; }
340 else if (m_t == ATOM_INT1) { return (int)m._ch; }
341 else if (m_t == ATOM_UINT2) { return (int)m._us; }
342 else if (m_t == ATOM_UINT1) { return (int)m._uc; }
343 else if (m_t == ATOM_INT8) { return (int)m._llo; }
344 else if (m_t == ATOM_UINT8) { return (int)m._ull; }
345 else if (m_t == ATOM_BOOLEAN) { return (m._bo) ? 1 : 0; }
346 else if (m_t == ATOM_FLOAT4) { long l = (long)m._fl; return (int)l; }
347 else if (m_t == ATOM_FLOAT8) { long l = (long)m._do; return (int)l; }
348 else if (m_t == ATOM_BINARY) {
349 if (m._bin != NULL && m_q == 1) {
350 int i = *(m._bin);
351 return i;
352 }
353 }
354 return 0;
355 }
356 LONGLONG getInt2() const {
357 if (m_t == ATOM_INT8) { return m._llo; }
358 else if (m_t == ATOM_INT4) { return (LONGLONG)m._in; }
359 else if (m_t == ATOM_UINT4) { return (LONGLONG)m._ui; }
360 else if (m_t == ATOM_INT2) { return (LONGLONG)m._sh; }
361 else if (m_t == ATOM_INT1) { return (LONGLONG)m._ch; }
362 else if (m_t == ATOM_UINT2) { return (LONGLONG)m._us; }
363 else if (m_t == ATOM_UINT1) { return (LONGLONG)m._uc; }
364 else if (m_t == ATOM_UINT8) { return (LONGLONG)m._ull; }
365 else if (m_t == ATOM_BOOLEAN) { return (m._bo) ? 1 : 0; }
366 else if (m_t == ATOM_FLOAT4) { return (LONGLONG)m._fl; }
367 else if (m_t == ATOM_FLOAT8) { return (LONGLONG)m._do; }
368 else if (m_t == ATOM_BINARY) {
369 if (m._bin != NULL && m_q == 1) {
370 LONGLONG i = (LONGLONG)*(m._bin);
371 return i;
372 }
373 }
374 return 0;
375 }
376 int getIntAt(int pos) const {
377 if ((m_t & ATOM_ARRAY) == 0)
378 {
379 return (pos == 0) ? this->getInt() : 0;
380 }
381 if (m._ptr == NULL || m_q <= pos)
382 {
383 return -1;
384 }
385 int primtype = m_t & ~ATOM_ARRAY;
386 if (primtype == ATOM_INT4) { return *(((int *)m._ptr) + pos); }
387 else if (primtype == ATOM_UINT4) {
388 return (int)(*(((UINT *)m._ptr) + pos));
389 } else if (primtype == ATOM_INT2) {
390 return (int)(*(((short *)m._ptr) + pos));
391 } else if (primtype == ATOM_INT1) {
392 return (int)(*(((char *)m._ptr) + pos));
393 } else if (primtype == ATOM_UINT2) {
394 return (int)(*(((USHORT *)m._ptr) + pos));
395 } else if (primtype == ATOM_UINT1) {
396 return (int)(*(((BYTE *)m._ptr) + pos));
397 } else if (primtype == ATOM_INT8) {
398 return (int)(*(((LONGLONG *)m._ptr) + pos));
399 } else if (primtype == ATOM_UINT8) {
400 return (int)(*(((ULONGLONG *)m._ptr) + pos));
401 } else if (primtype == ATOM_BOOLEAN) {
402 return (*(((bool *)m._ptr) + pos)) ? 1 : 0;
403 } else if (primtype == ATOM_FLOAT4) {
404 long l = (long)(*(((float *)m._ptr) + pos));
405 return (int)l;
406 } else if (primtype == ATOM_FLOAT8) {
407 long l = (long)(*(((double *)m._ptr) + pos));
408 return (int)l;
409 } else if (primtype == ATOM_BINARY) {
410 return -1;
411 }
412 return 0;
413 }
414 unsigned int getUInt() const {
415 if (m_t == ATOM_UINT4) { return m._ui; }
416 else if (m_t == ATOM_INT4) { return (UINT)m._in; }
417 else if (m_t == ATOM_UINT2) { return (UINT)m._us; }
418 else if (m_t == ATOM_UINT1) { return (UINT)m._uc; }
419 else if (m_t == ATOM_INT2) { return (UINT)m._sh; }
420 else if (m_t == ATOM_INT1) { return (UINT)m._ch; }
421 else if (m_t == ATOM_UINT8) { return (UINT)m._ull; }
422 else if (m_t == ATOM_INT8) { return (UINT)m._llo; }
423 else if (m_t == ATOM_BOOLEAN) { return (m._bo) ? 1 : 0; }
424 else if (m_t == ATOM_FLOAT4) { long l = (long)m._fl; return (UINT)l; }
425 else if (m_t == ATOM_FLOAT8) { long l = (long)m._do; return (UINT)l; }
426 else if (m_t == ATOM_BINARY) {
427 if (m._bin != NULL && m_q == 1) {
428 UINT i = *(m._bin);
429 return i;
430 }
431 }
432 return 0;
433 }
434 ULONGLONG getUInt2() const {
435 if (m_t == ATOM_UINT8) { return m._ull; }
436 else if (m_t == ATOM_UINT4) { return (ULONGLONG)m._ui; }
437 else if (m_t == ATOM_INT4) { return (ULONGLONG)m._in; }
438 else if (m_t == ATOM_UINT2) { return (ULONGLONG)m._us; }
439 else if (m_t == ATOM_UINT1) { return (ULONGLONG)m._uc; }
440 else if (m_t == ATOM_INT2) { return (ULONGLONG)m._sh; }
441 else if (m_t == ATOM_INT1) { return (ULONGLONG)m._ch; }
442 else if (m_t == ATOM_INT8) { return (ULONGLONG)m._llo; }
443 else if (m_t == ATOM_BOOLEAN) { return (m._bo) ? 1 : 0; }
444 else if (m_t == ATOM_FLOAT4) { return (ULONGLONG)m._fl; }
445 else if (m_t == ATOM_FLOAT8) { return (ULONGLONG)m._do; }
446 else if (m_t == ATOM_BINARY) {
447 if (m._bin != NULL && m_q == 1) {
448 ULONGLONG i = (ULONGLONG)*(m._bin);
449 return i;
450 }
451 }
452 return 0;
453 }
454 int setInt(int v);
455 int setDouble(double v);
456
457 int set(const string& valstr, int format);
458 void set(const b_value& value) { *this = value; }
459 void set(const BYTE * bin, size_t q) {
460 clean();
461 m_t = ATOM_BINARY; m_q = q; m_sz = sizeof(BYTE);
462 m._bin = (BYTE *)malloc(m_q * m_sz);
463 memmove(m._bin, bin, q);
464 }
465 void set(b_valvect * any, int type) { // type is STRUCT or VECTOR
466 m._vec = any; m_t = type; m_sz = 0;
467 m_q = any->size();
468 }
469 void get(b_value& retval) { retval = *this; }
470 int get(string& retval) const;
471
472 virtual string toString() const;
473
474 static const BCHAR * formatStr(int format);
475 static const BCHAR * smlStr(int format);
476 static int strToFormat(const BCHAR * frmStr);
477 static int smlToFormat(const BCHAR * smlStr);
478 static b_value zero;
479
480 friend bool operator==(const b_value& lhs, const b_value& rhs);
481 friend bool operator!=(const b_value& lhs, const b_value& rhs) {
482 return (! (lhs == rhs));
483 }
484 friend bool operator<(const b_value& lhs, const b_value& rhs);
485
486 //
487 protected:
488 void copy(const b_value& rhs);
489 size_t total() const; // calculate bytes in list
490 };
491
492 inline bool operator==(const b_value& lhs, const b_value& rhs)
493 {
494 if (lhs.m_t == rhs.m_t) {
495 if (lhs.m_t == ATOM_ASCII) {
496 return (*lhs.m._str == *rhs.m._str);
497 } else if (lhs.m_t == ATOM_UINT4) {
498 return (lhs.m._ui == rhs.m._ui);
499 } else if (lhs.m_t == ATOM_INT4) {
500 return (lhs.m._in == rhs.m._in);
501 } else if (lhs.m_t == ATOM_BOOLEAN) {
502 return (lhs.m._bo == rhs.m._bo);
503 } else if (lhs.m_t == ATOM_UINT2) {
504 return (lhs.m._us == rhs.m._us);
505 } else if (lhs.m_t == ATOM_INT2) {
506 return (lhs.m._sh == rhs.m._sh);
507 } else if (lhs.m_t == ATOM_UINT1) {
508 return (lhs.m._uc == rhs.m._uc);
509 } else if (lhs.m_t == ATOM_INT1) {
510 return (lhs.m._ch == rhs.m._ch);
511 } else if (lhs.m_t == ATOM_FLOAT8) {
512 return (lhs.m._do == rhs.m._do);
513 } else if (lhs.m_t == ATOM_FLOAT4) {
514 return (lhs.m._fl == rhs.m._fl);
515 } else if (lhs.m_t == ATOM_INT8) {
516 return (lhs.m._llo == rhs.m._llo);
517 } else if (lhs.m_t == ATOM_UINT8) {
518 return (lhs.m._ull == rhs.m._ull);
519 } else if (lhs.m_t == ATOM_JIS || lhs.m_t == ATOM_UNICODE) {
520 return (*lhs.m._str == *rhs.m._str);
521 } else if (lhs.m_t == ATOM_LIST || lhs.m_t == ATOM_STRUCT ||
522 lhs.m_t == ATOM_VECTOR) {
523 if (lhs.m._vec == NULL || rhs.m._vec == NULL)
524 return (lhs.m._vec == rhs.m._vec);
525 return (*lhs.m._vec == *rhs.m._vec);
526 }
527 } else if (lhs.m_t == ATOM_UINT4) {
528 unsigned int uival = rhs.getUInt();
529 return (lhs.m._ui == uival);
530 } else if (lhs.m_t == ATOM_INT4) {
531 int ival = rhs.getInt();
532 return (lhs.m._in == ival);
533 } else if (lhs.m_t == ATOM_INT8) {
534 LONGLONG ival = rhs.getInt2();
535 return (lhs.m._llo == ival);
536 } else if (lhs.m_t == ATOM_UINT8) {
537 ULONGLONG ival = rhs.getUInt2();
538 return (lhs.m._ull == ival);
539 }
540 return false;
541 }
542
543 inline bool operator<(const b_value& lhs, const b_value& rhs)
544 {
545 if (lhs.m_t == rhs.m_t) {
546 if (lhs.m_t == ATOM_ASCII) {
547 return (*lhs.m._str < *rhs.m._str);
548 } else if (lhs.m_t == ATOM_UINT4) {
549 return (lhs.m._ui < rhs.m._ui);
550 } else if (lhs.m_t == ATOM_INT4) {
551 return (lhs.m._in < rhs.m._in);
552 } else if (lhs.m_t == ATOM_UINT2) {
553 return (lhs.m._us < rhs.m._us);
554 } else if (lhs.m_t == ATOM_INT2) {
555 return (lhs.m._sh < rhs.m._sh);
556 } else if (lhs.m_t == ATOM_UINT1) {
557 return (lhs.m._uc < rhs.m._uc);
558 } else if (lhs.m_t == ATOM_INT1) {
559 return (lhs.m._ch < rhs.m._ch);
560 } else if (lhs.m_t == ATOM_BOOLEAN) {
561 return (lhs.m._bo < rhs.m._bo);
562 } else if (lhs.m_t == ATOM_FLOAT8) {
563 return (lhs.m._do < rhs.m._do);
564 } else if (lhs.m_t == ATOM_FLOAT4) {
565 return (lhs.m._fl < rhs.m._fl);
566 } else if (lhs.m_t == ATOM_INT8) {
567 return (lhs.m._llo < rhs.m._llo);
568 } else if (lhs.m_t == ATOM_UINT8) {
569 return (lhs.m._ull < rhs.m._ull);
570 } else if (lhs.m_t == ATOM_JIS || lhs.m_t == ATOM_UNICODE) {
571 return (*lhs.m._str < *rhs.m._str);
572 } else if (lhs.m_t == ATOM_LIST || lhs.m_t == ATOM_STRUCT ||
573 lhs.m_t == ATOM_VECTOR) {
574 if (lhs.m._vec == NULL || rhs.m._vec == NULL)
575 return false;
576 return (*lhs.m._vec < *rhs.m._vec);
577 }
578 } else if (lhs.m_t == ATOM_UINT4) {
579 unsigned int uival = rhs.getUInt();
580 return (lhs.m._ui < uival);
581 } else if (lhs.m_t == ATOM_INT4) {
582 int ival = rhs.getInt();
583 return (lhs.m._in < ival);
584 } else if (lhs.m_t == ATOM_INT8) {
585 LONGLONG ival = rhs.getInt2();
586 return (lhs.m._llo < ival);
587 } else if (lhs.m_t == ATOM_UINT8) {
588 ULONGLONG ival = rhs.getUInt2();
589 return (lhs.m._ull < ival);
590 }
591 return false;
592 }
593
594 // Compare
595 struct value_less
596 {
597 bool operator() (const b_value& x, const b_value& y) const {
598 return (x < y);
599 }
600 };
601
602 #endif /* B_VALUE_H */
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help