generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-07-04 17:40:01 +02:00
Code Issues Projects Releases Wiki Activity

casts inlining and some code tidy-up

Browse Source
This commit is contained in:
Aleksandar Fabijanic 2008-05-13 23:26:35 +00:00
parent bad44e6e46
commit 96c57718c4
1 changed files with 104 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
Foundation/include/Poco/Any.h
View File

@ -54,145 +54,145 @@ class Any
/// by Applied Informatics. /// by Applied Informatics.
{ {
public: public:
Any(): Any():
_content(0) _content(0)
/// Creates an empty any type. /// Creates an empty any type.
{ {
} }
template <typename ValueType> template <typename ValueType>
Any(const ValueType& value): Any(const ValueType& value):
_content(new Holder<ValueType>(value)) _content(new Holder<ValueType>(value))
/// Creates an any which stores the init parameter inside. /// Creates an any which stores the init parameter inside.
/// ///
/// Example: /// Example:
/// Any a(13); /// Any a(13);
/// Any a(string("12345")); /// Any a(string("12345"));
{ {
} }
Any(const Any& other): Any(const Any& other):
_content(other._content ? other._content->clone() : 0) _content(other._content ? other._content->clone() : 0)
/// Copy constructor, works with empty Anys and initialized Any values. /// Copy constructor, works with empty Anys and initialized Any values.
{ {
} }
~Any() ~Any()
{ {
delete _content; delete _content;
} }
Any& swap(Any& rhs) Any& swap(Any& rhs)
/// Swaps the content of the two Anys. /// Swaps the content of the two Anys.
{ {
std::swap(_content, rhs._content); std::swap(_content, rhs._content);
return *this; return *this;
} }
template <typename ValueType> template <typename ValueType>
Any& operator = (const ValueType& rhs) Any& operator = (const ValueType& rhs)
/// Assignment operator for all types != Any. /// Assignment operator for all types != Any.
/// ///
/// Example: /// Example:
/// Any a = 13; /// Any a = 13;
/// Any a = string("12345"); /// Any a = string("12345");
{ {
Any(rhs).swap(*this); Any(rhs).swap(*this);
return *this; return *this;
} }
Any& operator = (const Any& rhs) Any& operator = (const Any& rhs)
/// Assignment operator for Any. /// Assignment operator for Any.
{ {
Any(rhs).swap(*this); Any(rhs).swap(*this);
return *this; return *this;
} }
bool empty() const bool empty() const
/// returns true if the Any is empty /// 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. /// Returns the type information of the stored content.
/// If the Any is empty typeid(void) is returned. /// 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 /// It is suggested to always query an Any for its type info before trying to extract
/// data via an AnyCast/RefAnyCast. /// data via an AnyCast/RefAnyCast.
{ {
return _content ? _content->type() : typeid(void); return _content ? _content->type() : typeid(void);
} }
private: private:
class Placeholder class Placeholder
{ {
public: public:
virtual ~Placeholder() virtual ~Placeholder()
{ {
} }
virtual const std::type_info& type() const = 0; virtual const std::type_info& type() const = 0;
virtual Placeholder* clone() const = 0; virtual Placeholder* clone() const = 0;
}; };
template <typename ValueType> template <typename ValueType>
class Holder: public Placeholder class Holder: public Placeholder
{ {
public: public:
Holder(const ValueType& value): Holder(const ValueType& value):
_held(value) _held(value)
{ {
} }
virtual const std::type_info& type() const virtual const std::type_info& type() const
{ {
return typeid(ValueType); return typeid(ValueType);
} }
virtual Placeholder* clone() const virtual Placeholder* clone() const
{ {
return new Holder(_held); return new Holder(_held);
} }
ValueType _held; ValueType _held;
}; };
private: private:
template <typename ValueType> template <typename ValueType>
friend ValueType* AnyCast(Any*); friend ValueType* AnyCast(Any*);
template <typename ValueType> template <typename ValueType>
friend ValueType* UnsafeAnyCast(Any*); friend ValueType* UnsafeAnyCast(Any*);
Placeholder* _content; Placeholder* _content;
}; };
template <typename ValueType> template <typename ValueType>
ValueType* AnyCast(Any* operand) inline ValueType* AnyCast(Any* operand)
/// AnyCast operator used to extract the ValueType from an Any*. Will return a pointer /// AnyCast operator used to extract the ValueType from an Any*. Will return a pointer
/// to the stored value. /// to the stored value.
/// ///
/// Example Usage: /// Example Usage:
/// MyType* pTmp = AnyCast<MyType*>(pAny). /// MyType* pTmp = AnyCast<MyType*>(pAny).
/// Will return NULL if the cast fails, i.e. types don't match. /// Will return NULL if the cast fails, i.e. types don't match.
{ {
return operand && operand->type() == typeid(ValueType) return operand && operand->type() == typeid(ValueType)
? &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held ? &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held
: 0; : 0;
} }
template <typename ValueType> template <typename ValueType>
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 /// AnyCast operator used to extract a const ValueType pointer from an const Any*. Will return a const pointer
/// to the stored value. /// to the stored value.
/// ///
/// Example Usage: /// Example Usage:
/// const MyType* pTmp = AnyCast<MyType*>(pAny). /// const MyType* pTmp = AnyCast<MyType*>(pAny).
/// Will return NULL if the cast fails, i.e. types don't match. /// Will return NULL if the cast fails, i.e. types don't match.
{ {
return AnyCast<ValueType>(const_cast<Any*>(operand)); return AnyCast<ValueType>(const_cast<Any*>(operand));
} }
@ -201,15 +201,15 @@ ValueType AnyCast(const Any& operand)
/// AnyCast operator used to extract a copy of the ValueType from an const Any&. /// AnyCast operator used to extract a copy of the ValueType from an const Any&.
/// ///
/// Example Usage: /// Example Usage:
/// MyType tmp = AnyCast<MyType>(anAny). /// MyType tmp = AnyCast<MyType>(anAny).
/// Will throw a BadCastException if the cast fails. /// Will throw a BadCastException if the cast fails.
/// Dont use an AnyCast in combination with references, i.e. MyType& tmp = ... or const MyType& = ... /// 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 /// Some compilers will accept this code although a copy is returned. Use the RefAnyCast in
/// these cases. /// these cases.
{ {
ValueType* result = AnyCast<ValueType>(const_cast<Any*>(&operand)); ValueType* result = AnyCast<ValueType>(const_cast<Any*>(&operand));
if (!result) throw BadCastException("Failed to convert between const Any types"); if (!result) throw BadCastException("Failed to convert between const Any types");
return *result; return *result;
} }
@ -218,15 +218,16 @@ ValueType AnyCast(Any& operand)
/// AnyCast operator used to extract a copy of the ValueType from an Any&. /// AnyCast operator used to extract a copy of the ValueType from an Any&.
/// ///
/// Example Usage: /// Example Usage:
/// MyType tmp = AnyCast<MyType>(anAny). /// MyType tmp = AnyCast<MyType>(anAny).
/// Will throw a BadCastException if the cast fails. /// Will throw a BadCastException if the cast fails.
/// Dont use an AnyCast in combination with references, i.e. MyType& tmp = ... or const MyType& tmp = ... /// 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 /// Some compilers will accept this code although a copy is returned. Use the RefAnyCast in
/// these cases. /// these cases.
{ {
ValueType* result = AnyCast<ValueType>(&operand); ValueType* result = AnyCast<ValueType>(&operand);
if (!result) throw BadCastException("Failed to convert between Any types"); if (!result)
return *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. /// AnyCast operator used to return a const reference to the internal data.
/// ///
/// Example Usage: /// Example Usage:
/// const MyType& tmp = RefAnyCast<MyType>(anAny); /// const MyType& tmp = RefAnyCast<MyType>(anAny);
{ {
ValueType* result = AnyCast<ValueType>(const_cast<Any*>(&operand)); ValueType* result = AnyCast<ValueType>(const_cast<Any*>(&operand));
if (!result) throw BadCastException("RefAnyCast: Failed to convert between const Any types"); if (!result)
return *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. /// AnyCast operator used to return a reference to the internal data.
/// ///
/// Example Usage: /// Example Usage:
/// MyType& tmp = RefAnyCast<MyType>(anAny); /// MyType& tmp = RefAnyCast<MyType>(anAny);
{ {
ValueType* result = AnyCast<ValueType>(&operand); ValueType* result = AnyCast<ValueType>(&operand);
if (!result) throw BadCastException("RefAnyCast: Failed to convert between Any types"); if (!result)
return *result; throw BadCastException("RefAnyCast: Failed to convert between Any types");
return *result;
} }
template <typename ValueType> template <typename ValueType>
ValueType* UnsafeAnyCast(Any* operand) inline ValueType* UnsafeAnyCast(Any* operand)
/// The "unsafe" versions of AnyCast are not part of the /// The "unsafe" versions of AnyCast are not part of the
/// public interface and may be removed at any time. They are /// 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 /// 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 /// use typeid() comparison, e.g., when our types may travel across
/// different shared libraries. /// different shared libraries.
{ {
return &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held; return &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held;
} }
template <typename ValueType> template <typename ValueType>
const ValueType* UnsafeAnyCast(const Any* operand) inline const ValueType* UnsafeAnyCast(const Any* operand)
/// The "unsafe" versions of AnyCast are not part of the /// The "unsafe" versions of AnyCast are not part of the
/// public interface and may be removed at any time. They are /// 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 /// 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 /// use typeid() comparison, e.g., when our types may travel across
/// different shared libraries. /// different shared libraries.
{ {
return AnyCast<ValueType>(const_cast<Any*>(operand)); return AnyCast<ValueType>(const_cast<Any*>(operand));
} }