cvariant.cpp

很好用的数据库连接组件

#include "stdafx.h"
#include "CVariant.h"

# if defined(_REENTRANT)
static MyMutexPool zc_thread_mutexpool;
# endif
static string i_temp  = "" ;

static const int ntypes = 12;//支持的类型数
//类型对应的名字
static const char *const type_map[ntypes] = {
  0,
  "bool",
  "ushort",
  "short",
  "uint",
  "int",
  "ulong",
  "long",
  "float",
  "double",
  "char*" ,
  "mydate"
};

CVariant::Private::Private ()//私有类的空构造函数
{
  typ = CVariant::Invalid;//将类型置为无效类型
}

CVariant::Private::Private (Private * d)//根据参数d的类型和值对当前类对象进行初始化
{
  switch (d->typ)
  {
  case CVariant::Invalid://无效类型
    break;
  case CVariant::Bool://Bool类型
    value.b = d->value.b;//记录Bool值
    break;
  case CVariant::UShort://UShort类型
    value.us = d->value.us;//记录UShort值
    break;
  case CVariant::Short://Short类型
    value.s = d->value.s;//记录Short值
    break;
  case CVariant::UInt://UInt类型
    value.ui = d->value.ui;//记录UInt值
    break;  
  case CVariant::Int://Int类型
    value.i = d->value.i;//记录Int值
    break;
  case CVariant::ULong://ULong类型
    value.ul = d->value.ul;//记录ULong值
    break;
  case CVariant::Long://Long类型
    value.l = d->value.l;//记录Long值
    break;
  case CVariant::Float://Float类型
    value.f = d->value.f;//记录Float值
    break;  
  case CVariant::Double://Double类型
    value.d = d->value.d;//记录Double值
    break;
  case CVariant::Pchar://Pchar类型
    value.ptr = new char [strlen ((char *) (d->value.ptr)) + 1];//分配字符串所需内存
    strcpy ((char *) (value.ptr), (char *) (d->value.ptr));//拷贝字符串
    break;
  case CVariant::mydate:
    value.date = new CDate_T(*(d->value.date)) ;
    break;
  }
  typ = d->typ;//类型拷贝
}



CVariant::Private::~Private ()
{
  clear ();//清除数据
}


void
CVariant::Private::clear ()
{
  switch (typ)
  {
  case CVariant::Pchar:
    delete[]value.ptr;//释放字符串内存
    value.ptr=NULL;
    break;
  case CVariant::mydate:
    delete value.date;//释放字符串内存
    value.date=NULL;
    break;
  case CVariant::Invalid:
  case CVariant::Bool:
  case CVariant::UShort:
  case CVariant::Short:
  case CVariant::UInt:
  case CVariant::Int:
  case CVariant::ULong:
  case CVariant::Long:
  case CVariant::Float:
  case CVariant::Double:
    break;
  }
}


CVariant::CVariant (const CVariant & p)//拷贝构造
{

  # if defined(_REENTRANT)
  ZcMutexLocker locker (zc_thread_mutexpool.get (d));
  # endif
  p.d->ref ();//增加当前值的引用
  d = p.d;//记录值地址
}



CVariant::CVariant ()//空构造
{
  d = new Private;//构造私有类
  d->typ = Invalid;//类型为无效类型
}

//用bool型构造CVariant类型
CVariant::CVariant (bool val)
{
  d = new Private;//构造私有类
  d->typ = Bool;//类型为Bool
  d->value.b = val;//拷贝值
}


//用unsigned short  类型构造CVariant类型
CVariant::CVariant (unsigned short val)
{
  d = new Private;//构造私有类
  d->typ = UShort;//类型为UShort
  d->value.us = val;//拷贝值
}

//用short类型构造CVariant类型
CVariant::CVariant (short val)
{
  d = new Private;//构造私有类
  d->typ = Short;//类型为Int
  d->value.s = val;//拷贝值
}

//用unsigned int 类型构造CVariant类型
CVariant::CVariant (unsigned int val)
{
  d = new Private;//构造私有类
  d->typ = UInt;//类型为UInt
  d->value.ui = val;//拷贝值
}

//用int 类型构造CVariant类型
CVariant::CVariant (int val)
{
  d = new Private;//构造私有类
  d->typ = Int;//类型为Int
  d->value.i = val;//拷贝值
}


//用unsigned long 类型构造CVariant类型
CVariant::CVariant (unsigned long val)
{
  d = new Private;//构造私有类
  d->typ = ULong;//类型为ULong
  d->value.ul = val;//拷贝值
}

//用Long 类型构造CVariant类型
CVariant::CVariant (long val)
{
  d = new Private;//构造私有类
  d->typ = Long;//类型为Long
  d->value.l = val;//拷贝值
}

//用float 类型构造CVariant类型
CVariant::CVariant (float val)
{
  d = new Private;//构造私有类
  d->typ = Float;//类型为Float
  d->value.f = val;//拷贝值
}

//用double构造CVariant类型
CVariant::CVariant (double val)
{
  d = new Private;//构造私有类
  d->typ = Double;//类型为Double
  d->value.d = val;//拷贝值
}

//用字符串构造CVariant类型
CVariant::CVariant (const char *val)
{
  d = new Private;//构造私有类
  d->typ = Pchar;//类型为Pchar
  if(val!=NULL)
  {
    d->value.ptr = new char [ strlen (val) + 1 ];//分配内存
    strcpy ((char *) (d->value.ptr), val);//字符串拷贝
  }
  else
  {
    d->value.ptr = NULL;
  }
}

CVariant::CVariant (const CDate_T & val)
{
  d = new Private;//构造私有类
  d->typ = mydate;//类型为Pchar
  d->value.date = new CDate_T( val );
}



CVariant::~CVariant ()
{
  # if defined(_REENTRANT)
  ZcMutexLocker locker (zc_thread_mutexpool.get (d));
  # endif
  if (d->deref ())//如果只有一个(自己)引用
  {
    delete d;//析构私有类
    d=NULL;
  }
}


//返回bool型值
bool
CVariant::toBool () const
{
  switch (d->typ)
  {
  case Bool://本身是bool无需转化
    return d->value.b;
  case UShort://UShort
    return d->value.us != 0;  
  case Short://Short
    return d->value.s != 0;
  case UInt://UInt
    return d->value.ui != 0;
  case Int://Int
    return d->value.i != 0;
  case ULong://ULong
    return d->value.ul != 0;
  case Long://Long
    return d->value.l != 0;
  case Float://Float
    return d->value.f != 0.0;//值为0.0则返回false  
  case Double://double
    return d->value.d != 0.0;//值为0.0则返回false
  default:
    return false;////返回false
  }
}


unsigned short CVariant::toUShort (bool * ok) const
{
  if (ok)
    *ok = canCast (UShort);//是否能够转化

  char * tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (unsigned short) d->value.b;	
  case UShort:
    return d->value.us;
  case Short:
    return (unsigned short) d->value.s;
  case UInt:
    return (unsigned short) d->value.ui;
  case Int:
    return (unsigned short) d->value.i;
  case ULong:
    return (unsigned short)d->value.ul;
  case Long:
    return (unsigned short) d->value.l;
  case Float:
    return (unsigned short) d->value.f;  
  case Double:
    return (unsigned short) d->value.d;
  case Pchar:
    return (unsigned short) strtol ((const char *) (d->value.ptr), &tmp, 10);
  default:
    return 0;
  }

}

short
CVariant::toShort (bool * ok) const
{
  if (ok)
    *ok = canCast (Short);//是否能够转化

  char *tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (short) d->value.b;	
  case UShort:
    return (short) d->value.us;
  case Short:
    return d->value.s;
  case UInt:
    return (short) d->value.ui;
  case Int:
    return (short) d->value.i;
  case ULong:
    return (short) d->value.ul;
  case Long:
    return (short) d->value.l;    
  case Float:
    return (short) d->value.f;  
  case Double:
    return (short) d->value.d;
  case Pchar:
    return (short) strtol ((const char *) (d->value.ptr), &tmp, 10);
  default:
    return 0;
  }
}



unsigned int CVariant::toUInt (bool * ok) const
{
  if (ok)
    *ok = canCast (UInt);//是否能够转化

  char * tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (unsigned int) d->value.b;
  case UShort:
    return (unsigned int)d->value.us;
  case Short:
    return (unsigned int) d->value.s;
  case UInt:
    return d->value.ui;
  case Int:
    return (unsigned int) d->value.i;    
  case ULong:
    return (unsigned int)d->value.ul;
  case Long:
    return (unsigned int) d->value.l;
  case Float:
    return (unsigned int) d->value.f;  
  case Double:
    return (unsigned int) d->value.d;
  case Pchar:
    return (unsigned int) strtol ((const char *) (d->value.ptr), &tmp, 10);
  default:
    return 0;
  }

}

int
CVariant::toInt (bool * ok) const
{
  if (ok)
    *ok = canCast (Int);//是否能够转化

  char *tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (int) d->value.b;
  case UShort:
    return (int) d->value.us;
  case Short:
    return (int)d->value.s;
  case UInt:
    return (int) d->value.ui;
  case Int:
    return d->value.i;    
  case ULong:
    return (int) d->value.ul;
  case Long:
    return (int) d->value.l;
  case Float:
    return (int) d->value.f;  
  case Double:
    return (int) d->value.d;
  case Pchar:
    return (int) strtol ((const char *) (d->value.ptr), &tmp, 10);
  default:
    return 0;
  }
}





unsigned long CVariant::toULong (bool * ok) const
{
  if (ok)
    *ok = canCast (ULong);//是否能够转化

  char * tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (unsigned long) d->value.b;
  case UShort:
    return (unsigned long) d->value.us;
  case Short:
    return (unsigned long) d->value.s;
  case UInt:
    return (unsigned long) d->value.ui;
  case Int:
    return (unsigned long) d->value.i;
  case ULong:
    return d->value.ul;
  case Long:
    return (unsigned long) d->value.l; 
  case Float:
    return (unsigned long) d->value.f;
  case Double:
    return (unsigned long) d->value.d;
  case Pchar:
    return (unsigned long) strtol ((const char *) (d->value.ptr), &tmp, 10);
  default:
    return 0;
  }

}

long
CVariant::toLong (bool * ok) const
{
  if (ok)
    *ok = canCast (Long);//是否能够转化

  char *tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (long) d->value.b;
  case UShort:
    return (long) d->value.us;
  case Short:
    return (long) d->value.s;
  case UInt:
    return (long) d->value.ui;
  case Int:
    return (long) d->value.i;    
  case ULong:
    return (long) d->value.ul;
  case Long:
    return d->value.l;
  case Float:
    return (long) d->value.f;
  case Double:
    return (long) d->value.d;
  case Pchar:
    return (long) strtol ((const char *) (d->value.ptr), &tmp, 10);
  default:
    return 0;
  }
}

float
CVariant::toFloat (bool * ok) const
{
  if (ok)
    *ok = canCast (Float);//是否能够转化

  char *tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (float) d->value.b;
  case UShort:
    return (float) d->value.us;
  case Short:
    return (float) d->value.s;
  case UInt:
    return (float) d->value.ui;
  case Int:
    return (float) d->value.i;
  case ULong:
    return (float) d->value.ul;
  case Long:
    return (float) d->value.l;
  case Float:
    return d->value.f;
  case Double:
    return (float)d->value.d;
  case Pchar:
    return (float) strtod ((const char *) (d->value.ptr), &tmp);
  default:
    return 0.0;
  }
}

double
CVariant::toDouble (bool * ok) const
{
  if (ok)
    *ok = canCast (Double);//是否能够转化

  char *tmp;
  switch (d->typ)//不同类型不同处理
  {
  case Bool:
    return (double) d->value.b;
  case UShort:
    return (double) d->value.us;
  case Short:
    return (double) d->value.s;
  case UInt:
    return (double) d->value.ui;
  case Int:
    return (double) d->value.i;
  case ULong:
    return (double) d->value.ul;
  case Long:
    return (double) d->value.l;    
  case Float:
    return (double) d->value.f;  
  case Double:
    return d->value.d;
  case Pchar:
    return (double) strtod ((const char *) (d->value.ptr), &tmp);
  default:
    return 0.0;
  }
}

const char *
CVariant::toPchar (bool * ok) const
{
  # if defined(_REENTRANT)
  ZcMutexLocker locker (zc_thread_mutexpool.get (&i_temp));
  # endif

  if (ok)
    *ok = canCast (Pchar);//是否能够转化
  
  char cTemp[64];
  switch (d->typ)//不同类型不同处理
  {
  case UShort:
    sprintf (cTemp, "%u", d->value.us);
    i_temp = cTemp ;
    return i_temp.c_str();
  case Short:
    sprintf (cTemp, "%d", d->value.s);
    i_temp=cTemp;
    return i_temp.c_str();
  case UInt:
    sprintf (cTemp, "%u", d->value.ui);
    i_temp=cTemp;
    return i_temp.c_str();
  case Int:
    sprintf (cTemp, "%d", d->value.i);