From 96c57718c46f3d8c962b047969f4e9e312f935a0 Mon Sep 17 00:00:00 2001 From: Aleksandar Fabijanic Date: Tue, 13 May 2008 23:26:35 +0000 Subject: [PATCH] casts inlining and some code tidy-up --- Foundation/include/Poco/Any.h | 205 +++++++++++++++++----------------- 1 file changed, 104 insertions(+), 101 deletions(-) diff --git a/Foundation/include/Poco/Any.h b/Foundation/include/Poco/Any.h index 3cad4711e..0c74021b3 100644 --- a/Foundation/include/Poco/Any.h +++ b/Foundation/include/Poco/Any.h @@ -54,145 +54,145 @@ class Any /// by Applied Informatics. { public: - Any(): + Any(): _content(0) /// Creates an empty any type. - { - } + { + } - template - Any(const ValueType& value): + template + Any(const ValueType& value): _content(new Holder(value)) /// Creates an any which stores the init parameter inside. /// /// Example: - /// Any a(13); - /// Any a(string("12345")); - { - } + /// Any a(13); + /// Any a(string("12345")); + { + } - Any(const Any& other): + Any(const Any& other): _content(other._content ? other._content->clone() : 0) /// Copy constructor, works with empty Anys and initialized Any values. - { - } + { + } - ~Any() - { - delete _content; - } + ~Any() + { + delete _content; + } - Any& swap(Any& rhs) + Any& swap(Any& rhs) /// Swaps the content of the two Anys. - { - std::swap(_content, rhs._content); - return *this; - } + { + std::swap(_content, rhs._content); + return *this; + } - template - Any& operator = (const ValueType& rhs) + template + Any& operator = (const ValueType& rhs) /// Assignment operator for all types != Any. /// /// Example: - /// Any a = 13; - /// Any a = string("12345"); - { - Any(rhs).swap(*this); - return *this; - } + /// Any a = 13; + /// Any a = string("12345"); + { + Any(rhs).swap(*this); + return *this; + } - Any& operator = (const Any& rhs) + Any& operator = (const Any& rhs) /// Assignment operator for Any. - { - Any(rhs).swap(*this); - return *this; - } + { + Any(rhs).swap(*this); + return *this; + } - bool empty() const + bool empty() const /// returns true if the Any is empty - { - return !_content; - } + { + return !_content; + } - const std::type_info& type() const + const std::type_info& type() const /// Returns the type information of the stored content. /// If the Any is empty typeid(void) is returned. /// It is suggested to always query an Any for its type info before trying to extract /// data via an AnyCast/RefAnyCast. - { - return _content ? _content->type() : typeid(void); - } + { + return _content ? _content->type() : typeid(void); + } private: - class Placeholder - { - public: - virtual ~Placeholder() - { - } + class Placeholder + { + public: + virtual ~Placeholder() + { + } - virtual const std::type_info& type() const = 0; - virtual Placeholder* clone() const = 0; - }; + virtual const std::type_info& type() const = 0; + virtual Placeholder* clone() const = 0; + }; - template - class Holder: public Placeholder - { - public: - Holder(const ValueType& value): + template + class Holder: public Placeholder + { + public: + Holder(const ValueType& value): _held(value) - { - } + { + } - virtual const std::type_info& type() const - { - return typeid(ValueType); - } + virtual const std::type_info& type() const + { + return typeid(ValueType); + } - virtual Placeholder* clone() const - { - return new Holder(_held); - } + virtual Placeholder* clone() const + { + return new Holder(_held); + } - ValueType _held; - }; + ValueType _held; + }; private: - template - friend ValueType* AnyCast(Any*); + template + friend ValueType* AnyCast(Any*); - template - friend ValueType* UnsafeAnyCast(Any*); + template + friend ValueType* UnsafeAnyCast(Any*); - Placeholder* _content; + Placeholder* _content; }; template -ValueType* AnyCast(Any* operand) +inline ValueType* AnyCast(Any* operand) /// AnyCast operator used to extract the ValueType from an Any*. Will return a pointer /// to the stored value. /// /// Example Usage: - /// MyType* pTmp = AnyCast(pAny). + /// MyType* pTmp = AnyCast(pAny). /// Will return NULL if the cast fails, i.e. types don't match. { - return operand && operand->type() == typeid(ValueType) - ? &static_cast*>(operand->_content)->_held - : 0; + return operand && operand->type() == typeid(ValueType) + ? &static_cast*>(operand->_content)->_held + : 0; } template -const ValueType* AnyCast(const Any* operand) +inline const ValueType* AnyCast(const Any* operand) /// AnyCast operator used to extract a const ValueType pointer from an const Any*. Will return a const pointer /// to the stored value. /// /// Example Usage: - /// const MyType* pTmp = AnyCast(pAny). + /// const MyType* pTmp = AnyCast(pAny). /// Will return NULL if the cast fails, i.e. types don't match. { - return AnyCast(const_cast(operand)); + return AnyCast(const_cast(operand)); } @@ -201,15 +201,15 @@ ValueType AnyCast(const Any& operand) /// AnyCast operator used to extract a copy of the ValueType from an const Any&. /// /// Example Usage: - /// MyType tmp = AnyCast(anAny). + /// MyType tmp = AnyCast(anAny). /// Will throw a BadCastException if the cast fails. /// Dont use an AnyCast in combination with references, i.e. MyType& tmp = ... or const MyType& = ... /// Some compilers will accept this code although a copy is returned. Use the RefAnyCast in /// these cases. { - ValueType* result = AnyCast(const_cast(&operand)); - if (!result) throw BadCastException("Failed to convert between const Any types"); - return *result; + ValueType* result = AnyCast(const_cast(&operand)); + if (!result) throw BadCastException("Failed to convert between const Any types"); + return *result; } @@ -218,15 +218,16 @@ ValueType AnyCast(Any& operand) /// AnyCast operator used to extract a copy of the ValueType from an Any&. /// /// Example Usage: - /// MyType tmp = AnyCast(anAny). + /// MyType tmp = AnyCast(anAny). /// Will throw a BadCastException if the cast fails. /// Dont use an AnyCast in combination with references, i.e. MyType& tmp = ... or const MyType& tmp = ... /// Some compilers will accept this code although a copy is returned. Use the RefAnyCast in /// these cases. { - ValueType* result = AnyCast(&operand); - if (!result) throw BadCastException("Failed to convert between Any types"); - return *result; + ValueType* result = AnyCast(&operand); + if (!result) + throw BadCastException("Failed to convert between Any types"); + return *result; } @@ -235,11 +236,12 @@ const ValueType& RefAnyCast(const Any & operand) /// AnyCast operator used to return a const reference to the internal data. /// /// Example Usage: - /// const MyType& tmp = RefAnyCast(anAny); + /// const MyType& tmp = RefAnyCast(anAny); { - ValueType* result = AnyCast(const_cast(&operand)); - if (!result) throw BadCastException("RefAnyCast: Failed to convert between const Any types"); - return *result; + ValueType* result = AnyCast(const_cast(&operand)); + if (!result) + throw BadCastException("RefAnyCast: Failed to convert between const Any types"); + return *result; } @@ -248,35 +250,36 @@ ValueType& RefAnyCast(Any& operand) /// AnyCast operator used to return a reference to the internal data. /// /// Example Usage: - /// MyType& tmp = RefAnyCast(anAny); + /// MyType& tmp = RefAnyCast(anAny); { - ValueType* result = AnyCast(&operand); - if (!result) throw BadCastException("RefAnyCast: Failed to convert between Any types"); - return *result; + ValueType* result = AnyCast(&operand); + if (!result) + throw BadCastException("RefAnyCast: Failed to convert between Any types"); + return *result; } template -ValueType* UnsafeAnyCast(Any* operand) +inline ValueType* UnsafeAnyCast(Any* operand) /// The "unsafe" versions of AnyCast are not part of the /// public interface and may be removed at any time. They are /// required where we know what type is stored in the any and can't /// use typeid() comparison, e.g., when our types may travel across /// different shared libraries. { - return &static_cast*>(operand->_content)->_held; + return &static_cast*>(operand->_content)->_held; } template -const ValueType* UnsafeAnyCast(const Any* operand) +inline const ValueType* UnsafeAnyCast(const Any* operand) /// The "unsafe" versions of AnyCast are not part of the /// public interface and may be removed at any time. They are /// required where we know what type is stored in the any and can't /// use typeid() comparison, e.g., when our types may travel across /// different shared libraries. { - return AnyCast(const_cast(operand)); + return AnyCast(const_cast(operand)); }