dynamicanyholder.h

很好用的网络封装库,不熟悉网络编程的人也可以使用。使用风格良好的标准c++编写。

//
// DynamicAnyHolder.h
//
// $Id: //poco/1.3/Foundation/include/Poco/DynamicAnyHolder.h#2 $
//
// Library: Foundation
// Package: Core
// Module:  DynamicAnyHolder
//
// Definition of the DynamicAnyHolder class.
//
// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// Permission is hereby granted, free of charge, to any person or organization
// obtaining a copy of the software and accompanying documentation covered by
// this license (the "Software") to use, reproduce, display, distribute,
// execute, and transmit the Software, and to prepare derivative works of the
// Software, and to permit third-parties to whom the Software is furnished to
// do so, all subject to the following:
// 
// The copyright notices in the Software and this entire statement, including
// the above license grant, this restriction and the following disclaimer,
// must be included in all copies of the Software, in whole or in part, and
// all derivative works of the Software, unless such copies or derivative
// works are solely in the form of machine-executable object code generated by
// a source language processor.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//


#ifndef Foundation_DynamicAnyHolder_INCLUDED
#define Foundation_DynamicAnyHolder_INCLUDED


#include "Poco/Foundation.h"
#include "Poco/NumberFormatter.h"
#include "Poco/NumberParser.h"
#include "Poco/String.h"
#include "Poco/Exception.h"
#include <typeinfo>
#undef min
#undef max
#include <limits>


namespace Poco {


class Foundation_API DynamicAnyHolder
	/// Interface for a data holder used by the DynamicAny class. 
	/// Provides methods to convert between data types.
	/// Only data types for which a convert method exists are supported, which are
	/// all C++ built-in types with addition of std::string.
{
public:
	DynamicAnyHolder();
		/// Creates the DynamicAnyHolder.

	virtual ~DynamicAnyHolder();
		/// Destroys the DynamicAnyHolder.

	virtual DynamicAnyHolder* clone() const = 0;
		/// Deep-copies the DynamicAnyHolder.
		
	virtual const std::type_info& type() const = 0;
		/// Returns the type information of the stored content.

	virtual void convert(Int8& val) const = 0;
	virtual void convert(Int16& val) const = 0;
	virtual void convert(Int32& val) const = 0;
	virtual void convert(Int64& val) const = 0;
	virtual void convert(UInt8& val) const = 0;
	virtual void convert(UInt16& val) const = 0;
	virtual void convert(UInt32& val) const = 0;
	virtual void convert(UInt64& val) const = 0;

#ifndef POCO_LONG_IS_64_BIT
	void convert(long& val) const;
	void convert(unsigned long& val) const;
#endif

	virtual void convert(bool& val) const = 0;
	virtual void convert(float& val) const = 0;
	virtual void convert(double& val) const = 0;
	virtual void convert(char& val) const = 0;
	virtual void convert(std::string& val) const = 0;

protected:
	template <typename F, typename T>
	void convertToSmaller(const F& from, T& to) const
		/// This function is meant to convert signed integral values from
		/// larger to smaller type. It checks the upper and lower bound and
		/// if from value is within limits of type T (i.e. check calls do not throw), 
		/// it is converted.
	{
		poco_static_assert (std::numeric_limits<F>::is_specialized);
		poco_static_assert (std::numeric_limits<T>::is_specialized);
		poco_static_assert (std::numeric_limits<F>::is_signed);
		poco_static_assert (std::numeric_limits<T>::is_signed);

		checkUpperLimit(from, to); 
		checkLowerLimit(from, to);
		to = static_cast<T>(from);
	}

	template <typename F, typename T>
	void convertToSmallerUnsigned(const F& from, T& to) const
		/// This function is meant for converting unsigned integral data types,
		/// from larger to smaller type. Since lower limit is always 0 for unigned types, 
		/// only the upper limit is checked, thus saving some cycles compared to the signed 
		/// version of the function. If the value to be converted is smaller than
		/// the maximum value for the target type, the conversion is performed.
	{
		poco_static_assert (std::numeric_limits<F>::is_specialized);
		poco_static_assert (std::numeric_limits<T>::is_specialized);
		poco_static_assert (!std::numeric_limits<F>::is_signed);
		poco_static_assert (!std::numeric_limits<T>::is_signed);

		checkUpperLimit(from, to); 
		to = static_cast<T>(from);
	}

	template <typename F, typename T>
	void convertSignedToUnsigned(const F& from, T& to) const
		/// This function is meant for converting signed integral data types to
		/// unsigned data types. Negative values can not be converted and if one is 
		/// encountered, RangeException is thrown. 
		/// If uper limit is within the target data type limits, the converiosn is performed.
	{
		poco_static_assert (std::numeric_limits<F>::is_specialized);
		poco_static_assert (std::numeric_limits<T>::is_specialized);
		poco_static_assert (std::numeric_limits<F>::is_signed);
		poco_static_assert (!std::numeric_limits<T>::is_signed);

		if (from < 0)
			throw RangeException("Value too small.");
		checkUpperLimit(from, to); 
		to = static_cast<T>(from);
	}

	template <typename F, typename T>
	void convertUnsignedToSigned(const F& from, T& to) const
		/// This function is meant for converting unsigned integral data types to
		/// unsigned data types. Negative values can not be converted and if one is 
		/// encountered, RangeException is thrown. 
		/// If uper limit is within the target data type limits, the converiosn is performed.
	{
		poco_static_assert (std::numeric_limits<F>::is_specialized);
		poco_static_assert (std::numeric_limits<T>::is_specialized);
		poco_static_assert (!std::numeric_limits<F>::is_signed);
		poco_static_assert (std::numeric_limits<T>::is_signed);

		checkUpperLimit(from, to); 
		to = static_cast<T>(from);
	}

private:
	template <typename F, typename T>
	void checkUpperLimit(const F& from, T& to) const
	{
		if (from > std::numeric_limits<T>::max()) 
			throw RangeException("Value too large.");
	}

	template <typename F, typename T>
	void checkLowerLimit(const F& from, T& to) const
	{
		if (from < std::numeric_limits<T>::min()) 
			throw RangeException("Value too small.");
	}
};


//
// inlines
//
#ifndef POCO_LONG_IS_64_BIT
inline void DynamicAnyHolder::convert(long& val) const
{
	Int32 tmp;
	convert(tmp);
	val = tmp;
}


inline void DynamicAnyHolder::convert(unsigned long& val) const
{
	UInt32 tmp;
	convert(tmp);
	val = tmp;
}
#endif


template <typename T>
class DynamicAnyHolderImpl: public DynamicAnyHolder
	/// Template based implementation of a DynamicAnyHolder. 
	/// Conversion work happens in the template specializations of this class.
	///
	/// DynamicAny can be used for any type for which a specialization for
	/// DynamicAnyHolderImpl is available.
	///
	/// DynamicAnyHolderImpl throws following exceptions:
	///		NotImplementedException (if the specialization for a type does not exist)
	///		RangeException (if an attempt is made to assign a numeric value outside of the target min/max limits
	///		SyntaxException (if an attempt is made to convert a string containing non-numeric characters to number)
	///
	/// All specializations must additionally implement a public member function:
	///     const T& value() const
	/// returning a const reference to the actual stored value.
{
public:
	DynamicAnyHolderImpl()
	{
	}

	~DynamicAnyHolderImpl()
	{
	}
	
	const std::type_info& type() const
	{
		return typeid(T);
	}

	void convert(Int8&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(Int16&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(Int32&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(Int64&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}
	
	void convert(UInt8&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(UInt16&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(UInt32&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(UInt64&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(bool& val) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(float& val) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(double& val) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(char& val) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	void convert(std::string&) const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}

	DynamicAnyHolder* clone() const
	{
		throw NotImplementedException("No DynamicAnyHolder specialization for type", typeid(T).name());
	}
};


template <>
class DynamicAnyHolderImpl<Int8>: public DynamicAnyHolder
{
public:
	DynamicAnyHolderImpl(Int8 val): _val(val)
	{
	}

	~DynamicAnyHolderImpl()
	{
	}
	
	const std::type_info& type() const
	{
		return typeid(Int8);
	}

	void convert(Int8& val) const
	{
		val = _val;
	}

	void convert(Int16& val) const
	{
		val = _val;
	}
	
	void convert(Int32& val) const
	{
		val = _val;
	}

	void convert(Int64& val) const
	{
		val = _val;
	}

	void convert(UInt8& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(UInt16& val) const
	{
		convertSignedToUnsigned(_val, val);
	}
	
	void convert(UInt32& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(UInt64& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(bool& val) const
	{
		val = (_val != 0);
	}

	void convert(float& val) const
	{
		val = static_cast<float>(_val);
	}

	void convert(double& val) const
	{
		val = static_cast<double>(_val);
	}

	void convert(char& val) const
	{
		val = static_cast<char>(_val);
	}

	void convert(std::string& val) const
	{
		val = NumberFormatter::format(_val);
	}

	DynamicAnyHolder* clone() const
	{
		return new DynamicAnyHolderImpl(_val);
	}
	
	const Int8& value() const
	{
		return _val;
	}

private:
	Int8 _val;
};


template <>
class DynamicAnyHolderImpl<Int16>: public DynamicAnyHolder
{
public:
	DynamicAnyHolderImpl(Int16 val): _val(val)
	{
	}

	~DynamicAnyHolderImpl()
	{
	}
	
	const std::type_info& type() const
	{
		return typeid(Int16);
	}

	void convert(Int8& val) const
	{
		convertToSmaller(_val, val);
	}

	void convert(Int16& val) const
	{
		val = _val;
	}
	
	void convert(Int32& val) const
	{
		val = _val;
	}

	void convert(Int64& val) const
	{
		val = _val;
	}

	void convert(UInt8& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(UInt16& val) const
	{
		convertSignedToUnsigned(_val, val);
	}
	
	void convert(UInt32& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(UInt64& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(bool& val) const
	{
		val = (_val != 0);
	}

	void convert(float& val) const
	{
		val = static_cast<float>(_val);
	}

	void convert(double& val) const
	{
		val = static_cast<double>(_val);
	}

	void convert(char& val) const
	{
		UInt8 tmp;
		convert(tmp);
		val = static_cast<char>(tmp);
	}

	void convert(std::string& val) const
	{
		val = NumberFormatter::format(_val);
	}

	DynamicAnyHolder* clone() const
	{
		return new DynamicAnyHolderImpl(_val);
	}

	const Int16& value() const
	{
		return _val;
	}

private:
	Int16 _val;
};


template <>
class DynamicAnyHolderImpl<Int32>: public DynamicAnyHolder
{
public:
	DynamicAnyHolderImpl(Int32 val): _val(val)
	{
	}

	~DynamicAnyHolderImpl()
	{
	}

	const std::type_info& type() const
	{
		return typeid(Int32);
	}

	void convert(Int8& val) const
	{
		convertToSmaller(_val, val);
	}

	void convert(Int16& val) const
	{
		convertToSmaller(_val, val);
	}
	
	void convert(Int32& val) const
	{
		val = _val;
	}

	void convert(Int64& val) const
	{
		val = _val;
	}

	void convert(UInt8& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(UInt16& val) const
	{
		convertSignedToUnsigned(_val, val);
	}
	
	void convert(UInt32& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(UInt64& val) const
	{
		convertSignedToUnsigned(_val, val);
	}

	void convert(bool& val) const
	{
		val = (_val != 0);
	}

	void convert(float& val) const
	{
		val = static_cast<float>(_val);
	}

	void convert(double& val) const
	{
		val = static_cast<double>(_val);
	}

	void convert(char& val) const
	{
		UInt8 tmp;
		convert(tmp);
		val = static_cast<char>(tmp);
	}

	void convert(std::string& val) const
	{
		val = NumberFormatter::format(_val);
	}

	DynamicAnyHolder* clone() const
	{
		return new DynamicAnyHolderImpl(_val);
	}

	const Int32& value() const
	{
		return _val;
	}

private:
	Int32 _val;
};


template <>
class DynamicAnyHolderImpl<Int64>: public DynamicAnyHolder
{
public:
	DynamicAnyHolderImpl(Int64 val): _val(val)
	{
	}