/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#ifndef _COM_SUN_STAR_UNO_ANY_H_
#define _COM_SUN_STAR_UNO_ANY_H_

#include <uno/any2.h>
#include <typelib/typedescription.h>
#include <com/sun/star/uno/Type.h>
#include "cppu/unotype.hxx"
#include <rtl/alloc.h>


namespace com
{     
namespace sun
{     
namespace star
{     
namespace uno
{     

/** 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 Any : public uno_Any
{
public:
	// these are here to force memory de/allocation to sal lib.
    /** @internal */
	inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
		{ return ::rtl_allocateMemory( nSize ); }
    /** @internal */
	inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
		{ ::rtl_freeMemory( pMem ); }
    /** @internal */
	inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
		{ return pMem; }
    /** @internal */
	inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
		{}
	
	/** Default constructor: Any holds no value; its type is void.
	*/
	inline Any() SAL_THROW( () );
    
    /** 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 );
    
	/** Copy constructor: Sets value of the given any.
        
		@param rAny another any
	*/
	inline Any( const Any & rAny ) SAL_THROW( () );
	
	/** Constructor: Sets a copy of the given data.
        
		@param pData_ value
		@param rType type of value
	*/
	inline Any( const void * pData_, const Type & rType ) SAL_THROW( () );
	
	/** Constructor: Sets a copy of the given data.
        
		@param pData_ value
		@param pTypeDescr type of value
	*/
	inline Any( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW( () );
	
	/** Constructor: Sets a copy of the given data.
        
		@param pData_ value
		@param pType type of value
	*/
	inline Any( const void * pData_, typelib_TypeDescriptionReference * pType ) SAL_THROW( () );
	
	/** Destructor: Destructs any content and frees memory.
	*/
	inline ~Any() SAL_THROW( () );
	
	/** 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 ) SAL_THROW( () );
	
	/** Gets the type of the set value.
        
		@return a Type object of the set value
	 */
	inline const Type & SAL_CALL getValueType() const SAL_THROW( () )
		{ return * reinterpret_cast< const Type * >( &pType ); }
	/** Gets the type of the set value.
        
		@return the UNacquired type description reference of the set value
	 */
	inline typelib_TypeDescriptionReference * SAL_CALL getValueTypeRef() const SAL_THROW( () )
		{ 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 a pointer to type description pointer
	*/
	inline void SAL_CALL getValueTypeDescription( typelib_TypeDescription ** ppTypeDescr ) const SAL_THROW( () )
		{ ::typelib_typedescriptionreference_getDescription( ppTypeDescr, pType ); }
	
	/** Gets the type class of the set value.
        
		@return the type class of the set value
	 */
	inline TypeClass SAL_CALL getValueTypeClass() const SAL_THROW( () )
		{ return (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 SAL_THROW( () );
	
	/** Tests if any contains a value.
        
		@return true if any has a value, false otherwise
	*/
	inline sal_Bool SAL_CALL hasValue() const SAL_THROW( () )
		{ return (typelib_TypeClass_VOID != pType->eTypeClass); }
	
	/** Gets a pointer to the set value.
        
		@return a pointer to the set value
	*/
	inline const void * SAL_CALL getValue() const SAL_THROW( () )
		{ return pData; }

#if ! defined(EXCEPTIONS_OFF)
    /** 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
        <type scope="com::sun::star::uno">RuntimeException</type>
        if the specified type cannot be provided.

        @return value of specified type
        @exception <type scope="com::sun::star::uno">RuntimeException</type>
                   in case the specified type cannot be provided
    */
    template <typename T>
    inline T get() const;
#endif // ! defined(EXCEPTIONS_OFF)
    
	/** 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 ) SAL_THROW( () );
	/** 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 ) SAL_THROW( () );
	/** 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 ) SAL_THROW( () );
	
	/** 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() SAL_THROW( () );
	
	/** 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 sal_Bool SAL_CALL isExtractableTo( const Type & rType ) const SAL_THROW( () );
    
	/** 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 sal_Bool SAL_CALL operator == ( const Any & rAny ) const SAL_THROW( () );
	/** Unequality 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 sal_Bool SAL_CALL operator != ( const Any & rAny ) const SAL_THROW( () );
    
private:
    // not impl: forbid use with ambiguous type (sal_Unicode, sal_uInt16)
    explicit Any( sal_uInt16 );
#if defined(_MSC_VER)
    // Omitting the following private declarations leads to an internal compiler
    // error on MSVC (version 1310).
    // not impl: forbid use with ambiguous type (sal_Unicode, sal_uInt16)
#if ! defined(EXCEPTIONS_OFF)
    template <>
    sal_uInt16 get<sal_uInt16>() const;
#endif // ! defined(EXCEPTIONS_OFF)
    template <>
	bool has<sal_uInt16>() const;
#endif // defined(_MSC_VER)
};

/** Template function to generically construct an any from a C++ value.

    @tplparam C value type
	@param value a value
	@return an any
*/
template< class C >
inline Any SAL_CALL makeAny( const C & value ) SAL_THROW( () );

// additionally specialized for C++ bool
template<>
inline Any SAL_CALL makeAny( bool const & value ) SAL_THROW( () );

class BaseReference;
class Type;

/** Template binary <<= operator to set the value of an any.

    @tplparam 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 ) SAL_THROW( () );

// additionally for C++ bool:
inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
    SAL_THROW( () );

/** 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.
    
    @tplparam 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 sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW( () );
	
/** 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.
    
    @tplparam 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 sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_THROW( () );
/** Template unequality 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.
    
    @tplparam 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 sal_Bool SAL_CALL operator != ( const Any & rAny, const C & value ) SAL_THROW( () );

// additional specialized >>= and == operators
// bool
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Bool & value ) SAL_THROW( () );
inline sal_Bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value ) SAL_THROW( () );
template<>
inline sal_Bool SAL_CALL operator >>= ( Any const & rAny, bool & value )
    SAL_THROW( () );
template<>
inline sal_Bool SAL_CALL operator == ( Any const & rAny, bool const & value )
    SAL_THROW( () );
// byte
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int8 & value ) SAL_THROW( () );
// short
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value ) SAL_THROW( () );
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value ) SAL_THROW( () );
// long
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value ) SAL_THROW( () );
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value ) SAL_THROW( () );
// hyper
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value ) SAL_THROW( () );
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value ) SAL_THROW( () );
// float
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, float & value ) SAL_THROW( () );
// double
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, double & value ) SAL_THROW( () );
// string
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value ) SAL_THROW( () );
inline sal_Bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value ) SAL_THROW( () );
// type
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Type & value ) SAL_THROW( () );
inline sal_Bool SAL_CALL operator == ( const Any & rAny, const Type & value ) SAL_THROW( () );
// any
inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Any & value ) SAL_THROW( () );
// interface
inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value ) SAL_THROW( () );

}
}
}
}

/** 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.
    
	@param dummy typed pointer for function signature
	@return type of IDL type any
*/
inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::com::sun::star::uno::Any * ) SAL_THROW( () )
{
    return ::cppu::UnoType< ::com::sun::star::uno::Any >::get();
}

#endif