开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网格计算 > 查看源码
VariantEx.cpp
资源名称：fmailstable.rar　[点击查看]
上传用户：maryhy001
上传日期：2007-05-02
资源大小：2317k
文件大小：7k
源码类别：

网格计算

开发平台：

Visual C++

VariantEx.cpp：源码内容
  1. #include "stdafx.h"
  2. #include ".VariantEx.h"
  5. //constructor procedure
  6. CVariantEx::CVariantEx()
  7. {
  8. this->m_var.Clear();
  9. }
  11. //constructor procedure
  12. CVariantEx::CVariantEx(_variant_t &vt)
  13. {
  14. try{
  15. if( this->Clear() ){
  16. this->m_var = vt;
  17. }
  18. }
  19. catch(_com_error e){
  20. //throw e.ErrorMessage();
  21. }
  22. }
  24. //constructor procedure
  25. CVariantEx::CVariantEx(CVariantEx &var)
  26. {
  27. this->m_var = var.get_variant_t();
  28. }
  30. CVariantEx::CVariantEx(const bool bVar)
  31. {
  32. _variant_t v(bVar);
  33. this->m_var = v;
  34. }
  36. CVariantEx::CVariantEx(const long nVar)
  37. {
  38. _variant_t v(nVar);
  39. this->m_var = v;
  40. }
  42. CVariantEx::CVariantEx(const double dVar)
  43. {
  44. _variant_t v(dVar);
  45. this->m_var = v;
  46. }
  48. CVariantEx::CVariantEx(LPCSTR lpszVar)
  49. {
  50. _variant_t v(lpszVar);
  51. this->m_var = v;
  52. }
  54. //operator "=" override 
  55. CVariantEx& CVariantEx::operator=(_variant_t &vt)
  56. {
  57. this->m_var = vt;
  58. return (*this);
  59. }
  61. //operator "=" override 
  62. CVariantEx& CVariantEx::operator=(CVariantEx &var)
  63. {
  64. this->m_var = var.get_variant_t();
  65. return (*this);
  66. }
  68. CVariantEx& CVariantEx::operator=(const bool bVar)
  69. {
  70. _variant_t v(bVar);
  71. this->m_var = v;
  73. return (*this);
  74. }
  76. CVariantEx& CVariantEx::operator=(const long nVar)
  77. {
  78. _variant_t v(nVar);
  79. this->m_var = v;
  81. return (*this);
  82. }
  84. CVariantEx& CVariantEx::operator=(const double dVar)
  85. {
  86. _variant_t v(dVar);
  87. this->m_var = v;
  89. return (*this);
  90. }
  92. CVariantEx& CVariantEx::operator=(LPCSTR lpszVar)
  93. {
  94. _variant_t v(lpszVar);
  95. this->m_var = v;
  97. return (*this);
  98. }
  100. //destructor procedure
  101. CVariantEx::~CVariantEx()
  102. {
  103. this->Clear();
  104. }
  106. //determine the var whether is null
  107. bool CVariantEx::IsNull()
  108. {
  109. //if you write "this->m_var == NULL" 
  110. //then the compiler can warn syntax error
  111. return (this->m_var.vt == VT_NULL);
  112. }
  114. //clear the var value
  115. bool CVariantEx::Clear()
  116. {
  117. if( this->IsNull() ){
  118. return true;
  119. }
  120. else{
  121. this->m_var.Clear();
  122. return true;
  123. }
  124. }
  126. //get the variant type
  127. VARTYPE_ENUM CVariantEx::getVarType()
  128. {
  129. if(this->IsNull()){
  130. throw "variant is null!!!";
  131. }
  133. switch(this->m_var.vt) {
  134. case VT_BSTR:
  135. case VT_LPSTR:
  136. case VT_LPWSTR:
  137. return VTE_STRING;
  139. case VT_I2:
  140. return VTE_SHORT;
  142. case VT_I8:
  143. return VTE_LONG;
  145. case VT_VOID:
  146. case VT_INT:
  147. case VT_I4:
  148. return VTE_INT;
  150. case VT_UI2:
  151. return VTE_UNSHORT;
  153. case VT_UINT:
  154. case VT_UI4:
  155. return VTE_UNINT;
  157. case VT_UI8:
  158. return VTE_ULINT;
  160. case VT_R4:
  161. return VTE_FLOAT;
  163. case VT_DECIMAL:
  164. return VTE_DECIMAL;
  166. case VT_R8:
  167. return VTE_DOUBLE;
  169. case VT_BOOL:
  170. return VTE_BOOL;
  172. case VT_DATE: 
  173. return VTE_DATETIME;
  175. case VT_NULL:
  176. return VTE_NULL;
  178. case VT_EMPTY:
  179. return VTE_EMPTY;
  181. case VT_UNKNOWN:
  182. default:
  183. return VTE_UNKNOWN;
  184. }
  185. }
  187. //get the variant value
  188. _variant_t& CVariantEx::get_variant_t()
  189. {
  190. return this->m_var;
  191. }
  193. //######################################################
  195. //convert to string type
  196. string CVariantEx::AsString()
  197. {
  198. string strRet = "";
  199. if(this->IsNull()){
  200. return strRet;
  201. //throw "variant is null!!!";
  202. }
  203. char szInt[64],
  204. szDT[MAX_DATE_SIZE + MAX_TIME_SIZE];
  206. strRet.erase();
  207. memset(szInt, 0x0, sizeof(szInt));
  209. switch(this->getVarType()) {
  210. case VTE_STRING:
  211. strRet = (LPCTSTR)(_bstr_t)this->m_var;
  212. break;
  214. case VTE_INT:
  215. itoa(this->m_var.intVal, szInt, 10);
  216. break;
  218. case VTE_SHORT:
  219. itoa(this->m_var.iVal, szInt, 10);
  220. break;
  222. case VTE_LONG:
  223. ltoa(this->m_var.lVal, szInt, 10);
  224. break;
  226. case VTE_UNSHORT:
  227. itoa(this->m_var.uiVal, szInt, 10);
  228. break;
  230. case VTE_UNINT:
  231. ultoa(this->m_var.uintVal, szInt, 10);
  232. break;
  234. case VTE_ULINT:
  235. ultoa(this->m_var.ulVal, szInt, 10);
  236. break;
  238. //real type(%.4f format)
  239. case VTE_FLOAT:
  240. case VTE_DECIMAL:
  241. sprintf((char*)&szInt[0], "%.4f", this->m_var.fltVal);
  242. break;
  244. //real type(%.8f format)
  245. case VTE_DOUBLE:
  246. sprintf((char*)&szInt[0], "%.8f", this->m_var.dblVal);
  247. break;
  249. case VTE_BOOL:
  250. if(this->AsBool())
  251. strcpy((char*)&szInt[0], "True");
  252. else
  253. strcpy((char*)&szInt[0], "False");
  254. break;
  256. case VTE_DATETIME:
  257. {
  258. try{
  259. CDateTimeEx dtDateTime = this->AsDateTime();
  260. dtDateTime.AsDTString(szDT);
  261. strRet = strRet + szDT;
  262. }
  263. catch(std::exception e){
  264. throw e.what();
  265. }
  266. }
  267. break;
  269. case VTE_NULL:
  270. strRet = "NULL";
  271. break;
  273. case VTE_UNKNOWN:
  274. strRet = "UNKNOWN";
  275. break;
  277. case VTE_EMPTY:
  278. break;
  280. case VTE_BLOB:
  281. case VTE_BLOB_OBJECT:
  282. strRet = "BLOB";
  283. break;
  285. case VTE_TEXT:
  286. strRet = "TEXT";
  287. break;
  289. default:
  290. throw "couldn't convert this variant to string value!!!";
  291. }
  292. strRet = strRet + szInt;
  293. return strRet;
  294. }
  296. //convert to boolean type
  297. bool CVariantEx::AsBool()
  298. {
  299. if(this->IsNull()){
  300. throw "variant is null!!!";
  301. }
  302. switch(this->getVarType()) {
  303. case VTE_BOOL:
  304. return (0 != this->m_var.lVal) ? true: false;
  306. case VTE_UNSHORT:
  307. return (this->m_var.uiVal != 0) ? true:false; 
  309. case VTE_UNINT:
  310. return (this->m_var.uintVal != 0) ? true:false; 
  312. case VTE_ULINT:
  313. return (this->m_var.ulVal != 0) ? true:false;
  315. default:
  316. throw "couldn't convert this variant to boolean value!!!";
  317. }
  318. }
  320. //convert to integer type
  321. int   CVariantEx::AsInteger()
  322. {
  323. if(this->IsNull()){
  324. throw "variant is null!!!";
  325. }
  326. /////////////////////////////////
  327. switch(this->getVarType()) {
  329. case VTE_INT:
  330. return (this->m_var.intVal);
  332. case VTE_SHORT:
  333. return (this->m_var.iVal);
  335. case VTE_LONG:
  336. return (this->m_var.lVal);
  338. case VTE_UNSHORT:
  339. return (this->m_var.uiVal);
  341. case VTE_UNINT:
  342. return (this->m_var.uintVal);
  344. case VTE_ULINT:
  345. return (this->m_var.ulVal);
  347. default:
  348. throw "couldn't convert this variant to int value!!!";
  349. }
  350. }
  352. //convert to real type
  353. double CVariantEx::AsReal()
  354. {
  355. if(this->IsNull()){
  356. throw "variant is null!!!";
  357. }
  358. /////////////////////////////////
  359. switch(this->getVarType()) {
  360. case VTE_FLOAT:
  361. return (this->m_var.fltVal);
  363. case VTE_DECIMAL:
  364. {
  365. char szDecimal[32];
  366. memset(szDecimal, 0x0, sizeof(szDecimal));
  367. sprintf(szDecimal, "%.4f", this->m_var.decVal);
  369. return (atof(szDecimal));
  370. }
  372. case VTE_DOUBLE:
  373. return (this->m_var.dblVal);
  375. default:
  376. throw "couldn't convert this variant to double value!!!";
  377. }
  378. }
  380. //convert to datetime type
  381. CDateTimeEx CVariantEx::AsDateTime()
  382. {
  383. if(this->IsNull()){
  384. throw "variant is null!!!";
  385. }
  386. /////////////////////////////////
  387. DATE dtTag = this->m_var.date;
  388. try{
  389. CDateTimeEx dtDateTime(dtTag);
  390. return dtDateTime;
  391. }
  392. catch(std::exception e){
  393. throw e.what();
  394. }
  395. }