Re: MFC in VS2005 problem
I'm sorry about the attachments.
Here's some code (6files, long post!)
=================
XXMLDomParser.h
=================
/*
File : XXMLDomParser.h
Class : XXMLDomParser
Base class for all xml DOM builder and readers
*/
#pragma once
#import <msxml4.dll> named_guids
using namespace MSXML2;
//
// Include member classes
//
#include "stdafx.h"
#include "fx\a\FXALoggableException.h"
//
// 'Borrowed' macros from Microsoft msxml c++ sample.
//
#define CHECKHR(x) {hr = x; if(FAILED(hr)) goto CleanUp;}
#define SAFERELEASE(p) {if (p) {(p)->Release();p = NULL;}}
#define SAFEFREE(p) {if (p) {free(p);}}
#define SAFEFREESTRING(p) {if (p) { SysFreeString(p);}}
// This macro replaces CHECKHR.
#define EVALHR(hr) { if(S_OK != hr) { throw FXALoggableException(300, _T("XML error"),
_T("")/*CString((__WFILE__))*/, _T("")); } }
/**
* XML parser base class.
*/
class XXMLDomParser
{
//
// Attributes.
//
protected:
MSXML2::IXMLDOMDocument* mXmlDOMDocument;
//
// Interface Methods.
//
public:
/**
* Constructor.
*/
XXMLDomParser();
/**
* Destructor.
*/
~XXMLDomParser();
//
// Protected helper functions.
//
protected:
//
// Check that XML parser component is initialized.
//
void CheckInit();
//
// Add element and set value as text
//
MSXML2::IXMLDOMNode* AddElement(MSXML2::IXMLDOMNode* rootNode, const
CString& name, const CString& value);
//
// Add element
//
MSXML2::IXMLDOMNode* AddElement(MSXML2::IXMLDOMNode* rootNode, const
CString& name);
//
// Add root element
//
MSXML2::IXMLDOMNode* AddRoot(const CString& name);
//
// Convenience methods for adding an attribute to an attribute list.
//
void AddStringAttribute(MSXML2::IXMLDOMNamedNodeMap* attributeList,
CString attributeName,
CString attributeValue);
void AddIntAttribute(MSXML2::IXMLDOMNamedNodeMap* attributeList,
CString attributeName,
int attributeValue);
void AddFloatAttribute(MSXML2::IXMLDOMNamedNodeMap* attributeList,
CString attributeName,
float attributeValue);
void AddBooleanAttribute(MSXML2::IXMLDOMNamedNodeMap* attributeList,
CString attributeName,
BOOL attributeValue);
void AddTimeAttribute(MSXML2::IXMLDOMNamedNodeMap* attributeList,
CString attributeName,
CTime attributeValue);
//
// Convenience methods for getting an attribute value from an attribute
list.
//
static CString GetStringAttributeValue(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName);
static int GetIntAttributeValue(MSXML2::IXMLDOMNamedNodeMap* attributeList,
CString attributeName);
static float GetFloatAttributeValue(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName);
static BOOL GetBooleanAttributeValue(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName);
static BSTR GetXml(MSXML2::IXMLDOMNode* root);
//
// Private helper functions.
//
private:
};
================
XXMLDomParser.cpp
================
/*
File: XXMLDomParser.cpp
Class: XXMLDomParser
Base class for all xml DOM builder and readers
*/
#include "stdafx.h"
#include "x\XXMLDomParser.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
//
// Replace a " character with " entity,
// and a & with a & entity.
// NB! The order.
//
static CString encodeString(const CString& str)
{
CString tmp(str);
tmp.Replace(_T("&"), _T("&"));
tmp.Replace(_T("\""), _T("""));
return tmp;
}
//
// Replace a " entity with a " character
// and & entity with a & character.
// NB! The order.
//
static CString decodeString(const CString& str)
{
CString tmp(str);
tmp.Replace(_T("&"), _T("&"));
tmp.Replace(_T("""), _T("\""));
return tmp;
}
///////////////////////////////
// Public Interface section. //
///////////////////////////////
//
// Construction.
//
XXMLDomParser::XXMLDomParser()
{
HRESULT hr;
mXmlDOMDocument = NULL;
//
// Create an empty XML document DOM.
//
hr = CoCreateInstance(MSXML2::CLSID_DOMDocument,
NULL,
CLSCTX_INPROC_SERVER,
MSXML2::IID_IXMLDOMDocument,
(void**)&mXmlDOMDocument);
if (FAILED(hr))
{
SAFERELEASE(mXmlDOMDocument);
}
}
//
// Destruction.
//
XXMLDomParser::~XXMLDomParser()
{
SAFERELEASE(mXmlDOMDocument);
}
/////////////////////////////
// Helper function section.//
/////////////////////////////
//
// Check that XML parser component is initialized.
//
void XXMLDomParser::CheckInit()
{
if (NULL == mXmlDOMDocument)
{
throw FXALoggableException(300,
_T("Could not initialize XML parser component"),
CString(_T("")),//CString((__WFILE__)),
CString(_T("")));
}
// Clear document from all nodes
MSXML2::IXMLDOMNode* node = NULL;
mXmlDOMDocument->get_firstChild(&node);
while (node != NULL)
{
mXmlDOMDocument->removeChild(node);
mXmlDOMDocument->get_firstChild(&node);
}
}
//
// Add string attribute to attribute list
//
void XXMLDomParser::AddStringAttribute(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName,
CString attributeValue)
{
MSXML2::IXMLDOMAttributePtr attribute = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
MSXML2::IXMLDOMNodePtr tempNode = NULL;
ASSERT(NULL != attributeList);
try
{
if (attributeValue != _T(""))
{
attributeNameBSTR = attributeName.AllocSysString();
attributeValueBSTR = attributeValue.AllocSysString();
attribute = mXmlDOMDocument->createAttribute(attributeNameBSTR);
EVALHR(attribute->put_text(attributeValueBSTR));
tempNode = attributeList->setNamedItem(attribute);
SysFreeString(attributeNameBSTR);
SysFreeString(attributeValueBSTR);
}
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
SAFEFREESTRING(attributeValueBSTR);
SAFERELEASE(attribute);
SAFERELEASE(tempNode);
throw;
}
}
//
// Add integer attribute to attribute list
//
void XXMLDomParser::AddIntAttribute(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName,
int attributeValue)
{
MSXML2::IXMLDOMAttributePtr attribute = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
MSXML2::IXMLDOMNodePtr tempNode = NULL;
CString tempStr;
char buff[25];
ASSERT(NULL != attributeList);
try
{
if (attributeValue != -1)
{
_itoa_s(attributeValue, buff, 25, 10);
tempStr = CString(buff);
attributeNameBSTR = attributeName.AllocSysString();
attributeValueBSTR = tempStr.AllocSysString();
attribute = mXmlDOMDocument->createAttribute(attributeNameBSTR);
EVALHR(attribute->put_text(attributeValueBSTR));
tempNode = attributeList->setNamedItem(attribute);
SysFreeString(attributeNameBSTR);
SysFreeString(attributeValueBSTR);
}
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
SAFEFREESTRING(attributeValueBSTR);
SAFERELEASE(attribute);
SAFERELEASE(tempNode);
throw;
}
}
//
// Add float attribute to attribute list
//
void XXMLDomParser::AddFloatAttribute(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName,
float attributeValue)
{
MSXML2::IXMLDOMAttributePtr attribute = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
MSXML2::IXMLDOMNodePtr tempNode = NULL;
CString tempStr;
char buff[32];
ASSERT(NULL != attributeList);
try
{
if (attributeValue != -1.0f)
{
sprintf_s(buff, 32, "%01.2f", attributeValue);
tempStr = buff;
attributeNameBSTR = attributeName.AllocSysString();
attributeValueBSTR = tempStr.AllocSysString();
attribute = mXmlDOMDocument->createAttribute(attributeNameBSTR);
EVALHR(attribute->put_text(attributeValueBSTR));
tempNode = attributeList->setNamedItem(attribute);
SysFreeString(attributeNameBSTR);
SysFreeString(attributeValueBSTR);
}
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
SAFEFREESTRING(attributeValueBSTR);
SAFERELEASE(attribute);
SAFERELEASE(tempNode);
throw;
}
}
//
// Add boolean attribute to attribute list
//
void XXMLDomParser::AddBooleanAttribute(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName,
BOOL attributeValue)
{
MSXML2::IXMLDOMAttributePtr attribute = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
MSXML2::IXMLDOMNodePtr tempNode = NULL;
CString tempStr;
ASSERT(NULL != attributeList);
try
{
if (TRUE == attributeValue)
{
tempStr = "true";
}
else
{
tempStr = "false";
}
attributeNameBSTR = attributeName.AllocSysString();
attributeValueBSTR = tempStr.AllocSysString();
attribute = mXmlDOMDocument->createAttribute(attributeNameBSTR);
EVALHR(attribute->put_text(attributeValueBSTR));
tempNode = attributeList->setNamedItem(attribute);
SysFreeString(attributeNameBSTR);
SysFreeString(attributeValueBSTR);
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
SAFEFREESTRING(attributeValueBSTR);
SAFERELEASE(attribute);
SAFERELEASE(tempNode);
throw;
}
}
//
// Add time attribute to attribute list
//
void XXMLDomParser::AddTimeAttribute(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName,
CTime attributeValue)
{
MSXML2::IXMLDOMAttributePtr attribute = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
MSXML2::IXMLDOMNodePtr tempNode = NULL;
CString tempStr;
ASSERT(NULL != attributeList);
try
{
if (attributeValue != CTime (0))
{
tempStr = attributeValue.Format("%Y-%m-%d %H:%M");
attributeNameBSTR = attributeName.AllocSysString();
attributeValueBSTR = tempStr.AllocSysString();
attribute = mXmlDOMDocument->createAttribute(attributeNameBSTR);
EVALHR(attribute->put_text(attributeValueBSTR));
tempNode = attributeList->setNamedItem(attribute);
SysFreeString(attributeNameBSTR);
SysFreeString(attributeValueBSTR);
}
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
SAFEFREESTRING(attributeValueBSTR);
SAFERELEASE(attribute);
SAFERELEASE(tempNode);
throw;
}
}
//
// Get string attribute value from attribute list
//
CString XXMLDomParser::GetStringAttributeValue(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName)
{
MSXML2::IXMLDOMNodePtr attributeNode = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
ASSERT(NULL != attributeList);
try
{
attributeNameBSTR = attributeName.AllocSysString();
attributeNode = attributeList->getNamedItem(attributeNameBSTR);
if(attributeNode == NULL)
{
SysFreeString(attributeNameBSTR);
return _T("");
}
EVALHR(attributeNode->get_text(&attributeValueBSTR));
SysFreeString(attributeNameBSTR);
CString value = attributeValueBSTR;
return decodeString(value);
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
throw;
}
}
//
// Get integer attribute value from attribute list
//
int XXMLDomParser::GetIntAttributeValue(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName)
{
MSXML2::IXMLDOMNodePtr attributeNode = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
CString tempStr;
ASSERT(NULL != attributeList);
try
{
attributeNameBSTR = attributeName.AllocSysString();
attributeNode = attributeList->getNamedItem(attributeNameBSTR);
if(attributeNode == NULL)
{
SysFreeString(attributeNameBSTR);
return -1;
}
EVALHR(attributeNode->get_text(&attributeValueBSTR));
tempStr = attributeValueBSTR;
SysFreeString(attributeNameBSTR);
return _ttoi(tempStr);
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
throw;
}
}
//
// Get float attribute value from attribute list
//
float XXMLDomParser::GetFloatAttributeValue(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName)
{
MSXML2::IXMLDOMNodePtr attributeNode = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
CString tempStr;
ASSERT(NULL != attributeList);
try
{
attributeNameBSTR = attributeName.AllocSysString();
attributeNode = attributeList->getNamedItem(attributeNameBSTR);
if(attributeNode == NULL)
{
SysFreeString(attributeNameBSTR);
return -1.0f;
}
EVALHR(attributeNode->get_text(&attributeValueBSTR));
tempStr = attributeValueBSTR;
SysFreeString(attributeNameBSTR);
return (float) _tstof(tempStr);
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
throw;
}
}
//
// Get boolean attribute value from attribute list
//
BOOL XXMLDomParser::GetBooleanAttributeValue(MSXML2::IXMLDOMNamedNodeMap*
attributeList,
CString attributeName)
{
MSXML2::IXMLDOMNodePtr attributeNode = NULL;
BSTR attributeNameBSTR = NULL;
BSTR attributeValueBSTR = NULL;
CString tempStr;
ASSERT(NULL != attributeList);
try
{
attributeNameBSTR = attributeName.AllocSysString();
attributeNode = attributeList->getNamedItem(attributeNameBSTR);
EVALHR(attributeNode->get_text(&attributeValueBSTR));
tempStr = attributeValueBSTR;
SysFreeString(attributeNameBSTR);
if (0 == tempStr.CompareNoCase(_T("true")))
{
return TRUE;
}
else
{
return FALSE;
}
}
catch (FXALoggableException&)
{
SAFEFREESTRING(attributeNameBSTR);
throw;
}
}
BSTR XXMLDomParser::GetXml(MSXML2::IXMLDOMNode* root)
{
ASSERT(root != NULL);
BSTR xmlString;
root->get_xml(&xmlString);
return xmlString;
}
//
// Add element and set value as text
//
MSXML2::IXMLDOMNode* XXMLDomParser::AddElement(MSXML2::IXMLDOMNode*
rootNode, const CString& name, const CString& value)
{
MSXML2::IXMLDOMElementPtr newElement = NULL;
MSXML2::IXMLDOMNodePtr tempNode = NULL;
BSTR elemName = ::SysAllocString(name);
newElement = mXmlDOMDocument->createElement(elemName);
newElement->put_text(::SysAllocString(value));
tempNode = rootNode->appendChild(newElement);
return tempNode;
}
//
// Add element
//
MSXML2::IXMLDOMNode* XXMLDomParser::AddElement(MSXML2::IXMLDOMNode*
rootNode, const CString& name)
{
MSXML2::IXMLDOMElementPtr newElement = NULL;
MSXML2::IXMLDOMNodePtr tempNode = NULL;
BSTR elemName = ::SysAllocString(name);
newElement = mXmlDOMDocument->createElement(elemName);
tempNode = rootNode->appendChild(newElement);
return tempNode;
}
//
// Add root element
//
MSXML2::IXMLDOMNode* XXMLDomParser::AddRoot(const CString& name)
{
MSXML2::IXMLDOMElementPtr rootElement = NULL;
MSXML2::IXMLDOMNodePtr rootNode = NULL;
BSTR elemName = ::SysAllocString(name);
rootElement = mXmlDOMDocument->createElement(elemName);
rootNode = mXmlDOMDocument->appendChild(rootElement);
return rootNode;
}
===================
FXALoggableException.h
===================
/*
File: FXALoggableException.h
Class: FXALoggableException
Base class for all loggable exceptions.
*/
#pragma once
//
// Include base class.
//
#include "fx\a\FXAException.h"
class FXALoggableException : public FXAException
{
//
// Attributes.
//
protected:
//
// Message to be displayed to the developer.
//
CString mDeveloperMessage;
//
// Component where the exception occurred.
//
CString mComponentName;
//
// Class and method where the exception occurred.
//
CString mMethodSignature;
//
// Public methods.
//
public:
/**
* Constructor.
*/
FXALoggableException();
FXALoggableException(int code,
const CString& developerMessage,
const CString& componentName,
const CString& methodSignature);
/**
* Destructor.
*/
virtual ~FXALoggableException();
/**
* Copy constructor.
*/
FXALoggableException(const FXALoggableException& that);
//
// Assignment operator.
//
const FXALoggableException& operator=(const FXALoggableException& that);
/**
* Get message to be logged.
*
* @return The log message.
*/
virtual CString GetLogMessage() const;
//
// Private methods.
//
private:
public:
DECLARE_DYNAMIC(FXALoggableException)
};
======================
FXALoggableException.cpp
======================
/*
File: FXALoggableException.cpp
Class: FXALoggableException
Base class for all loggable exceptions.
*/
#include "stdafx.h"
#include "fx\a\FXALoggableException.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
IMPLEMENT_DYNAMIC(FXALoggableException, FXAException)
//
// Constructor.
//
FXALoggableException::FXALoggableException()
{
}
FXALoggableException::FXALoggableException(int code,
const CString& developerMessage,
const CString& componentName,
const CString& methodSignature)
: FXAException(code),
mDeveloperMessage(developerMessage),
mComponentName(componentName),
mMethodSignature(methodSignature)
{
}
//
// Destructor.
//
FXALoggableException::~FXALoggableException()
{
}
//
// Copy constructor.
//
FXALoggableException::FXALoggableException(const FXALoggableException& that)
: FXAException(that)
{
this->mDeveloperMessage = that.mDeveloperMessage;
this->mComponentName = that.mComponentName;
this->mMethodSignature = that.mMethodSignature;
}
//
// Assignment operator.
//
const FXALoggableException& FXALoggableException::operator=(const
FXALoggableException& that)
{
//
// Guard against self assignment.
//
if (&that != this)
{
this->mDeveloperMessage = that.mDeveloperMessage;
this->mComponentName = that.mComponentName;
this->mMethodSignature = that.mMethodSignature;
this->mCode = that.mCode;
for(POSITION pos = that.mArguments.GetHeadPosition(); pos != NULL;)
{
mArguments.AddTail(that.mArguments.GetNext(pos));
}
}
return *this;
}
//
// Get message to be logged.
//
CString FXALoggableException::GetLogMessage() const
{
CString logMessage;
logMessage.Format(_T("LOCATION: %s/%s DESCRIPTION: %s"),
!mComponentName.IsEmpty() ? mComponentName : _T("(unknown)"),
!mMethodSignature.IsEmpty() ? mMethodSignature : _T("(unknown)"),
!mDeveloperMessage.IsEmpty() ? mDeveloperMessage : _T("(unknown)"));
//
// Append arguments
//
const CStringList& arg = GetArguments();
if (arg.GetCount() > 0)
{
logMessage += _T(" TEXT: ");
}
for (POSITION pos = arg.GetHeadPosition(); pos != NULL; )
{
CString str = arg.GetNext(pos);
logMessage += str + _T(" ");
}
return logMessage;
}
=============
FXAException.h
=============
/*
File: FXAException.h
Class: FXAException
Base class for all exceptions.
*/
#pragma once
class FXAException : public CObject
{
//
// Attributes.
//
protected:
//
// Error code.
//
int mCode;
//
// Arguments in error message.
//
CStringList mArguments;
//
// Public methods.
//
public:
/**
* Constructor.
*/
FXAException();
/**
* Constructor.
*
* @param code the error code.
*/
FXAException(int code);
/**
* Constructor.
*
* @param code the error code.
* @param arguments the arguments to the error message.
*/
FXAException(int code, const CStringList& arguments);
/**
* Destructor.
*/
virtual ~FXAException();
/**
* Copy constructor.
*/
FXAException(const FXAException& that);
/**
* Assignment operator.
*/
const FXAException& operator=(const FXAException& that);
/**
* Set error code.
*
* @param code the error code.
*/
void SetCode(int code);
/**
* Get error code.
*
* @return the error code.
*/
int GetCode() const;
/**
* Add argument for error message.
*
* @param arg the argument.
*/
void AddArgument(const CString& arg);
/**
* Get arguments for error message.
*
* @return the arguments.
*/
const CStringList& GetArguments() const;
//
// Private methods.
//
private:
public:
DECLARE_DYNAMIC(FXAException)
};
===============
FXAException.cpp
===============
/*
File: FXAException.cpp
Class: FXAException
Base class for all exceptions.
*/
#include "stdafx.h"
#include "fx\a\FXAException.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
IMPLEMENT_DYNAMIC(FXAException, CObject)
//
// Constructor.
//
FXAException::FXAException()
{
}
//
// Constructor.
//
FXAException::FXAException(int code)
: mCode(code)
{
}
// Constructor.
//
FXAException::FXAException(int code, const CStringList& arguments)
: mCode(code)
{
for (POSITION pos = arguments.GetHeadPosition(); pos != NULL;)
{
mArguments.AddTail(arguments.GetNext(pos));
}
}
//
// Destructor.
//
FXAException::~FXAException()
{
}
//
// Copy constructor.
//
FXAException::FXAException(const FXAException& that)
{
this->mCode = that.mCode;
for(POSITION pos = that.mArguments.GetHeadPosition(); pos != NULL;)
{
mArguments.AddTail(that.mArguments.GetNext(pos));
}
}
//
// Assignment operator.
//
const FXAException& FXAException::operator=(const FXAException& that)
{
//
// Guard against self assignment.
//
if (&that != this)
{
this->mCode = that.mCode;
for(POSITION pos = that.mArguments.GetHeadPosition(); pos != NULL;)
{
mArguments.AddTail(that.mArguments.GetNext(pos));
}
}
return *this;
}
//
// Set error code.
//
void FXAException::SetCode(int code)
{
mCode = code;
}
//
// Get error code.
//
int FXAException::GetCode() const
{
return mCode;
}
//
// Add argument for error message.
//
void FXAException::AddArgument(const CString& arg)
{
mArguments.AddTail(arg);
}
//
// Get arguments for error message.
//
const CStringList& FXAException::GetArguments() const
{
return mArguments;
}
/*
File: FXAException.cpp
Class: FXAException
Base class for all exceptions.
*/
#include "stdafx.h"
#include "fx\a\FXAException.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
IMPLEMENT_DYNAMIC(FXAException, CObject)
//
// Constructor.
//
FXAException::FXAException()
{
}
//
// Constructor.
//
FXAException::FXAException(int code)
: mCode(code)
{
}
// Constructor.
//
FXAException::FXAException(int code, const CStringList& arguments)
: mCode(code)
{
for (POSITION pos = arguments.GetHeadPosition(); pos != NULL;)
{
mArguments.AddTail(arguments.GetNext(pos));
}
}
//
// Destructor.
//
FXAException::~FXAException()
{
}
//
// Copy constructor.
//
FXAException::FXAException(const FXAException& that)
{
this->mCode = that.mCode;
for(POSITION pos = that.mArguments.GetHeadPosition(); pos != NULL;)
{
mArguments.AddTail(that.mArguments.GetNext(pos));
}
}
//
// Assignment operator.
//
const FXAException& FXAException::operator=(const FXAException& that)
{
//
// Guard against self assignment.
//
if (&that != this)
{
this->mCode = that.mCode;
for(POSITION pos = that.mArguments.GetHeadPosition(); pos != NULL;)
{
mArguments.AddTail(that.mArguments.GetNext(pos));
}
}
return *this;
}
//
// Set error code.
//
void FXAException::SetCode(int code)
{
mCode = code;
}
//
// Get error code.
//
int FXAException::GetCode() const
{
return mCode;
}
//
// Add argument for error message.
//
void FXAException::AddArgument(const CString& arg)
{
mArguments.AddTail(arg);
}
//
// Get arguments for error message.
//
const CStringList& FXAException::GetArguments() const
{
return mArguments;
}
Thanks
<A>
----== Posted via Newsfeeds.Com - Unlimited-Unrestricted-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----