variant.cpp.bak

网络socket,IO,线程池

#include "stdafx.h"

#pragma warning(disable:4786)

#include <memory>
#include<sstream> 
#include <string>
using namespace std;

#include "Variant.h"
#include "Property.h"

CVariant::CVariant():m_nType(TYPE_NONE),m_data()
{
}
CVariant::~CVariant()
{
	Empty();
}

void CVariant::Empty()
{
	switch(m_nType)
	{
	case TYPE_NONE:
		break;
	case TYPE_INT:
		m_data.m_nValue = 0;
		break;
	case TYPE_FLOAT:
		m_data.m_fValue = 0.0;
		break;
	case TYPE_STR:
		delete m_data.m_pStrValue;
		m_data.m_pStrValue = NULL;
		break;
	case TYPE_PROPERTY:		
		delete m_data.m_pProperty;
		m_data.m_pProperty = NULL;
		break;
	case TYPE_TIME:
		delete m_data.m_pTime;
		m_data.m_pTime = NULL;
		break;
	default:
		throw MException(ERR_CVARIANTAS,"void CVariant::Empty()");
	}
	m_nType = TYPE_NONE;
}
	
CVariant::CVariant(const CVariant& var):m_nType(TYPE_NONE)
{
	Assign(var);	
}

CVariant::CVariant(int nValue):m_nType(TYPE_NONE)
{
	Assign(nValue);
}

CVariant::CVariant(float fValue):m_nType(TYPE_NONE)
{
	Assign(fValue);
}

CVariant::CVariant(const char* szString):m_nType(TYPE_NONE)
{
	Assign(szString);
}
CVariant::CVariant(const string& strString):m_nType(TYPE_NONE)
{
	Assign(strString);
}
CVariant::CVariant(const CProperty& property):m_nType(TYPE_NONE)
{
	Assign(property);
}
CVariant::CVariant(const CTime& time):m_nType(TYPE_NONE)
{
	Assign(time);
}

const CVariant& CVariant::Assign(const CVariant& var)
{
	switch(var.m_nType)
	{
		case	TYPE_NONE:
			Empty();
			break;
		case	TYPE_INT:
			Assign(var.AsInteger());
			break;
		case	TYPE_STR:
			Assign(var.AsString());
			break;
		case	TYPE_FLOAT:
			Assign(var.AsFloat());
			break;
		case	TYPE_PROPERTY:
			Assign(var.AsProperty());
			break;
		case	TYPE_TIME:
			Assign(var.AsTime());
			break;
		default:
			throw MException(ERR_CASE_DEFAULT,"const CVariant& CVariant::Assign(const CVariant& val)");
			break;
	}
	return	*this;
}

const CVariant& CVariant::Assign(int nValue)
{
	Empty();
	m_nType = TYPE_INT;
	m_data.m_nValue = nValue;
	return *this;
}
const CVariant& CVariant::Assign(float fValue)
{
	Empty();
	m_nType = TYPE_FLOAT;
	m_data.m_fValue = fValue;
	return *this;
}
const CVariant& CVariant::Assign(const char* szString)
{
	auto_ptr<string>	au_str(new string(szString));
	Empty();
	m_nType = TYPE_STR;
	m_data.m_pStrValue = au_str.get();
	au_str.release();
	return	*this;
}
const CVariant& CVariant::Assign(const string& strString)
{
	auto_ptr<string>	au_str(new string(strString));
	Empty();
	m_nType = TYPE_STR;
	m_data.m_pStrValue = au_str.get();
	au_str.release();
	return	*this;
}
const CVariant& CVariant::Assign(const CProperty& property)
{
	auto_ptr<CProperty>	au_str(new CProperty(property));
	Empty();
	m_nType = TYPE_PROPERTY;
	m_data.m_pProperty = au_str.get();
	au_str.release();
	return	*this;
}
const CVariant& CVariant::Assign(const CTime& time)
{
	auto_ptr<CTime>	au_str(new CTime(time));
	Empty();
	m_nType = TYPE_TIME;
	m_data.m_pTime = au_str.get();
	au_str.release();
	return	*this;
}

int CVariant::AsInteger() const
{
	if(m_nType == TYPE_INT)
		return m_data.m_nValue;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsInteger()");
}
float  CVariant::AsFloat()const
{
	if(m_nType == TYPE_FLOAT)
		return m_data.m_fValue;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsFloat()");
}
const string& CVariant::AsString() const
{
	if(m_nType == TYPE_STR)
		return *m_data.m_pStrValue;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsString()");
}
const CProperty& CVariant::AsProperty() const
{
	if(m_nType == TYPE_PROPERTY)
		return *m_data.m_pProperty;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsProperty()");
}
const CTime& CVariant::AsTime() const
{
	if(m_nType == TYPE_TIME)
		return *m_data.m_pTime;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsTime()");
}

int& CVariant::AsRefInteger()
{
	if(m_nType == TYPE_INT)
		return m_data.m_nValue;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsInteger()");
}
float&  CVariant::AsRefFloat()
{
	if(m_nType == TYPE_FLOAT)
		return m_data.m_fValue;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsFloat()");
}
string& CVariant::AsRefString()
{
	if(m_nType == TYPE_STR)
		return *m_data.m_pStrValue;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsString()");
}
CProperty& CVariant::AsRefProperty()
{
	if(m_nType == TYPE_PROPERTY)
		return *m_data.m_pProperty;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsProperty()");
}

CTime& CVariant::AsRefTime()
{
	if(m_nType == TYPE_TIME)
		return *m_data.m_pTime;
	throw	MException(ERR_CVARIANTAS,"int CVariant::AsTime()");
}

string & CVariant::Appen2String(string & str) const
{
	stringstream tmpStream;
	CString s;
	switch(m_nType)
	{
	case TYPE_NONE:
		str += "(null)";
		break;
	case TYPE_INT:
		tmpStream<<m_data.m_nValue;
		str += tmpStream.str();
		break;
	case TYPE_FLOAT:
		tmpStream<<m_data.m_fValue;
		str += tmpStream.str();
		break;
	case TYPE_STR:
		str += *m_data.m_pStrValue;
		break;

	case TYPE_PROPERTY:
		m_data.m_pProperty->Appen2String(str);
		break;
	case TYPE_TIME:
		s = m_data.m_pTime->Format("%Y-%m-%d %H:%M:%S");
		str += s.operator LPCTSTR ( );
		break;
	default:
		throw MException(EINVAL,"Compare two TVariants Error, bad type");
	}
	return str;
}


int	CVariant::IsEqual(const CVariant& var) const 
{
	if(m_nType != var.m_nType)
		throw	MException(ERR_CVARIANTEUQAL,"int	CVariant::IsEqual(const CVariant& var) const ");
		
	CTimeSpan span;	
	switch(m_nType)
	{
		case	TYPE_NONE:
			return 0;
			break;
		case	TYPE_INT:
			return m_data.m_nValue - var.m_data.m_nValue;
			break;
		// In fact float should not be done so
		case	TYPE_FLOAT:
			return m_data.m_fValue - var.m_data.m_fValue;
			break;
		case	TYPE_STR:
			return m_data.m_pStrValue->compare(*var.m_data.m_pStrValue);
			break;
		case 	TYPE_PROPERTY:
			throw	MException(ERR_CVARIANTEUQAL,"int	CVariant::IsEqual(const CVariant& var) const ");
			break;
		case	TYPE_TIME:
			span = *m_data.m_pTime - *var.m_data.m_pTime;
			return span.GetTotalSeconds();
			break;
		default:
			throw	MException(ERR_CVARIANTEUQAL,"int	CVariant::IsEqual(const CVariant& var) const ");
			break;
	}
}