Any.h

Go to the documentation of this file.

/* -*- 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 <uno/any2.h>
#include <typelib/typedescription.h>
#include <cppu/unotype.hxx>
#include <com/sun/star/uno/TypeClass.hdl>
#include <rtl/alloc.h>

namespace rtl { class OUString; }

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

class Type;

class SAL_WARN_UNUSED Any : public uno_Any
{
public:
    // these are here to force memory de/allocation to sal lib.
    inline static void * SAL_CALL operator new ( size_t nSize )
        { return ::rtl_allocateMemory( nSize ); }
    inline static void SAL_CALL operator delete ( void * pMem )
        { ::rtl_freeMemory( pMem ); }
    inline static void * SAL_CALL operator new ( size_t, void * pMem )
        { return pMem; }
    inline static void SAL_CALL operator delete ( void *, void * )
        {}

    inline Any();

    template <typename T>
    explicit inline Any( T const & value );
    explicit inline Any( bool value );

    inline Any( const Any & rAny );

    inline Any( const void * pData_, const Type & rType );

    inline Any( const void * pData_, typelib_TypeDescription * pTypeDescr );

    inline Any( const void * pData_, typelib_TypeDescriptionReference * pType );

    inline ~Any();

    inline Any & SAL_CALL operator = ( const Any & rAny );

    inline const Type & SAL_CALL getValueType() const
        { return * reinterpret_cast< const Type * >( &pType ); }
    inline typelib_TypeDescriptionReference * SAL_CALL getValueTypeRef() const
        { return pType; }

    inline void SAL_CALL getValueTypeDescription( typelib_TypeDescription ** ppTypeDescr ) const
        { ::typelib_typedescriptionreference_getDescription( ppTypeDescr, pType ); }

    inline TypeClass SAL_CALL getValueTypeClass() const
        { return (TypeClass)pType->eTypeClass; }

    inline ::rtl::OUString SAL_CALL getValueTypeName() const;

    inline bool SAL_CALL hasValue() const
        { return (typelib_TypeClass_VOID != pType->eTypeClass); }

    inline const void * SAL_CALL getValue() const
        { return pData; }

    template <typename T>
    inline T get() const;

    inline void SAL_CALL setValue( const void * pData_, const Type & rType );
    inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescriptionReference * pType );
    inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescription * pTypeDescr );

    inline void SAL_CALL clear();

    inline bool SAL_CALL isExtractableTo( const Type & rType ) const;

    template <typename T>
    inline bool has() const;

    inline bool SAL_CALL operator == ( const Any & rAny ) const;
    inline bool SAL_CALL operator != ( const Any & rAny ) const;

private:
    // Forbid use with ambiguous type (sal_Unicode, sal_uInt16):
    explicit Any(sal_uInt16) SAL_DELETED_FUNCTION;
};

// 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;

template< class C >
inline Any SAL_CALL makeAny( const C & value );

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

class BaseReference;

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< class C >
inline bool SAL_CALL operator >>= ( const Any & rAny, C & value );

template< class C >
inline bool SAL_CALL operator == ( const Any & rAny, const C & value );
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
template<>
inline bool SAL_CALL operator >>= ( const Any & rAny, Any & value );
// interface
template<>
inline bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value );

}
}
}
}

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: */