Reference.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 .
 */

/*
 * This file is part of LibreOffice published API.
 */
#ifndef INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H
#define INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H

#include "sal/config.h"

#include <cassert>
#include <cstddef>

#if defined LIBO_INTERNAL_ONLY
#include <type_traits>
#endif

#include "rtl/alloc.h"

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

class RuntimeException;
class XInterface;
class Type;
class Any;

enum UnoReference_NoAcquire
{
    UNO_REF_NO_ACQUIRE
};

class BaseReference
{
protected:
    XInterface * _pInterface;

    inline static XInterface * SAL_CALL iquery( XInterface * pInterface, const Type & rType );
    inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface, const Type & rType );

public:
    XInterface * SAL_CALL get() const
        { return _pInterface; }

    bool SAL_CALL is() const
        { return (NULL != _pInterface); }

#if defined LIBO_INTERNAL_ONLY

    explicit operator bool() const
        { return is(); }
#endif

    inline bool SAL_CALL operator == ( XInterface * pInterface ) const;
    inline bool SAL_CALL operator != ( XInterface * pInterface ) const;

    inline bool SAL_CALL operator == ( const BaseReference & rRef ) const;
    inline bool SAL_CALL operator != ( const BaseReference & rRef ) const;

    inline bool SAL_CALL operator < ( const BaseReference & rRef ) const;
};

enum UnoReference_Query
{
    UNO_QUERY
};
enum UnoReference_QueryThrow
{
    UNO_QUERY_THROW
};
enum UnoReference_SetThrow
{
    UNO_SET_THROW
};

template< class interface_type >
class SAL_DLLPUBLIC_RTTI Reference : public BaseReference
{
    inline static XInterface * SAL_CALL iquery( XInterface * pInterface );
    inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface );
    inline static interface_type * SAL_CALL iset_throw( interface_type * pInterface );

    static interface_type * castFromXInterface(XInterface * p) {
        return static_cast< interface_type * >(static_cast< void * >(p));
    }

    static XInterface * castToXInterface(interface_type * p) {
        return static_cast< XInterface * >(static_cast< void * >(p));
    }

public:
    // 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 * )
        {}

    inline ~Reference() COVERITY_NOEXCEPT_FALSE;

    inline Reference();

    inline Reference( const Reference< interface_type > & rRef );

#if defined LIBO_INTERNAL_ONLY

    inline Reference( Reference< interface_type > && rRef ) noexcept;

    template< class derived_type >
    inline Reference(
        const Reference< derived_type > & rRef,
        std::enable_if_t<
            std::is_base_of_v<interface_type, derived_type>
            && !std::is_same_v<interface_type, XInterface>, void *> = nullptr);
#endif

    inline Reference( interface_type * pInterface );

    inline Reference( interface_type * pInterface, __sal_NoAcquire dummy);
    inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version") Reference( interface_type * pInterface, UnoReference_NoAcquire dummy );

    inline Reference( const BaseReference & rRef, UnoReference_Query dummy );
    inline Reference( XInterface * pInterface, UnoReference_Query dummy);
    inline Reference( const Any & rAny, UnoReference_Query dummy);
    inline Reference( const BaseReference & rRef, UnoReference_QueryThrow dummy );
#ifdef LIBO_INTERNAL_ONLY

    Reference( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
#endif

    inline Reference( XInterface * pInterface, UnoReference_QueryThrow dummy );
    inline Reference( const Any & rAny, UnoReference_QueryThrow dummy );
    inline Reference( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy );
    inline Reference( interface_type * pInterface, UnoReference_SetThrow dummy );

    SAL_CALL operator const Reference< XInterface > & () const
        { return * reinterpret_cast< const Reference< XInterface > * >( this ); }

    interface_type * SAL_CALL operator -> () const {
        assert(_pInterface != NULL);
        return castFromXInterface(_pInterface);
    }

    interface_type & SAL_CALL operator * () const {
        assert(_pInterface != NULL);
        return *castFromXInterface(_pInterface);
    }

    interface_type * SAL_CALL get() const
        { return castFromXInterface(_pInterface); }

    inline void SAL_CALL clear();

    inline bool SAL_CALL set( const Reference< interface_type > & rRef );
    inline bool SAL_CALL set( interface_type * pInterface );

    inline bool SAL_CALL set( interface_type * pInterface, __sal_NoAcquire dummy);
    inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version") bool SAL_CALL set( interface_type * pInterface, UnoReference_NoAcquire dummy);

    inline bool SAL_CALL set( XInterface * pInterface, UnoReference_Query dummy );
    inline bool SAL_CALL set( const BaseReference & rRef, UnoReference_Query dummy);

    inline bool set( Any const & rAny, UnoReference_Query dummy );

    inline void SAL_CALL set( XInterface * pInterface, UnoReference_QueryThrow dummy );
    inline void SAL_CALL set( const BaseReference & rRef, UnoReference_QueryThrow dummy );
#ifdef LIBO_INTERNAL_ONLY

    void set( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
#endif

    inline void set( Any const & rAny, UnoReference_QueryThrow dummy);
    inline void SAL_CALL set( interface_type * pInterface, UnoReference_SetThrow dummy);
    inline void SAL_CALL set( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy);


    inline Reference< interface_type > & SAL_CALL operator = ( interface_type * pInterface );
    inline Reference< interface_type > & SAL_CALL operator = ( const Reference< interface_type > & rRef );
#if defined LIBO_INTERNAL_ONLY

    inline Reference< interface_type > & operator = ( Reference< interface_type > && rRef ) noexcept;
#endif

    SAL_WARN_UNUSED_RESULT inline static Reference< interface_type > SAL_CALL query( const BaseReference & rRef );
    SAL_WARN_UNUSED_RESULT inline static Reference< interface_type > SAL_CALL query( XInterface * pInterface );
#if defined LIBO_INTERNAL_ONLY

    template< class other_type > inline Reference< other_type > query() const;
    template< class other_type > inline Reference< other_type > queryThrow() const;
#endif
};

}
}
}
}

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */