AnimatLab  2
Test
StdVariant.cpp
Go to the documentation of this file.
1 
7 #include "StdAfx.h"
8 
9 namespace StdUtils
10 {
11 
18 CStdVariant::CStdVariant()
19 {
20  m_bCreatedVar = false;
21  m_iVariantType = StdVtEmpty;
22 
23  m_lpShort = NULL;
24  m_lpLong = NULL;
25  m_lpFloat = NULL;
26  m_lpDouble = NULL;
27  m_lpBool = NULL;
28  m_lpChar = NULL;
29  m_lpUChar = NULL;
30  m_lpUShort = NULL;
31  m_lpULong = NULL;
32  m_lpInt = NULL;
33  m_lpUInt = NULL;
34  m_lpString = NULL;
35 }
36 
43 CStdVariant::~CStdVariant()
44 {
45 
46 try
47 {
48  Reset();
49 }
50 catch(...)
51 {Std_TraceMsg(0, "Caught Error in desctructor of CStdVariant\r\n", "", -1, false, true);}
52 }
53 
62 int CStdVariant::VariantType()
63 {return m_iVariantType;}
64 
73 std::string CStdVariant::VariantTypeName()
74 {return Std_ConstToVariantType(m_iVariantType);}
75 
82 void CStdVariant::Reset()
83 {
84 
85  if(m_bCreatedVar)
86  {
87  if(m_lpShort) delete m_lpShort;
88  if(m_lpLong) delete m_lpLong;
89  if(m_lpFloat) delete m_lpFloat;
90  if(m_lpDouble) delete m_lpDouble;
91  if(m_lpBool) delete m_lpBool;
92  if(m_lpChar) delete m_lpChar;
93  if(m_lpUChar) delete m_lpUChar;
94  if(m_lpUShort) delete m_lpUShort;
95  if(m_lpULong) delete m_lpULong;
96  if(m_lpInt) delete m_lpInt;
97  if(m_lpUInt) delete m_lpUInt;
98  if(m_lpString) delete m_lpString;
99  }
100 
101  m_bCreatedVar = false;
102  m_iVariantType = StdVtEmpty;
103 
104  m_lpShort = NULL;
105  m_lpLong = NULL;
106  m_lpFloat = NULL;
107  m_lpDouble = NULL;
108  m_lpBool = NULL;
109  m_lpChar = NULL;
110  m_lpUChar = NULL;
111  m_lpUShort = NULL;
112  m_lpULong = NULL;
113  m_lpInt = NULL;
114  m_lpUInt = NULL;
115  m_lpString = NULL;
116 }
117 
128 short CStdVariant::GetShort(bool bConvert)
129 {
130  if(!bConvert && (m_iVariantType!=StdVtShort) )
131  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Short");
132 
133  switch (m_iVariantType)
134  {
135  case StdVtEmpty:
136  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
137  break;
138 
139  case StdVtShort:
140  return (short) *m_lpShort;
141  case StdVtLong:
142  return (short) *m_lpLong;
143  case StdVtFloat:
144  return (short) *m_lpFloat;
145  case StdVtDouble:
146  return (short) *m_lpDouble;
147  case StdVtBool:
148  return (short) *m_lpBool;
149  case StdVtChar:
150  return (short) *m_lpChar;
151  case StdVtUChar:
152  return (short) *m_lpUChar;
153  case StdVtUShort:
154  return (short) *m_lpUShort;
155  case StdVtULong:
156  return (short) *m_lpULong;
157  case StdVtInt:
158  return (short) *m_lpInt;
159  case StdVtUInt:
160  return (short) *m_lpUInt;
161  case StdVtString:
162  return (short) atol(m_lpString->c_str());
163 
164  default:
165  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
166  break;
167  }
168 
169  return -1;
170 }
171 
180 short *CStdVariant::GetShortPtr()
181 {
182  if(!m_lpShort || (m_iVariantType!=StdVtShort) )
183  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Short");
184  return m_lpShort;
185 }
186 
195 void CStdVariant::SetValue(short Val)
196 {
197  Reset();
198  m_iVariantType = StdVtShort;
199  m_lpShort = new short;
200  m_bCreatedVar = true;
201  *m_lpShort = Val;
202 }
203 
212 void CStdVariant::SetPtr(short *lpVal)
213 {
214  Reset();
215  m_iVariantType = StdVtShort;
216  m_lpShort = lpVal;
217  m_bCreatedVar = false;
218 }
219 
230 long CStdVariant::GetLong(bool bConvert)
231 {
232  if(!bConvert && (m_iVariantType!=StdVtLong) )
233  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Long");
234 
235  switch (m_iVariantType)
236  {
237  case StdVtEmpty:
238  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
239  break;
240 
241  case StdVtShort:
242  return (long) *m_lpShort;
243  case StdVtLong:
244  return (long) *m_lpLong;
245  case StdVtFloat:
246  return (long) *m_lpFloat;
247  case StdVtDouble:
248  return (long) *m_lpDouble;
249  case StdVtBool:
250  return (long) *m_lpBool;
251  case StdVtChar:
252  return (long) *m_lpChar;
253  case StdVtUChar:
254  return (long) *m_lpUChar;
255  case StdVtUShort:
256  return (long) *m_lpUShort;
257  case StdVtULong:
258  return (long) *m_lpULong;
259  case StdVtInt:
260  return (long) *m_lpInt;
261  case StdVtUInt:
262  return (long) *m_lpUInt;
263  case StdVtString:
264  return (long) atol(m_lpString->c_str());
265 
266  default:
267  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
268  break;
269  }
270 
271  return -1;
272 }
273 
282 long *CStdVariant::GetLongPtr()
283 {
284  if(!m_lpLong || (m_iVariantType!=StdVtLong) )
285  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Long");
286  return m_lpLong;
287 }
288 
297 void CStdVariant::SetValue(long Val)
298 {
299  Reset();
300  m_iVariantType = StdVtLong;
301  m_lpLong = new long;
302  m_bCreatedVar = true;
303  *m_lpLong = Val;
304 }
305 
314 void CStdVariant::SetPtr(long *lpVal)
315 {
316  Reset();
317  m_iVariantType = StdVtLong;
318  m_lpLong = lpVal;
319  m_bCreatedVar = false;
320 }
321 
332 float CStdVariant::GetFloat(bool bConvert)
333 {
334  if(!bConvert && (m_iVariantType!=StdVtFloat) )
335  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Float");
336 
337  switch (m_iVariantType)
338  {
339  case StdVtEmpty:
340  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
341  break;
342 
343  case StdVtShort:
344  return (float) *m_lpShort;
345  case StdVtLong:
346  return (float) *m_lpLong;
347  case StdVtFloat:
348  return (float) *m_lpFloat;
349  case StdVtDouble:
350  return (float) *m_lpDouble;
351  case StdVtBool:
352  return (float) *m_lpBool;
353  case StdVtChar:
354  return (float) *m_lpChar;
355  case StdVtUChar:
356  return (float) *m_lpUChar;
357  case StdVtUShort:
358  return (float) *m_lpUShort;
359  case StdVtULong:
360  return (float) *m_lpULong;
361  case StdVtInt:
362  return (float) *m_lpInt;
363  case StdVtUInt:
364  return (float) *m_lpUInt;
365  case StdVtString:
366  return (float) atof(m_lpString->c_str());
367 
368  default:
369  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
370  break;
371  }
372 
373  return -1;
374 }
375 
385 float *CStdVariant::GetFloatPtr()
386 {
387  if(!m_lpFloat || (m_iVariantType!=StdVtFloat) )
388  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Float");
389  return m_lpFloat;
390 }
391 
400 void CStdVariant::SetValue(float Val)
401 {
402  Reset();
403  m_iVariantType = StdVtFloat;
404  m_lpFloat = new float;
405  m_bCreatedVar = true;
406  *m_lpFloat = Val;
407 }
408 
417 void CStdVariant::SetPtr(float *lpVal)
418 {
419  Reset();
420  m_iVariantType = StdVtFloat;
421  m_lpFloat = lpVal;
422  m_bCreatedVar = false;
423 }
424 
435 double CStdVariant::GetDouble(bool bConvert)
436 {
437  if(!bConvert && (m_iVariantType!=StdVtDouble) )
438  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Double");
439 
440  switch (m_iVariantType)
441  {
442  case StdVtEmpty:
443  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
444  break;
445 
446  case StdVtShort:
447  return (double) *m_lpShort;
448  case StdVtLong:
449  return (double) *m_lpLong;
450  case StdVtFloat:
451  return (double) *m_lpFloat;
452  case StdVtDouble:
453  return (double) *m_lpDouble;
454  case StdVtBool:
455  return (double) *m_lpBool;
456  case StdVtChar:
457  return (double) *m_lpChar;
458  case StdVtUChar:
459  return (double) *m_lpUChar;
460  case StdVtUShort:
461  return (double) *m_lpUShort;
462  case StdVtULong:
463  return (double) *m_lpULong;
464  case StdVtInt:
465  return (double) *m_lpInt;
466  case StdVtUInt:
467  return (double) *m_lpUInt;
468  case StdVtString:
469  return (double) atof(m_lpString->c_str());
470 
471  default:
472  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
473  break;
474  }
475 
476  return -1;
477 }
478 
488 double *CStdVariant::GetDoublePtr()
489 {
490  if(!m_lpDouble || (m_iVariantType!=StdVtDouble) )
491  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Double");
492  return m_lpDouble;
493 }
494 
503 void CStdVariant::SetValue(double Val)
504 {
505  Reset();
506  m_iVariantType = StdVtDouble;
507  m_lpDouble = new double;
508  m_bCreatedVar = true;
509  *m_lpDouble = Val;
510 }
511 
520 void CStdVariant::SetPtr(double *lpVal)
521 {
522  Reset();
523  m_iVariantType = StdVtDouble;
524  m_lpDouble = lpVal;
525  m_bCreatedVar = false;
526 }
527 
538 bool CStdVariant::GetBool(bool bConvert)
539 {
540  if(!bConvert && (m_iVariantType!=StdVtBool) )
541  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Bool");
542 
543  switch (m_iVariantType)
544  {
545  case StdVtEmpty:
546  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
547  break;
548 
549  case StdVtShort:
550  if(*m_lpShort == 0) return false; else return true;
551  case StdVtLong:
552  if(*m_lpLong == 0) return false; else return true;
553  case StdVtFloat:
554  if(*m_lpFloat == 0) return false; else return true;
555  case StdVtDouble:
556  if(*m_lpDouble == 0) return false; else return true;
557  case StdVtBool:
558  return *m_lpBool;
559  case StdVtChar:
560  if(*m_lpChar == 0) return false; else return true;
561  case StdVtUChar:
562  if(*m_lpUChar == 0) return false; else return true;
563  case StdVtUShort:
564  if(*m_lpUShort == 0) return false; else return true;
565  case StdVtULong:
566  if(*m_lpULong == 0) return false; else return true;
567  case StdVtInt:
568  if(*m_lpInt == 0) return false; else return true;
569  case StdVtUInt:
570  if(*m_lpUInt == 0) return false; else return true;
571  case StdVtString:
572  if(Std_CheckString(*m_lpString) == "TRUE") return true; else return false;
573 
574  default:
575  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
576  break;
577  }
578 
579  return false;
580 }
581 
591 bool *CStdVariant::GetBoolPtr()
592 {
593  if(!m_lpBool || (m_iVariantType!=StdVtBool) )
594  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Bool");
595  return m_lpBool;
596 }
597 
606 void CStdVariant::SetValue(bool Val)
607 {
608  Reset();
609  m_iVariantType = StdVtBool;
610  m_lpBool = new bool;
611  m_bCreatedVar = true;
612  *m_lpBool = Val;
613 }
614 
623 void CStdVariant::SetPtr(bool *lpVal)
624 {
625  Reset();
626  m_iVariantType = StdVtBool;
627  m_lpBool = lpVal;
628  m_bCreatedVar = false;
629 }
630 
641 char CStdVariant::GetChar(bool bConvert)
642 {
643  if(!bConvert && (m_iVariantType!=StdVtDouble) )
644  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Double");
645 
646  switch (m_iVariantType)
647  {
648  case StdVtEmpty:
649  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
650  break;
651 
652  case StdVtShort:
653  return (char) *m_lpShort;
654  case StdVtLong:
655  return (char) *m_lpLong;
656  case StdVtFloat:
657  return (char) *m_lpFloat;
658  case StdVtDouble:
659  return (char) *m_lpDouble;
660  case StdVtBool:
661  return (char) *m_lpBool;
662  case StdVtChar:
663  return (char) *m_lpChar;
664  case StdVtUChar:
665  return (char) *m_lpUChar;
666  case StdVtUShort:
667  return (char) *m_lpUShort;
668  case StdVtULong:
669  return (char) *m_lpULong;
670  case StdVtInt:
671  return (char) *m_lpInt;
672  case StdVtUInt:
673  return (char) *m_lpUInt;
674  case StdVtString:
675  if(m_lpString->length())
676  return (char) (*m_lpString)[0];
677  else
678  return 0;
679 
680  default:
681  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
682  break;
683  }
684 
685  return -1;
686 }
687 
697 char *CStdVariant::GetCharPtr()
698 {
699  if(!m_lpChar || (m_iVariantType!=StdVtChar) )
700  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Char");
701  return m_lpChar;
702 }
703 
712 void CStdVariant::SetValue(char Val)
713 {
714  Reset();
715  m_iVariantType = StdVtChar;
716  m_lpChar = new char;
717  m_bCreatedVar = true;
718  *m_lpChar = Val;
719 }
720 
729 void CStdVariant::SetPtr(char *lpVal)
730 {
731  Reset();
732  m_iVariantType = StdVtChar;
733  m_lpChar = lpVal;
734  m_bCreatedVar = false;
735 }
736 
747 unsigned char CStdVariant::GetUChar(bool bConvert)
748 {
749  if(!bConvert && (m_iVariantType!=StdVtUChar) )
750  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "UChar");
751 
752  switch (m_iVariantType)
753  {
754  case StdVtEmpty:
755  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
756  break;
757 
758  case StdVtShort:
759  return (unsigned char) *m_lpShort;
760  case StdVtLong:
761  return (unsigned char) *m_lpLong;
762  case StdVtFloat:
763  return (unsigned char) *m_lpFloat;
764  case StdVtDouble:
765  return (unsigned char) *m_lpDouble;
766  case StdVtBool:
767  return (unsigned char) *m_lpBool;
768  case StdVtChar:
769  return (unsigned char) *m_lpChar;
770  case StdVtUChar:
771  return (unsigned char) *m_lpUChar;
772  case StdVtUShort:
773  return (unsigned char) *m_lpUShort;
774  case StdVtULong:
775  return (unsigned char) *m_lpULong;
776  case StdVtInt:
777  return (unsigned char) *m_lpInt;
778  case StdVtUInt:
779  return (unsigned char) *m_lpUInt;
780  case StdVtString:
781  return (unsigned char) atol(m_lpString->c_str());
782 
783  default:
784  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
785  break;
786  }
787 
788  return -1;
789 }
790 
800 unsigned char *CStdVariant::GetUCharPtr()
801 {
802  if(!m_lpUChar || (m_iVariantType!=StdVtUChar) )
803  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "UChar");
804  return m_lpUChar;
805 }
806 
815 void CStdVariant::SetValue(unsigned char Val)
816 {
817  Reset();
818  m_iVariantType = StdVtUChar;
819  m_lpUChar = new unsigned char;
820  m_bCreatedVar = true;
821  *m_lpUChar = Val;
822 }
823 
832 void CStdVariant::SetPtr(unsigned char *lpVal)
833 {
834  Reset();
835  m_iVariantType = StdVtUChar;
836  m_lpUChar = lpVal;
837  m_bCreatedVar = false;
838 }
839 
850 unsigned short CStdVariant::GetUShort(bool bConvert)
851 {
852  if(!bConvert && (m_iVariantType!=StdVtUShort) )
853  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "UShort");
854 
855  switch (m_iVariantType)
856  {
857  case StdVtEmpty:
858  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
859  break;
860 
861  case StdVtShort:
862  return (unsigned short) *m_lpShort;
863  case StdVtLong:
864  return (unsigned short) *m_lpLong;
865  case StdVtFloat:
866  return (unsigned short) *m_lpFloat;
867  case StdVtDouble:
868  return (unsigned short) *m_lpDouble;
869  case StdVtBool:
870  return (unsigned short) *m_lpBool;
871  case StdVtChar:
872  return (unsigned short) *m_lpChar;
873  case StdVtUChar:
874  return (unsigned short) *m_lpUChar;
875  case StdVtUShort:
876  return (unsigned short) *m_lpUShort;
877  case StdVtULong:
878  return (unsigned short) *m_lpULong;
879  case StdVtInt:
880  return (unsigned short) *m_lpInt;
881  case StdVtUInt:
882  return (unsigned short) *m_lpUInt;
883  case StdVtString:
884  return (unsigned short) atol(m_lpString->c_str());
885 
886  default:
887  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
888  break;
889  }
890 
891  return -1;
892 }
893 
903 unsigned short *CStdVariant::GetUShortPtr()
904 {
905  if(!m_lpUShort || (m_iVariantType!=StdVtUShort) )
906  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "UShort");
907  return m_lpUShort;
908 }
909 
918 void CStdVariant::SetValue(unsigned short Val)
919 {
920  Reset();
921  m_iVariantType = StdVtUShort;
922  m_lpUShort = new unsigned short;
923  m_bCreatedVar = true;
924  *m_lpUShort = Val;
925 }
926 
935 void CStdVariant::SetPtr(unsigned short *lpVal)
936 {
937  Reset();
938  m_iVariantType = StdVtUShort;
939  m_lpUShort = lpVal;
940  m_bCreatedVar = false;
941 }
942 
953 unsigned long CStdVariant::GetULong(bool bConvert)
954 {
955  if(!bConvert && (m_iVariantType!=StdVtULong) )
956  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "ULong");
957 
958  switch (m_iVariantType)
959  {
960  case StdVtEmpty:
961  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
962  break;
963 
964  case StdVtShort:
965  return (unsigned long) *m_lpShort;
966  case StdVtLong:
967  return (unsigned long) *m_lpLong;
968  case StdVtFloat:
969  return (unsigned long) *m_lpFloat;
970  case StdVtDouble:
971  return (unsigned long) *m_lpDouble;
972  case StdVtBool:
973  return (unsigned long) *m_lpBool;
974  case StdVtChar:
975  return (unsigned long) *m_lpChar;
976  case StdVtUChar:
977  return (unsigned long) *m_lpUChar;
978  case StdVtUShort:
979  return (unsigned long) *m_lpUShort;
980  case StdVtULong:
981  return (unsigned long) *m_lpULong;
982  case StdVtInt:
983  return (unsigned long) *m_lpInt;
984  case StdVtUInt:
985  return (unsigned long) *m_lpUInt;
986  case StdVtString:
987  return (unsigned long) atol(m_lpString->c_str());
988 
989  default:
990  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
991  break;
992  }
993 
994  return -1;
995 }
996 
1005 unsigned long *CStdVariant::GetULongPtr()
1006 {
1007  if(!m_lpULong || (m_iVariantType!=StdVtULong) )
1008  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "ULong");
1009  return m_lpULong;
1010 }
1011 
1020 void CStdVariant::SetValue(unsigned long Val)
1021 {
1022  Reset();
1023  m_iVariantType = StdVtULong;
1024  m_lpULong = new unsigned long;
1025  m_bCreatedVar = true;
1026  *m_lpULong = Val;
1027 }
1028 
1037 void CStdVariant::SetPtr(unsigned long *lpVal)
1038 {
1039  Reset();
1040  m_iVariantType = StdVtULong;
1041  m_lpULong = lpVal;
1042  m_bCreatedVar = false;
1043 }
1044 
1055 int CStdVariant::GetInt(bool bConvert)
1056 {
1057  if(!bConvert && (m_iVariantType!=StdVtInt) )
1058  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Int");
1059 
1060  switch (m_iVariantType)
1061  {
1062  case StdVtEmpty:
1063  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
1064  break;
1065 
1066  case StdVtShort:
1067  return (int) *m_lpShort;
1068  case StdVtLong:
1069  return (int) *m_lpLong;
1070  case StdVtFloat:
1071  return (int) *m_lpFloat;
1072  case StdVtDouble:
1073  return (int) *m_lpDouble;
1074  case StdVtBool:
1075  return (int) *m_lpBool;
1076  case StdVtChar:
1077  return (int) *m_lpChar;
1078  case StdVtUChar:
1079  return (int) *m_lpUChar;
1080  case StdVtUShort:
1081  return (int) *m_lpUShort;
1082  case StdVtULong:
1083  return (int) *m_lpULong;
1084  case StdVtInt:
1085  return (int) *m_lpInt;
1086  case StdVtUInt:
1087  return (int) *m_lpUInt;
1088  case StdVtString:
1089  return (int) atof(m_lpString->c_str());
1090 
1091  default:
1092  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1093  break;
1094  }
1095 
1096  return -1;
1097 }
1098 
1107 int *CStdVariant::GetIntPtr()
1108 {
1109  if(!m_lpInt || (m_iVariantType!=StdVtInt) )
1110  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "Int");
1111  return m_lpInt;
1112 }
1113 
1122 void CStdVariant::SetValue(int Val)
1123 {
1124  Reset();
1125  m_iVariantType = StdVtInt;
1126  m_lpInt = new int;
1127  m_bCreatedVar = true;
1128  *m_lpInt = Val;
1129 }
1130 
1139 void CStdVariant::SetPtr(int *lpVal)
1140 {
1141  Reset();
1142  m_iVariantType = StdVtInt;
1143  m_lpInt = lpVal;
1144  m_bCreatedVar = false;
1145 }
1146 
1157 unsigned int CStdVariant::GetUInt(bool bConvert)
1158 {
1159  if(!bConvert && (m_iVariantType!=StdVtUInt) )
1160  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "UInt");
1161 
1162  switch (m_iVariantType)
1163  {
1164  case StdVtEmpty:
1165  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
1166  break;
1167 
1168  case StdVtShort:
1169  return (unsigned int) *m_lpShort;
1170  case StdVtLong:
1171  return (unsigned int) *m_lpLong;
1172  case StdVtFloat:
1173  return (unsigned int) *m_lpFloat;
1174  case StdVtDouble:
1175  return (unsigned int) *m_lpDouble;
1176  case StdVtBool:
1177  return (unsigned int) *m_lpBool;
1178  case StdVtChar:
1179  return (unsigned int) *m_lpChar;
1180  case StdVtUChar:
1181  return (unsigned int) *m_lpUChar;
1182  case StdVtUShort:
1183  return (unsigned int) *m_lpUShort;
1184  case StdVtULong:
1185  return (unsigned int) *m_lpULong;
1186  case StdVtInt:
1187  return (unsigned int) *m_lpInt;
1188  case StdVtUInt:
1189  return (unsigned int) *m_lpUInt;
1190  case StdVtString:
1191  return (unsigned int) atol(m_lpString->c_str());
1192 
1193  default:
1194  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1195  break;
1196  }
1197 
1198  return -1;
1199 }
1200 
1209 unsigned int *CStdVariant::GetUIntPtr()
1210 {
1211  if(!m_lpUInt || (m_iVariantType!=StdVtUInt) )
1212  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "UInt");
1213  return m_lpUInt;
1214 }
1215 
1224 void CStdVariant::SetValue(unsigned int Val)
1225 {
1226  Reset();
1227  m_iVariantType = StdVtUInt;
1228  m_lpUInt = new unsigned int;
1229  m_bCreatedVar = true;
1230  *m_lpUInt = Val;
1231 }
1232 
1241 void CStdVariant::SetPtr(unsigned int *lpVal)
1242 {
1243  Reset();
1244  m_iVariantType = StdVtUInt;
1245  m_lpUInt = lpVal;
1246  m_bCreatedVar = false;
1247 }
1248 
1257 std::string CStdVariant::GetNumericString()
1258 {
1259  switch (m_iVariantType)
1260  {
1261  case StdVtEmpty:
1262  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
1263  break;
1264 
1265  case StdVtShort:
1266  return STR(*m_lpShort);
1267  case StdVtLong:
1268  return STR(*m_lpLong);
1269  case StdVtFloat:
1270  return STR(*m_lpFloat);
1271  case StdVtDouble:
1272  return STR(*m_lpDouble);
1273  case StdVtBool:
1274  return STR((int) *m_lpBool);
1275  case StdVtChar:
1276  return STR(*m_lpChar);
1277  case StdVtUChar:
1278  return STR(*m_lpUChar);
1279  case StdVtUShort:
1280  return STR(*m_lpUShort);
1281  case StdVtULong:
1282  return STR((long) *m_lpULong);
1283  case StdVtInt:
1284  return STR(*m_lpInt);
1285  case StdVtUInt:
1286  return STR((long) *m_lpUInt);
1287 
1288  default:
1289  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1290  break;
1291  }
1292 
1293  return "";
1294 }
1295 
1306 std::string CStdVariant::GetString(bool bConvert)
1307 {
1308  if(!bConvert && (m_iVariantType!=StdVtString) )
1309  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "String");
1310 
1311  switch (m_iVariantType)
1312  {
1313  case StdVtEmpty:
1314  THROW_ERROR(Std_Err_lVariantNotSet, Std_Err_strVariantNotSet);
1315  break;
1316 
1317  case StdVtShort:
1318  return STR(*m_lpShort);
1319  case StdVtLong:
1320  return STR(*m_lpLong);
1321  case StdVtFloat:
1322  return STR(*m_lpFloat);
1323  case StdVtDouble:
1324  return STR(*m_lpDouble);
1325  case StdVtBool:
1326  return STR(*m_lpBool);
1327  case StdVtChar:
1328  return STR(*m_lpChar);
1329  case StdVtUChar:
1330  return STR(*m_lpUChar);
1331  case StdVtUShort:
1332  return STR(*m_lpUShort);
1333  case StdVtULong:
1334  return STR((long) *m_lpULong);
1335  case StdVtInt:
1336  return STR(*m_lpInt);
1337  case StdVtUInt:
1338  return STR((long) *m_lpUInt);
1339  case StdVtString:
1340  return *m_lpString;
1341 
1342  default:
1343  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1344  break;
1345  }
1346 
1347  return "";
1348 }
1349 
1358 std::string *CStdVariant::GetStringPtr()
1359 {
1360  if(!m_lpString || (m_iVariantType!=StdVtString) )
1361  THROW_PARAM_ERROR(Std_Err_lVariantParamUndefined, Std_Err_strVariantParamUndefined, "Param", "String");
1362  return m_lpString;
1363 }
1364 
1373 void CStdVariant::SetValue(std::string Val)
1374 {
1375  Reset();
1376  m_iVariantType = StdVtShort;
1377  m_lpString = new std::string;
1378  m_bCreatedVar = true;
1379  *m_lpString = Val;
1380 }
1381 
1390 void CStdVariant::SetPtr(std::string *lpVal)
1391 {
1392  Reset();
1393  m_iVariantType = StdVtShort;
1394  m_lpString = lpVal;
1395  m_bCreatedVar = false;
1396 }
1397 
1406 void CStdVariant::Copy(CStdVariant &oVar)
1407 {
1408  switch (oVar.m_iVariantType)
1409  {
1410  case StdVtEmpty:
1411  break;
1412  case StdVtShort:
1413  SetValue(*oVar.m_lpShort);
1414  break;
1415  case StdVtLong:
1416  SetValue(*oVar.m_lpLong);
1417  break;
1418  case StdVtFloat:
1419  SetValue(*oVar.m_lpFloat);
1420  break;
1421  case StdVtDouble:
1422  SetValue(*oVar.m_lpDouble);
1423  break;
1424  case StdVtBool:
1425  SetValue(*oVar.m_lpBool);
1426  break;
1427  case StdVtChar:
1428  SetValue(*oVar.m_lpChar);
1429  break;
1430  case StdVtUChar:
1431  SetValue(*oVar.m_lpUChar);
1432  break;
1433  case StdVtUShort:
1434  SetValue(*oVar.m_lpUShort);
1435  break;
1436  case StdVtULong:
1437  SetValue(*oVar.m_lpULong);
1438  break;
1439  case StdVtInt:
1440  SetValue(*oVar.m_lpInt);
1441  break;
1442  case StdVtUInt:
1443  SetValue(*oVar.m_lpUInt);
1444  break;
1445  case StdVtString:
1446  SetValue(*oVar.m_lpString);
1447  break;
1448 
1449  default:
1450  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1451  break;
1452  }
1453 }
1454 
1463 void CStdVariant::operator=(CStdVariant &oVar)
1464 {
1465  if(oVar.m_bCreatedVar)
1466  {
1467  switch (oVar.m_iVariantType)
1468  {
1469  case StdVtEmpty:
1470  break;
1471  case StdVtShort:
1472  SetValue(*oVar.m_lpShort);
1473  break;
1474  case StdVtLong:
1475  SetValue(*oVar.m_lpLong);
1476  break;
1477  case StdVtFloat:
1478  SetValue(*oVar.m_lpFloat);
1479  break;
1480  case StdVtDouble:
1481  SetValue(*oVar.m_lpDouble);
1482  break;
1483  case StdVtBool:
1484  SetValue(*oVar.m_lpBool);
1485  break;
1486  case StdVtChar:
1487  SetValue(*oVar.m_lpChar);
1488  break;
1489  case StdVtUChar:
1490  SetValue(*oVar.m_lpUChar);
1491  break;
1492  case StdVtUShort:
1493  SetValue(*oVar.m_lpUShort);
1494  break;
1495  case StdVtULong:
1496  SetValue(*oVar.m_lpULong);
1497  break;
1498  case StdVtInt:
1499  SetValue(*oVar.m_lpInt);
1500  break;
1501  case StdVtUInt:
1502  SetValue(*oVar.m_lpUInt);
1503  break;
1504  case StdVtString:
1505  SetValue(*oVar.m_lpString);
1506  break;
1507 
1508  default:
1509  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1510  break;
1511  }
1512  }
1513  else
1514  {
1515  Reset();
1516  m_lpShort = oVar.m_lpShort;
1517  m_lpLong = oVar.m_lpLong;
1518  m_lpFloat = oVar.m_lpFloat;
1519  m_lpDouble = oVar.m_lpDouble;
1520  m_lpBool = oVar.m_lpBool;
1521  m_lpChar = oVar.m_lpChar;
1522  m_lpUChar = oVar.m_lpUChar;
1523  m_lpUShort = oVar.m_lpUShort;
1524  m_lpULong = oVar.m_lpULong;
1525  m_lpInt = oVar.m_lpInt;
1526  m_lpUInt = oVar.m_lpUInt;
1527  m_lpString = oVar.m_lpString;
1528  m_iVariantType = oVar.m_iVariantType;
1529  }
1530 
1531 }
1532 
1541 CStdSerialize *CStdVariant::Clone()
1542 {
1543  CStdVariant *lpVar=NULL;
1544 
1545 try
1546 {
1547  lpVar = new CStdVariant;
1548  lpVar->operator=(*this);
1549  return lpVar;
1550 }
1551 catch(CStdErrorInfo oError)
1552 {
1553  if(lpVar) delete lpVar;
1554  RELAY_ERROR(oError);
1555  return NULL;
1556 }
1557 catch(...)
1558 {
1559  if(lpVar) delete lpVar;
1560  THROW_ERROR(Std_Err_lUnspecifiedError, Std_Err_strUnspecifiedError);
1561  return NULL;
1562 }
1563 }
1564 
1573 void CStdVariant::Trace(std::ostream &oOs)
1574 {
1575  oOs << "(VT: " << Std_ConstToVariantType(m_iVariantType) << "\tVal: ";
1576 
1577  switch (m_iVariantType)
1578  {
1579  case StdVtEmpty:
1580  break;
1581  case StdVtShort:
1582  oOs << *m_lpShort;
1583  break;
1584  case StdVtLong:
1585  oOs << *m_lpLong;
1586  break;
1587  case StdVtFloat:
1588  oOs << *m_lpFloat;
1589  break;
1590  case StdVtDouble:
1591  oOs << *m_lpDouble;
1592  break;
1593  case StdVtBool:
1594  oOs << STR(*m_lpBool);
1595  break;
1596  case StdVtChar:
1597  oOs << *m_lpChar;
1598  break;
1599  case StdVtUChar:
1600  oOs << *m_lpUChar;
1601  break;
1602  case StdVtUShort:
1603  oOs << *m_lpUShort;
1604  break;
1605  case StdVtULong:
1606  oOs << *m_lpULong;
1607  break;
1608  case StdVtInt:
1609  oOs << *m_lpInt;
1610  break;
1611  case StdVtUInt:
1612  oOs << *m_lpUInt;
1613  break;
1614  case StdVtString:
1615  oOs << *m_lpString;
1616  break;
1617 
1618  default:
1619  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1620  break;
1621  }
1622 
1623  oOs << ")";
1624 }
1625 
1626 //CStdSerialize overloads
1627 
1636 void CStdVariant::Load(CStdXml &oXml)
1637 {
1638  short sVal;
1639  long lVal;
1640  float fltVal;
1641  double dblVal;
1642  bool bVal;
1643  char cVal;
1644  unsigned char ucVal;
1645  unsigned short usVal;
1646  unsigned long ulVal;
1647  int iVal;
1648  unsigned int uiVal;
1649  std::string strVal;
1650 
1651  oXml.IntoElem(); //Into Variant Element
1652 
1653  std::string strVariantType = oXml.GetChildString("VariantType");
1654  m_iVariantType = Std_VariantTypeToConst(strVariantType);
1655 
1656  switch (m_iVariantType)
1657  {
1658  case StdVtEmpty:
1659  break;
1660 
1661  case StdVtShort:
1662  sVal = (short) oXml.GetChildInt("Value");
1663  SetValue(sVal);
1664  break;
1665 
1666  case StdVtLong:
1667  lVal = oXml.GetChildLong("Value");
1668  SetValue(lVal);
1669  break;
1670 
1671  case StdVtFloat:
1672  fltVal = oXml.GetChildFloat("Value");
1673  SetValue(fltVal);
1674  break;
1675 
1676  case StdVtDouble:
1677  dblVal = oXml.GetChildDouble("Value");
1678  SetValue(dblVal);
1679  break;
1680 
1681  case StdVtBool:
1682  bVal = oXml.GetChildBool("Value");
1683  SetValue(bVal);
1684  break;
1685 
1686  case StdVtChar:
1687  cVal = (char) oXml.GetChildInt("Value");
1688  SetValue(cVal);
1689  break;
1690 
1691  case StdVtUChar:
1692  ucVal = (unsigned char) oXml.GetChildInt("Value");
1693  SetValue(ucVal);
1694  break;
1695 
1696  case StdVtUShort:
1697  usVal = (unsigned short) oXml.GetChildLong("Value");
1698  SetValue(usVal);
1699  break;
1700 
1701  case StdVtULong:
1702  ulVal = (unsigned long) oXml.GetChildLong("Value");
1703  SetValue(ulVal);
1704  break;
1705 
1706  case StdVtInt:
1707  iVal = oXml.GetChildInt("Value");
1708  SetValue(iVal);
1709  break;
1710 
1711  case StdVtUInt:
1712  uiVal = (unsigned int) oXml.GetChildLong("Value");
1713  SetValue(uiVal);
1714  break;
1715 
1716  case StdVtString:
1717  strVal = oXml.GetChildString("Value");
1718  SetValue(strVal);
1719  break;
1720 
1721  default:
1722  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1723  break;
1724  }
1725 
1726  oXml.OutOfElem(); //OutOf Variant Element
1727 }
1728 
1737 void CStdVariant::Save(CStdXml &oXml)
1738 {
1739  std::string strEmpty;
1740 
1741  oXml.AddChildElement("Variant");
1742  oXml.IntoElem(); //Into Variant Element
1743 
1744  std::string strVariantType = Std_ConstToVariantType(m_iVariantType);
1745  oXml.AddChildElement("VariantType", strVariantType);
1746 
1747  switch (m_iVariantType)
1748  {
1749  case StdVtEmpty:
1750  oXml.AddChildElement("Value", strEmpty);
1751  break;
1752 
1753  case StdVtShort:
1754  oXml.AddChildElement("Value", (long) *m_lpShort);
1755  break;
1756 
1757  case StdVtLong:
1758  oXml.AddChildElement("Value", *m_lpLong);
1759  break;
1760 
1761  case StdVtFloat:
1762  oXml.AddChildElement("Value", *m_lpFloat);
1763  break;
1764 
1765  case StdVtDouble:
1766  oXml.AddChildElement("Value", *m_lpDouble);
1767  break;
1768 
1769  case StdVtBool:
1770  oXml.AddChildElement("Value", STR(*m_lpBool));
1771  break;
1772 
1773  case StdVtChar:
1774  oXml.AddChildElement("Value", (int) *m_lpChar);
1775  break;
1776 
1777  case StdVtUChar:
1778  oXml.AddChildElement("Value", (int) *m_lpUChar);
1779  break;
1780 
1781  case StdVtUShort:
1782  oXml.AddChildElement("Value", (long) *m_lpUShort);
1783  break;
1784 
1785  case StdVtULong:
1786  oXml.AddChildElement("Value", (long) *m_lpULong);
1787  break;
1788 
1789  case StdVtInt:
1790  oXml.AddChildElement("Value", *m_lpInt);
1791  break;
1792 
1793  case StdVtUInt:
1794  oXml.AddChildElement("Value", (long) *m_lpUInt);
1795  break;
1796 
1797  case StdVtString:
1798  oXml.AddChildElement("Value", *m_lpString);
1799  break;
1800 
1801  default:
1802  THROW_PARAM_ERROR(Std_Err_lInvalidVariantType, Std_Err_strInvalidVariantType, "VariantType", m_iVariantType);
1803  break;
1804  }
1805 
1806  oXml.OutOfElem(); //OutOf Variant Element
1807 }
1808 
1809 } //StdUtils
StdUtils::Std_VariantTypeToConst
int Std_VariantTypeToConst(std::string strType)
Standard variant type to constant.
Definition: StdUtilFunctions.cpp:703
StdUtils::CStdVariant::~CStdVariant
virtual ~CStdVariant()
Destructor.
Definition: StdVariant.cpp:43
StdUtils::CStdVariant::GetUInt
unsigned int GetUInt(bool bConvert=true)
Gets an unsigned int.
Definition: StdVariant.cpp:1157
StdUtils::CStdVariant::GetUCharPtr
unsigned char * GetUCharPtr()
Gets the unsigned character pointer.
Definition: StdVariant.cpp:800
StdUtils::CStdVariant::GetNumericString
std::string GetNumericString()
Gets a string version of the value.
Definition: StdVariant.cpp:1257
StdUtils::CStdVariant::CStdVariant
CStdVariant()
Default constructor.
Definition: StdVariant.cpp:18
StdUtils::CStdVariant::GetString
std::string GetString(bool bConvert=true)
Gets a string version of the value.
Definition: StdVariant.cpp:1306
StdUtils::CStdVariant::GetBoolPtr
bool * GetBoolPtr()
Gets the bool pointer.
Definition: StdVariant.cpp:591
StdUtils::CStdVariant::GetUChar
unsigned char GetUChar(bool bConvert=true)
Gets an unsigned character.
Definition: StdVariant.cpp:747
StdUtils::CStdVariant::GetUShort
unsigned short GetUShort(bool bConvert=true)
Gets an unsigned short.
Definition: StdVariant.cpp:850
StdUtils::CStdVariant::GetUShortPtr
unsigned short * GetUShortPtr()
Gets the unsigned short pointer.
Definition: StdVariant.cpp:903
StdUtils::CStdXml::AddChildElement
virtual void AddChildElement(std::string strElementName)
Adds a child element to current element.
Definition: StdXml.cpp:799
StdUtils::CStdErrorInfo
Information about the standard error.
Definition: StdErrorInfo.h:19
StdUtils::CStdXml::IntoElem
virtual bool IntoElem()
Goes into the next element where the cursor is located.
Definition: StdXml.cpp:42
StdUtils::CStdVariant::GetULongPtr
unsigned long * GetULongPtr()
Gets the unsigned long pointer.
Definition: StdVariant.cpp:1005
StdUtils::CStdVariant::Reset
void Reset()
Resets the variant data.
Definition: StdVariant.cpp:82
StdUtils::CStdVariant::m_lpLong
long * m_lpLong
StdVtLong 4-byte signed int.
Definition: StdVariant.h:50
StdUtils::CStdVariant::GetDoublePtr
double * GetDoublePtr()
Gets the double pointer.
Definition: StdVariant.cpp:488
StdUtils::CStdVariant
Standard variant type.
Definition: StdVariant.h:37
StdUtils::CStdVariant::GetULong
unsigned long GetULong(bool bConvert=true)
Gets an unsigned long.
Definition: StdVariant.cpp:953
StdUtils::CStdXml::GetChildDouble
virtual double GetChildDouble(std::string strElementName)
Gets a double value from the element with the specified name.
Definition: StdXml.cpp:538
StdUtils::CStdVariant::m_lpUShort
unsigned short * m_lpUShort
StdVtUShort 2 byte unsigned int.
Definition: StdVariant.h:68
StdUtils::Std_ConstToVariantType
std::string Std_ConstToVariantType(int iType)
Standard constant to variant type.
Definition: StdUtilFunctions.cpp:750
StdUtils::CStdVariant::GetDouble
double GetDouble(bool bConvert=true)
Gets a double.
Definition: StdVariant.cpp:435
StdUtils::CStdVariant::GetBool
bool GetBool(bool bConvert=true)
Gets a bool.
Definition: StdVariant.cpp:538
StdUtils::CStdVariant::GetCharPtr
char * GetCharPtr()
Gets the character pointer.
Definition: StdVariant.cpp:697
StdUtils::CStdVariant::VariantTypeName
std::string VariantTypeName()
Gets the variant type name.
Definition: StdVariant.cpp:73
StdUtils::CStdVariant::GetLongPtr
long * GetLongPtr()
Gets the long pointer.
Definition: StdVariant.cpp:282
StdUtils::CStdXml::GetChildInt
virtual int GetChildInt(std::string strElementName)
Gets an integer value from the element with the specified name.
Definition: StdXml.cpp:456
StdUtils::CStdVariant::SetPtr
void SetPtr(short *lpVal)
Sets a value pointer.
Definition: StdVariant.cpp:212
StdUtils::CStdVariant::m_lpChar
char * m_lpChar
StdVtChar Char.
Definition: StdVariant.h:62
StdUtils::CStdVariant::SetValue
void SetValue(short Val)
Sets the value.
Definition: StdVariant.cpp:195
StdUtils::CStdVariant::Trace
virtual void Trace(std::ostream &oOs)
Traces this object to an output stream.
Definition: StdVariant.cpp:1573
StdUtils::CStdVariant::Load
virtual void Load(CStdXml &oXml)
Loads the variant.
Definition: StdVariant.cpp:1636
StdUtils::CStdVariant::GetShort
short GetShort(bool bConvert=true)
Gets a short value.
Definition: StdVariant.cpp:128
StdUtils::CStdXml
A standard xml manipulation class.
Definition: StdXml.h:19
StdUtils::CStdVariant::operator=
void operator=(CStdVariant &oVar)
= casting operator.
Definition: StdVariant.cpp:1463
StdUtils::CStdVariant::GetLong
long GetLong(bool bConvert=true)
Gets a long value.
Definition: StdVariant.cpp:230
StdUtils::CStdVariant::Clone
virtual CStdSerialize * Clone()
Makes a deep copy of this object.
Definition: StdVariant.cpp:1541
StdUtils::CStdVariant::m_lpString
std::string * m_lpString
StdVtString string.
Definition: StdVariant.h:80
StdUtils::CStdXml::GetChildString
virtual std::string GetChildString(std::string strElementName)
Gets a string value from the element with the specified name.
Definition: StdXml.cpp:307
StdUtils::CStdVariant::VariantType
int VariantType()
Gets the variant type.
Definition: StdVariant.cpp:62
StdUtils
Namespace for the standard utility objects.
Definition: MarkupSTL.cpp:19
StdUtils::CStdVariant::m_lpUInt
unsigned int * m_lpUInt
StdVtUInt 2 byte unsigned int.
Definition: StdVariant.h:77
StdUtils::Std_TraceMsg
void Std_TraceMsg(const int iLevel, std::string strMessage, std::string strSourceFile, int iSourceLine, bool bLogToFile, bool bPrintHeader)
Traces a message to the debugger window.
Definition: StdUtilFunctions.cpp:3137
StdUtils::CStdXml::GetChildBool
virtual bool GetChildBool(std::string strElementName)
Gets a bool value from the element with the specified name.
Definition: StdXml.cpp:699
StdUtils::CStdVariant::Copy
void Copy(CStdVariant &oVar)
Copies the given variant.
Definition: StdVariant.cpp:1406
StdUtils::CStdVariant::GetFloat
float GetFloat(bool bConvert=true)
Gets a float.
Definition: StdVariant.cpp:332
StdUtils::CStdVariant::m_lpInt
int * m_lpInt
StdVtInt 2 byte signed int.
Definition: StdVariant.h:74
StdUtils::CStdVariant::GetChar
char GetChar(bool bConvert=true)
Gets a character.
Definition: StdVariant.cpp:641
StdUtils::CStdVariant::m_lpFloat
float * m_lpFloat
StdVtFloat 4-byte real.
Definition: StdVariant.h:53
StdUtils::CStdVariant::m_lpBool
bool * m_lpBool
StdVtBool Boolean.
Definition: StdVariant.h:59
StdUtils::CStdVariant::m_lpDouble
double * m_lpDouble
StdVtDouble 8-byte real.
Definition: StdVariant.h:56
StdUtils::CStdXml::OutOfElem
virtual bool OutOfElem()
Goes out of the element where the cursor is located.
Definition: StdXml.cpp:56
StdUtils::CStdVariant::GetShortPtr
short * GetShortPtr()
Gets the short pointer.
Definition: StdVariant.cpp:180
StdUtils::CStdVariant::Save
virtual void Save(CStdXml &oXml)
Saves the variant.
Definition: StdVariant.cpp:1737
StdUtils::Std_CheckString
std::string Std_CheckString(std::string strVal)
Converts a string to upper case and trims it.
Definition: StdUtilFunctions.cpp:1793
StdUtils::CStdSerialize
Standard serialize class.
Definition: StdSerialize.h:20
StdUtils::CStdVariant::m_bCreatedVar
bool m_bCreatedVar
true if created variable
Definition: StdVariant.h:41
StdUtils::CStdVariant::GetIntPtr
int * GetIntPtr()
Gets the int pointer.
Definition: StdVariant.cpp:1107
StdUtils::CStdVariant::GetUIntPtr
unsigned int * GetUIntPtr()
Gets the unsigned int pointer.
Definition: StdVariant.cpp:1209
StdUtils::CStdVariant::m_lpUChar
unsigned char * m_lpUChar
StdVtUChar Unsigned char.
Definition: StdVariant.h:65
StdUtils::CStdVariant::GetInt
int GetInt(bool bConvert=true)
Gets an int.
Definition: StdVariant.cpp:1055
StdUtils::CStdVariant::m_lpShort
short * m_lpShort
StdVtShort 2-byte signed int.
Definition: StdVariant.h:47
StdUtils::CStdVariant::m_lpULong
unsigned long * m_lpULong
StdVtULong 4 byte unsigned int.
Definition: StdVariant.h:71
StdUtils::CStdXml::GetChildLong
virtual long GetChildLong(std::string strElementName)
Gets a long value from the element with the specified name.
Definition: StdXml.cpp:371
StdUtils::CStdVariant::m_iVariantType
int m_iVariantType
Variant type.
Definition: StdVariant.h:44
StdUtils::CStdXml::GetChildFloat
virtual float GetChildFloat(std::string strElementName)
Gets a float value from the element with the specified name.
Definition: StdXml.cpp:617
StdUtils::CStdVariant::GetStringPtr
std::string * GetStringPtr()
Gets the string pointer.
Definition: StdVariant.cpp:1358
StdUtils::CStdVariant::GetFloatPtr
float * GetFloatPtr()
Gets the float pointer.
Definition: StdVariant.cpp:385