Data Holders (Header)

Link to: source code | other data directory

This class manages data storage in tables for the Goldenseal accounting software,
project management software and construction project estimating software.

class CHolder
{
public:
CHolder() {}
virtual ~CHolder() {}

virtual CHolder *Clone() const = 0;
virtual CTextString GetCString() const = 0;
virtual void SetCString(const CTextString &inString) = 0;

virtual SInt32 GetValue() const = 0;
virtual void SetValue(const SInt32 inValue) = 0;

virtual NeoSize GetFileLength() const = 0;

// the following routines are for subclasses to override
// to implement conversion of the holder's data frmo one type to another
// the default methods do no conversion
virtual Boolean ConvertValueTo(void */*aValue*/,
const SInt32 /*aType*/) const { return false; }
virtual Boolean ConvertValueFrom(const void */*aValue*/,
const SInt32 /*aType*/) { return false; }

virtual void WriteData(CNeoStream &/*stream*/) const {}
virtual void ReadData(CNeoStream &/*stream*/) {}
};
/*************************************************************************************/
// CDataHolder is also abstract, but takes CHolder one step further
// by allowing for a data type, via a template
template <class DataType>
class CDataHolder : public CHolder
{
public:
CDataHolder() {}
CDataHolder(const DataType &inData) { mData = inData; }
CDataHolder(const CDataHolder<DataType> &inHolder) { mData = inHolder.mData; }
virtual ~CDataHolder() {}

virtual CHolder *Clone() const { return NEW CDataHolder<DataType>(*this); }
virtual CTextString GetCString() const
{
CTextString cstring;
ConvertValueTo(&cstring, type_cstring);
return cstring;
}
virtual void SetCString(const CTextString &inString)
{ ConvertValueFrom(&inString, type_cstring); }

// the below doesn't work with CWP 5, since we can't
// do a value cast in CTextString. Subclasses must override TCS 7/31/00
virtual SInt32 GetValue() const { return 0; }
virtual void SetValue(const SInt32 inValue) { mData = SInt32(inValue); }

virtual DataType GetData() const { return mData; }
virtual void SetData(const DataType inData) { mData = inData; }

virtual NeoSize GetFileLength() const { return sizeof(mData); }

virtual void WriteData(CNeoStream &stream) const
{ stream.WriteChunk(&mData, sizeof(mData)); }
virtual void ReadData(CNeoStream &stream)
{ stream.ReadChunk(&mData, sizeof(mData)); }

CDataHolder<DataType>& operator=(const CDataHolder<DataType> &inDataHolder)
{
mData = inDataHolder.mData;
return *this;
}
protected:

DataType mData;
};/*************************************************************************************/
// the following class contains the data for a clairvoyant field
class SCVData
{
public:

SCVData() { id = 0; }
~SCVData() {}

SCVData &operator=(const SInt32 inValue) { id = inValue; return *this; }
SCVData &operator=(const CTextString &inString) { itemName = inString; return *this; }

operator SInt32() const { return id; }
operator CTextString() const { return itemName; }

// members
SInt32 id;
CTextString itemName;
};
/*************************************************************************************/
class CCVDataHolder : CDataHolder<SCVData>
{
public:
CCVDataHolder() {}
CCVDataHolder(const SCVData &inData) : CDataHolder<SCVData>(inData) {}
CCVDataHolder(const SInt32 id, const CTextString itemName) { SetCVData(id, itemName); }
virtual ~CCVDataHolder() {}

virtual CTextString GetCString() const { return mData.itemName; }
virtual void SetCString(const CTextString &inString) { mData.itemName = inString; }

virtual SInt32 GetValue() const { return mData.id; }
virtual void SetValue(const SInt32 inValue) { mData.id = inValue; }

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const; // TCS 1/13/02
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);

void SetCVData(const SInt32 id, const CTextString itemName)
{
mData.id = id;
mData.itemName = itemName;
}
}

/*************************************************************************************/
class CDateHolder : CDataHolder<CDate>
{
public:

CDateHolder() {}
CDateHolder(const CDate &inDate)
: CDataHolder<CDate>(inDate) {}
CDateHolder(const CDataHolder<CDate> &inHolder)
: CDataHolder<CDate>(inHolder) {}
virtual ~CDateHolder() {}

virtual SInt32 GetValue() const { return mData.GetIntegerValue(); } // TCS 7/31/00

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CTimeHolder : CDataHolder<CDate>
{
public:

CTimeHolder() {}
CTimeHolder(const CDate &inDate)
: CDataHolder<CDate>(inDate) {}
CTimeHolder(const CDataHolder<CDate> &inHolder)
: CDataHolder<CDate>(inHolder) {}
virtual ~CTimeHolder() {}

virtual SInt32 GetValue() const { return mData.GetIntegerValue(); } // TCS 7/31/00

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CPercentHolder : CDataHolder<CMoney>
{
public:

CPercentHolder() {}
CPercentHolder(const CMoney &inPercent)
: CDataHolder<CMoney>(inPercent) {}
CPercentHolder(const CDataHolder<CMoney> &inHolder)
: CDataHolder<CMoney>(inHolder) {}
virtual ~CPercentHolder() {}

virtual SInt32 GetValue() const { return mData.GetDollars(); } // rev TCS 5/10/01

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CMoneyHolder : CDataHolder<CMoney>
{
public:

CMoneyHolder() {}
CMoneyHolder(const CMoney &inDate)
: CDataHolder<CMoney>(inDate) {}
CMoneyHolder(const CDataHolder<CMoney> &inHolder)
: CDataHolder<CMoney>(inHolder) {}
virtual ~CMoneyHolder() {}

virtual SInt32 GetValue() const { return mData.GetDollars(); }

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CEMoneyHolder : CDataHolder<CMoney>
{
public:

CEMoneyHolder() {}
CEMoneyHolder(const CMoney &inDate)
: CDataHolder<CMoney>(inDate) {}
CEMoneyHolder(const CDataHolder<CMoney> &inHolder)
: CDataHolder<CMoney>(inHolder) {}
virtual ~CEMoneyHolder() {}

virtual SInt32 GetValue() const { return mData.GetDollars(); }

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CNumberHolder : CDataHolder<CMoney>
{
public:

CNumberHolder() {}
CNumberHolder(const CMoney &inDate)
: CDataHolder<CMoney>(inDate) {}
CNumberHolder(const CDataHolder<CMoney> &inHolder)
: CDataHolder<CMoney>(inHolder) {}
virtual ~CNumberHolder() {}

virtual SInt32 GetValue() const { return mData.GetDollars(); }

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CRealHolder : CDataHolder<TCS_Real>
{
public:

CRealHolder() {}
CRealHolder(const TCS_Real &inDate)
: CDataHolder<TCS_Real>(inDate) {}
CRealHolder(const CDataHolder<TCS_Real> &inHolder)
: CDataHolder<TCS_Real>(inHolder) {}
virtual ~CRealHolder() {}

virtual SInt32 GetValue() const { return SInt32(mData); }

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CInt32Holder : CDataHolder<SInt32>
{
public:

CInt32Holder() {}
CInt32Holder(const SInt32 &inDate)
: CDataHolder<SInt32>(inDate) {}
CInt32Holder(const CDataHolder<SInt32> &inHolder)
: CDataHolder<SInt32>(inHolder) {}
virtual ~CInt32Holder() {}

virtual SInt32 GetValue() const { return SInt32(mData); }

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};/*************************************************************************************/
class CBooleanHolder : CDataHolder<Boolean>
{
public:

CBooleanHolder() {}
CBooleanHolder(const Boolean &inDate)
: CDataHolder<Boolean>(inDate) {}
CBooleanHolder(const CDataHolder<Boolean> &inHolder)
: CDataHolder<Boolean>(inHolder) {}
virtual ~CBooleanHolder() {}

virtual Boolean ConvertValueTo(void *aValue, const SInt32 aType) const;
virtual Boolean ConvertValueFrom(const void *aValue, const SInt32 aType);
};