summaryrefslogtreecommitdiffstats
path: root/include/com/sun/star/uno/Any.h
diff options
context:
space:
mode:
Diffstat (limited to 'include/com/sun/star/uno/Any.h')
-rw-r--r--include/com/sun/star/uno/Any.h486
1 files changed, 486 insertions, 0 deletions
diff --git a/include/com/sun/star/uno/Any.h b/include/com/sun/star/uno/Any.h
new file mode 100644
index 000000000..577b31344
--- /dev/null
+++ b/include/com/sun/star/uno/Any.h
@@ -0,0 +1,486 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_COM_SUN_STAR_UNO_ANY_H
+#define INCLUDED_COM_SUN_STAR_UNO_ANY_H
+
+#include "sal/config.h"
+
+#include <cstddef>
+
+#include "rtl/ustring.hxx"
+#include "uno/any2.h"
+#include "typelib/typedescription.h"
+#include "cppu/unotype.hxx"
+#include "com/sun/star/uno/TypeClass.hdl"
+#include "rtl/alloc.h"
+
+namespace com
+{
+namespace sun
+{
+namespace star
+{
+namespace uno
+{
+
+class Type;
+
+/** C++ class representing an IDL any.
+ This class is used to transport any type defined in IDL. The class inherits from the
+ binary C representation of uno_Any.
+ You can insert a value by either using the <<= operators or the template function makeAny().
+ No any can hold an any. You can extract values from an any by using the >>= operators which
+ return true if the any contains an assignable value (no data loss), e.g. the any contains a
+ short and you >>= it into a long variable.
+*/
+class SAL_WARN_UNUSED SAL_DLLPUBLIC_RTTI Any : public uno_Any
+{
+public:
+ /// @cond INTERNAL
+ // these are here to force memory de/allocation to sal lib.
+ static void * SAL_CALL operator new ( size_t nSize )
+ { return ::rtl_allocateMemory( nSize ); }
+ static void SAL_CALL operator delete ( void * pMem )
+ { ::rtl_freeMemory( pMem ); }
+ static void * SAL_CALL operator new ( size_t, void * pMem )
+ { return pMem; }
+ static void SAL_CALL operator delete ( void *, void * )
+ {}
+ /// @endcond
+
+ /** Default constructor: Any holds no value; its type is void.
+ */
+ inline Any();
+
+ /** Templated ctor. Sets a copy of the given value.
+
+ @param value value of the Any
+ */
+ template <typename T>
+ explicit inline Any( T const & value );
+ /// Ctor support for C++ bool.
+ explicit inline Any( bool value );
+
+#if defined LIBO_INTERNAL_ONLY
+ template<typename T1, typename T2>
+ explicit inline Any(rtl::OUStringConcat<T1, T2> && value);
+ template<typename T1, typename T2>
+ explicit Any(rtl::OUStringConcat<T1, T2> const &) = delete;
+#endif
+
+ /** Copy constructor: Sets value of the given any.
+
+ @param rAny another any
+ */
+ inline Any( const Any & rAny );
+
+ /** Constructor: Sets a copy of the given data.
+
+ @param pData_ value
+ @param rType type of value
+ */
+ inline Any( const void * pData_, const Type & rType );
+
+ /** Constructor: Sets a copy of the given data.
+
+ @param pData_ value
+ @param pTypeDescr type of value
+ */
+ inline Any( const void * pData_, typelib_TypeDescription * pTypeDescr );
+
+ /** Constructor: Sets a copy of the given data.
+
+ @param pData_ value
+ @param pType_ type of value
+ */
+ inline Any( const void * pData_, typelib_TypeDescriptionReference * pType_ );
+
+#if defined LIBO_INTERNAL_ONLY
+ Any(bool const *, Type const &) = delete;
+ Any(bool const *, typelib_TypeDescription *) = delete;
+ Any(bool const *, typelib_TypeDescriptionReference *) = delete;
+ Any(sal_Bool const *, Type const &) = delete;
+ Any(sal_Bool const *, typelib_TypeDescription *) = delete;
+ Any(sal_Bool const *, typelib_TypeDescriptionReference *) = delete;
+ Any(std::nullptr_t, Type const & type):
+ Any(static_cast<void *>(nullptr), type) {}
+ Any(std::nullptr_t, typelib_TypeDescription * type):
+ Any(static_cast<void *>(nullptr), type) {}
+ Any(std::nullptr_t, typelib_TypeDescriptionReference * type):
+ Any(static_cast<void *>(nullptr), type) {}
+#endif
+
+ /** Destructor: Destructs any content and frees memory.
+ */
+ inline ~Any();
+
+ /** Assignment operator: Sets the value of the given any.
+
+ @param rAny another any (right side)
+ @return this any
+ */
+ inline Any & SAL_CALL operator = ( const Any & rAny );
+
+#if defined LIBO_INTERNAL_ONLY
+ inline Any(Any && other) noexcept;
+ inline Any & operator =(Any && other) noexcept;
+#endif
+
+ /** Gets the type of the set value.
+
+ @return a Type object of the set value
+ */
+ const Type & SAL_CALL getValueType() const
+ { return * reinterpret_cast< const Type * >( &pType ); }
+ /** Gets the type of the set value.
+
+ @return the unacquired type description reference of the set value
+ */
+ typelib_TypeDescriptionReference * SAL_CALL getValueTypeRef() const
+ { return pType; }
+
+ /** Gets the type description of the set value. Provides ownership of the type description!
+ Call an explicit typelib_typedescription_release() to release afterwards.
+
+ @param ppTypeDescr a pointer to type description pointer
+ */
+ void SAL_CALL getValueTypeDescription( typelib_TypeDescription ** ppTypeDescr ) const
+ { ::typelib_typedescriptionreference_getDescription( ppTypeDescr, pType ); }
+
+ /** Gets the type class of the set value.
+
+ @return the type class of the set value
+ */
+ TypeClass SAL_CALL getValueTypeClass() const
+ { return static_cast<TypeClass>(pType->eTypeClass); }
+
+ /** Gets the type name of the set value.
+
+ @return the type name of the set value
+ */
+ inline ::rtl::OUString SAL_CALL getValueTypeName() const;
+
+ /** Tests if any contains a value.
+
+ @return true if any has a value, false otherwise
+ */
+ bool SAL_CALL hasValue() const
+ { return (typelib_TypeClass_VOID != pType->eTypeClass); }
+
+ /** Gets a pointer to the set value.
+
+ @return a pointer to the set value
+ */
+ const void * SAL_CALL getValue() const
+ { return pData; }
+
+ /** Provides a value of specified type, so you can easily write e.g.
+ <pre>
+ sal_Int32 myVal = myAny.get<sal_Int32>();
+ </pre>
+ Widening conversion without data loss is taken into account.
+ Throws a com::sun::star::uno::RuntimeException if the specified type
+ cannot be provided.
+
+ @return value of specified type
+ @exception com::sun::star::uno::RuntimeException
+ in case the specified type cannot be provided
+ */
+ template <typename T>
+ inline T get() const;
+
+ /** Sets a value. If the any already contains a value, that value will be destructed
+ and its memory freed.
+
+ @param pData_ pointer to value
+ @param rType type of value
+ */
+ inline void SAL_CALL setValue( const void * pData_, const Type & rType );
+ /** Sets a value. If the any already contains a value, that value will be destructed
+ and its memory freed.
+
+ @param pData_ pointer to value
+ @param pType_ type of value
+ */
+ inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescriptionReference * pType_ );
+ /** Sets a value. If the any already contains a value, that value will be destructed
+ and its memory freed.
+
+ @param pData_ pointer to value
+ @param pTypeDescr type description of value
+ */
+ inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescription * pTypeDescr );
+
+#if defined LIBO_INTERNAL_ONLY
+ void setValue(bool const *, Type const &) = delete;
+ void setValue(bool const *, typelib_TypeDescriptionReference *) = delete;
+ void setValue(bool const *, typelib_TypeDescription *) = delete;
+ void setValue(sal_Bool const *, Type const &) = delete;
+ void setValue(sal_Bool const *, typelib_TypeDescriptionReference *)
+ = delete;
+ void setValue(sal_Bool const *, typelib_TypeDescription *) = delete;
+ void setValue(std::nullptr_t, Type const & type)
+ { setValue(static_cast<void *>(nullptr), type); }
+ void setValue(std::nullptr_t, typelib_TypeDescriptionReference * type)
+ { setValue(static_cast<void *>(nullptr), type); }
+ void setValue(std::nullptr_t, typelib_TypeDescription * type)
+ { setValue(static_cast<void *>(nullptr), type); }
+#endif
+
+ /** Clears this any. If the any already contains a value, that value will be destructed
+ and its memory freed. After this has been called, the any does not contain a value.
+ */
+ inline void SAL_CALL clear();
+
+ /** Tests whether this any is extractable to a value of given type.
+ Widening conversion without data loss is taken into account.
+
+ @param rType destination type
+ @return true if this any is extractable to value of given type (e.g. using >>= operator)
+ */
+ inline bool SAL_CALL isExtractableTo( const Type & rType ) const;
+
+ /** Tests whether this any can provide a value of specified type.
+ Widening conversion without data loss is taken into account.
+
+ @return true if this any can provide a value of specified type
+ (e.g. using >>= operator)
+ */
+ template <typename T>
+ inline bool has() const;
+
+ /** Equality operator: compares two anys.
+ The values need not be of equal type, e.g. a short integer is compared to a long integer.
+
+ @param rAny another any (right side)
+ @return true if both any contains equal values
+ */
+ inline bool SAL_CALL operator == ( const Any & rAny ) const;
+ /** Inequality operator: compares two anys.
+ The values need not be of equal type, e.g. a short integer is compared to a long integer.
+
+ @param rAny another any (right side)
+ @return true if both any contains unequal values
+ */
+ inline bool SAL_CALL operator != ( const Any & rAny ) const;
+
+private:
+#if !defined LIBO_INTERNAL_ONLY
+ /// @cond INTERNAL
+ // Forbid use with ambiguous type (sal_Unicode, sal_uInt16):
+ explicit Any(sal_uInt16) SAL_DELETED_FUNCTION;
+ /// @endcond
+#endif
+};
+
+#if !defined LIBO_INTERNAL_ONLY
+/// @cond INTERNAL
+// Forbid use with ambiguous type (sal_Unicode, sal_uInt16):
+template<> sal_uInt16 Any::get<sal_uInt16>() const SAL_DELETED_FUNCTION;
+template<> bool Any::has<sal_uInt16>() const SAL_DELETED_FUNCTION;
+/// @endcond
+#endif
+
+/** Template function to generically construct an any from a C++ value.
+
+ This can be useful with an explicitly specified template parameter, when the
+ (UNO) type recorded in the Any instance shall be different from what would
+ be deduced from the (C++) type of the argument if no template parameter were
+ specified explicitly.
+
+ @tparam C value type
+ @param value a value
+ @return an any
+*/
+template< class C >
+inline Any SAL_CALL makeAny( const C & value );
+
+#if !defined LIBO_INTERNAL_ONLY
+template<> inline Any SAL_CALL makeAny(sal_uInt16 const & value);
+#endif
+
+template<> Any SAL_CALL makeAny(Any const &) SAL_DELETED_FUNCTION;
+
+/** Wrap a value in an Any, if necessary.
+
+ The difference to makeAny is that makeAny cannot be called on an Any, while
+ toAny just returns the given Any.
+
+ @since LibreOffice 5.0
+*/
+template<typename T> inline Any toAny(T const & value);
+
+template<> inline Any toAny(Any const & value);
+
+#if defined LIBO_INTERNAL_ONLY
+
+/** Extract a value from an Any, if necessary.
+
+ The difference to operator >>= is that operator >>= cannot be called with an
+ Any as right-hand side (in LIBO_INTERNAL_ONLY), while fromAny just passes on
+ the given Any (and always succeeds) in the specialization for T = Any.
+
+ @tparam T any type representing a UNO type
+
+ @param any any Any value
+
+ @param value a non-null pointer, receiving the extracted value if
+ extraction succeeded (and left unmodified otherwise)
+
+ @return true iff extraction succeeded
+
+ @since LibreOffice 5.3
+*/
+template<typename T> inline bool fromAny(Any const & any, T * value);
+
+template<> inline bool fromAny(Any const & any, Any * value);
+
+#endif
+
+class BaseReference;
+
+/** Template binary <<= operator to set the value of an any.
+
+ @tparam C value type
+ @param rAny destination any (left side)
+ @param value source value (right side)
+*/
+template< class C >
+inline void SAL_CALL operator <<= ( Any & rAny, const C & value );
+
+// additionally for C++ bool:
+template<>
+inline void SAL_CALL operator <<= ( Any & rAny, bool const & value );
+
+/** Template binary >>= operator to assign a value from an any.
+ If the any does not contain a value that can be assigned without data loss, then this
+ operation will fail returning false.
+
+ @tparam C value type
+ @param rAny source any (left side)
+ @param value destination value (right side)
+ @return true if assignment was possible without data loss
+*/
+template< class C >
+inline bool SAL_CALL operator >>= ( const Any & rAny, C & value );
+
+/** Template equality operator: compares set value of left side any to right side value.
+ The values need not be of equal type, e.g. a short integer is compared to a long integer.
+ This operator can be implemented as template member function, if all supported compilers
+ can cope with template member functions.
+
+ @tparam C value type
+ @param rAny another any (left side)
+ @param value a value (right side)
+ @return true if values are equal, false otherwise
+*/
+template< class C >
+inline bool SAL_CALL operator == ( const Any & rAny, const C & value );
+/** Template inequality operator: compares set value of left side any to right side value.
+ The values need not be of equal type, e.g. a short integer is compared to a long integer.
+ This operator can be implemented as template member function, if all supported compilers
+ can cope with template member functions.
+
+ @tparam C value type
+ @param rAny another any (left side)
+ @param value a value (right side)
+ @return true if values are unequal, false otherwise
+*/
+template< class C >
+inline bool SAL_CALL operator != ( const Any & rAny, const C & value );
+
+// additional specialized >>= and == operators
+// bool
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Bool & value );
+template<>
+inline bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value );
+template<>
+inline bool SAL_CALL operator >>= ( Any const & rAny, bool & value );
+template<>
+inline bool SAL_CALL operator == ( Any const & rAny, bool const & value );
+// byte
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int8 & value );
+// short
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value );
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value );
+// long
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value );
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value );
+// hyper
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value );
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value );
+// float
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, float & value );
+// double
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, double & value );
+// string
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value );
+template<>
+inline bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value );
+// type
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, Type & value );
+template<>
+inline bool SAL_CALL operator == ( const Any & rAny, const Type & value );
+// any
+#if !defined LIBO_INTERNAL_ONLY
+template<>
+inline bool SAL_CALL operator >>= ( const Any & rAny, Any & value );
+#endif
+// interface
+template<>
+inline bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value );
+
+}
+}
+}
+}
+
+/** Gets the meta type of IDL type any.
+
+ There are cases (involving templates) where uses of getCppuType are known to
+ not compile. Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
+
+ The dummy parameter is just a typed pointer for function signature.
+
+ @return type of IDL type any
+
+ @deprecated
+ Use cppu::UnoType instead.
+*/
+SAL_DEPRECATED("use cppu::UnoType")
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Any * )
+{
+ return ::cppu::UnoType< ::com::sun::star::uno::Any >::get();
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */