#include <string>
#include <iostream>

template <typename R>
class MethodReturn
{
public:
	MethodReturn() {}
	MethodReturn( const R ReturnValueIN ): ReturnValue(ReturnValueIN) {}
	MethodReturn( const R ReturnValueIN, const std::string& rReasonIN ):
		ReturnValue(ReturnValueIN), ErrorDescription(rReasonIN) {}

	virtual ~MethodReturn() {}

	void swap( MethodReturn& rOtherIN )
	{
		std::swap( ReturnValue, rOtherIN.ReturnValue );
		std::swap( ErrorDescription, rOtherIN.ErrorDescription );
	}

	MethodReturn( const MethodReturn& rOtherIN )
	{
		ReturnValue = rOtherIN.ReturnValue;
		ErrorDescription = rOtherIN.ErrorDescription;
	}

	MethodReturn& operator = ( const MethodReturn& rOtherIN )
	{
		MethodReturn temp(rOtherIN);
		swap(temp);
		return *this;
	}

	virtual R Return( void ) { return ReturnValue; }
	virtual std::string What( void ) { return ErrorDescription; }

private:
	R				ReturnValue;
	std::string		ErrorDescription;
};


MethodReturn<bool>
f1( int* iPtrIN )
{
	if ( NULL == iPtrIN )
		return (MethodReturn<bool>::MethodReturn(false, "Bad Argument- Input pointer is NULL!"));

	return (MethodReturn<bool>::MethodReturn(true));
}

MethodReturn<bool>
f2( void )
{
	return (MethodReturn<bool>::MethodReturn(true));
}

MethodReturn<std::string>
f3( void* vpPtrIN )
{
	if ( NULL == vpPtrIN )
		return (MethodReturn<std::string>::MethodReturn("Error!!!", "Bad Argument- Input pointer is NULL!"));

	return (MethodReturn<std::string>::MethodReturn("No Error."));
}



void
main( void )
{
	MethodReturn<bool> bRet;
	bRet = f1( NULL );
	std::cout << "Returned: " << bRet.Return() << std::endl;
	std::cout << "Reason: " << bRet.What() << std::endl;

	bRet = f2();
	std::cout << "Returned: " << bRet.Return() << std::endl;
	std::cout << "Reason: " << bRet.What() << std::endl;

	MethodReturn<std::string> strRet = f3( NULL );
	std::cout << "Returned: " << strRet.Return() << std::endl;
	std::cout << "Reason: " << strRet.What() << std::endl;
}