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

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

网格计算

开发平台：

Visual C++

VariantEx.cpp：源码内容
  1. #include ".VariantEx.h"
  3. //constructor procedure
  4. CVariantEx::CVariantEx()
  5. {
  6. this->m_var.Clear();
  7. }
  9. //constructor procedure
  10. CVariantEx::CVariantEx(_variant_t &vt)
  11. {
  12. try{
  13. if( this->Clear() ){
  14. this->m_var = vt;
  15. }
  16. }
  17. catch(_com_error e){
  18. //throw e.ErrorMessage();
  19. }
  20. }
  22. //constructor procedure
  23. CVariantEx::CVariantEx(CVariantEx &var)
  24. {
  25. this->m_var = var.get_variant_t();
  26. }
  28. CVariantEx::CVariantEx(const bool bVar)
  29. {
  30. _variant_t v(bVar);
  31. this->m_var = v;
  32. }
  34. CVariantEx::CVariantEx(const long nVar)
  35. {
  36. _variant_t v(nVar);
  37. this->m_var = v;
  38. }
  40. CVariantEx::CVariantEx(const double dVar)
  41. {
  42. _variant_t v(dVar);
  43. this->m_var = v;
  44. }
  46. CVariantEx::CVariantEx(LPCSTR lpszVar)
  47. {
  48. _variant_t v(lpszVar);
  49. this->m_var = v;
  50. }
  52. //operator "=" override 
  53. CVariantEx& CVariantEx::operator=(_variant_t &vt)
  54. {
  55. this->m_var = vt;
  56. return (*this);
  57. }
  59. //operator "=" override 
  60. CVariantEx& CVariantEx::operator=(CVariantEx &var)
  61. {
  62. this->m_var = var.get_variant_t();
  63. return (*this);
  64. }
  66. CVariantEx& CVariantEx::operator=(const bool bVar)
  67. {
  68. _variant_t v(bVar);
  69. this->m_var = v;
  71. return (*this);
  72. }
  74. CVariantEx& CVariantEx::operator=(const long nVar)
  75. {
  76. _variant_t v(nVar);
  77. this->m_var = v;
  79. return (*this);
  80. }
  82. CVariantEx& CVariantEx::operator=(const double dVar)
  83. {
  84. _variant_t v(dVar);
  85. this->m_var = v;
  87. return (*this);
  88. }
  90. CVariantEx& CVariantEx::operator=(LPCSTR lpszVar)
  91. {
  92. _variant_t v(lpszVar);
  93. this->m_var = v;
  95. return (*this);
  96. }
  98. //destructor procedure
  99. CVariantEx::~CVariantEx()
  100. {
  101. this->Clear();
  102. }
  104. //determine the var whether is null
  105. bool CVariantEx::IsNull()
  106. {
  107. //if you write "this->m_var == NULL" 
  108. //then the compiler can warn syntax error
  109. return (this->m_var.vt == VT_NULL);
  110. }
  112. //clear the var value
  113. bool CVariantEx::Clear()
  114. {
  115. if( this->IsNull() ){
  116. return true;
  117. }
  118. else{
  119. this->m_var.Clear();
  120. return true;
  121. }
  122. }
  124. //get the variant type
  125. VARTYPE_ENUM CVariantEx::getVarType()
  126. {
  127. if(this->IsNull()){
  128. throw "variant is null!!!";
  129. }
  131. switch(this->m_var.vt) {
  132. case VT_BSTR:
  133. case VT_LPSTR:
  134. case VT_LPWSTR:
  135. return VTE_STRING;
  137. case VT_I2:
  138. return VTE_SHORT;
  140. case VT_I8:
  141. return VTE_LONG;
  143. case VT_VOID:
  144. case VT_INT:
  145. case VT_I4:
  146. return VTE_INT;
  148. case VT_UI2:
  149. return VTE_UNSHORT;
  151. case VT_UINT:
  152. case VT_UI4:
  153. return VTE_UNINT;
  155. case VT_UI8:
  156. return VTE_ULINT;
  158. case VT_R4:
  159. return VTE_FLOAT;
  161. case VT_DECIMAL:
  162. return VTE_DECIMAL;
  164. case VT_R8:
  165. return VTE_DOUBLE;
  167. case VT_BOOL:
  168. return VTE_BOOL;
  170. case VT_DATE: 
  171. return VTE_DATETIME;
  173. case VT_NULL:
  174. return VTE_NULL;
  176. case VT_EMPTY:
  177. return VTE_EMPTY;
  179. case VT_UNKNOWN:
  180. default:
  181. return VTE_UNKNOWN;
  182. }
  183. }
  185. //get the variant value
  186. _variant_t& CVariantEx::get_variant_t()
  187. {
  188. return this->m_var;
  189. }
  191. //######################################################
  193. //convert to string type
  194. string CVariantEx::AsString()
  195. {
  196. string strRet = "NULL";
  197. if(this->IsNull()){
  198. return strRet;
  199. //throw "variant is null!!!";
  200. }
  201. char szInt[64],
  202. szDT[MAX_DATE_SIZE + MAX_TIME_SIZE];
  204. strRet.erase();
  205. memset(szInt, 0x0, sizeof(szInt));
  207. switch(this->getVarType()) {
  208. case VTE_STRING:
  209. strRet = (LPCTSTR)(_bstr_t)this->m_var;
  210. break;
  212. case VTE_INT:
  213. itoa(this->m_var.intVal, szInt, 10);
  214. break;
  216. case VTE_SHORT:
  217. itoa(this->m_var.iVal, szInt, 10);
  218. break;
  220. case VTE_LONG:
  221. ltoa(this->m_var.lVal, szInt, 10);
  222. break;
  224. case VTE_UNSHORT:
  225. itoa(this->m_var.uiVal, szInt, 10);
  226. break;
  228. case VTE_UNINT:
  229. ultoa(this->m_var.uintVal, szInt, 10);
  230. break;
  232. case VTE_ULINT:
  233. ultoa(this->m_var.ulVal, szInt, 10);
  234. break;
  236. //real type(%.4f format)
  237. case VTE_FLOAT:
  238. case VTE_DECIMAL:
  239. sprintf((char*)&szInt[0], "%.4f", this->m_var.fltVal);
  240. break;
  242. //real type(%.8f format)
  243. case VTE_DOUBLE:
  244. sprintf((char*)&szInt[0], "%.8f", this->m_var.dblVal);
  245. break;
  247. case VTE_BOOL:
  248. if(this->AsBool())
  249. strcpy((char*)&szInt[0], "True");
  250. else
  251. strcpy((char*)&szInt[0], "False");
  252. break;
  254. case VTE_DATETIME:
  255. {
  256. try{
  257. CDateTimeEx dtDateTime = this->AsDateTime();
  258. dtDateTime.AsDTString(szDT);
  259. strRet = strRet + szDT;
  260. }
  261. catch(std::exception e){
  262. throw e.what();
  263. }
  264. }
  265. break;
  267. case VTE_NULL:
  268. strRet = "NULL";
  269. break;
  271. case VTE_UNKNOWN:
  272. strRet = "UNKNOWN";
  273. break;
  275. case VTE_EMPTY:
  276. break;
  278. case VTE_BLOB:
  279. case VTE_BLOB_OBJECT:
  280. strRet = "BLOB";
  281. break;
  283. case VTE_TEXT:
  284. strRet = "TEXT";
  285. break;
  287. default:
  288. throw "couldn't convert this variant to string value!!!";
  289. }
  290. strRet = strRet + szInt;
  291. return strRet;
  292. }
  294. //convert to boolean type
  295. bool CVariantEx::AsBool()
  296. {
  297. if(this->IsNull()){
  298. throw "variant is null!!!";
  299. }
  300. switch(this->getVarType()) {
  301. case VTE_BOOL:
  302. return (0 != this->m_var.lVal) ? true: false;
  304. case VTE_UNSHORT:
  305. return (this->m_var.uiVal != 0) ? true:false; 
  307. case VTE_UNINT:
  308. return (this->m_var.uintVal != 0) ? true:false; 
  310. case VTE_ULINT:
  311. return (this->m_var.ulVal != 0) ? true:false;
  313. default:
  314. throw "couldn't convert this variant to boolean value!!!";
  315. }
  316. }
  318. //convert to integer type
  319. int   CVariantEx::AsInteger()
  320. {
  321. if(this->IsNull()){
  322. throw "variant is null!!!";
  323. }
  324. /////////////////////////////////
  325. switch(this->getVarType()) {
  327. case VTE_INT:
  328. return (this->m_var.intVal);
  330. case VTE_SHORT:
  331. return (this->m_var.iVal);
  333. case VTE_LONG:
  334. return (this->m_var.lVal);
  336. case VTE_UNSHORT:
  337. return (this->m_var.uiVal);
  339. case VTE_UNINT:
  340. return (this->m_var.uintVal);
  342. case VTE_ULINT:
  343. return (this->m_var.ulVal);
  345. default:
  346. throw "couldn't convert this variant to int value!!!";
  347. }
  348. }
  350. //convert to real type
  351. double CVariantEx::AsReal()
  352. {
  353. if(this->IsNull()){
  354. throw "variant is null!!!";
  355. }
  356. /////////////////////////////////
  357. switch(this->getVarType()) {
  358. case VTE_FLOAT:
  359. return (this->m_var.fltVal);
  361. case VTE_DECIMAL:
  362. {
  363. char szDecimal[32];
  364. memset(szDecimal, 0x0, sizeof(szDecimal));
  365. sprintf(szDecimal, "%.4f", this->m_var.decVal);
  367. return (atof(szDecimal));
  368. }
  370. case VTE_DOUBLE:
  371. return (this->m_var.dblVal);
  373. default:
  374. throw "couldn't convert this variant to double value!!!";
  375. }
  376. }
  378. //convert to datetime type
  379. CDateTimeEx CVariantEx::AsDateTime()
  380. {
  381. if(this->IsNull()){
  382. throw "variant is null!!!";
  383. }
  384. /////////////////////////////////
  385. DATE dtTag = this->m_var.date;
  386. try{
  387. CDateTimeEx dtDateTime(dtTag);
  388. return dtDateTime;
  389. }
  390. catch(std::exception e){
  391. throw e.what();
  392. }
  393. }