sharedunocomponent.hxx

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_UNOTOOLS_SHAREDUNOCOMPONENT_HXX
#define INCLUDED_UNOTOOLS_SHAREDUNOCOMPONENT_HXX
 
#include <unotools/unotoolsdllapi.h>
#include <com/sun/star/uno/Reference.hxx>
#include <rtl/ref.hxx>
#include <memory>
 
namespace com::sun::star {
    namespace lang {
        class XComponent;
    }
}
 
namespace utl
{
 
    //= DisposableComponent
 
    class UNOTOOLS_DLLPUBLIC DisposableComponent
    {
        css::uno::Reference< css::lang::XComponent >  m_xComponent;
 
    public:
        DisposableComponent( const css::uno::Reference< css::uno::XInterface >& _rxComponent );
 
        ~DisposableComponent();
 
    private:
        DisposableComponent( const DisposableComponent& ) = delete;
        DisposableComponent& operator=( const DisposableComponent& ) = delete;
    };
 
    //= CloseableComponent
 
    class CloseableComponentImpl;
    class UNOTOOLS_DLLPUBLIC CloseableComponent
    {
    private:
        ::rtl::Reference< CloseableComponentImpl >  m_pImpl;
 
    public:
        CloseableComponent( const css::uno::Reference< css::uno::XInterface >& _rxComponent );
 
        ~CloseableComponent();
 
    private:
        CloseableComponent( const CloseableComponent& ) = delete;
        CloseableComponent& operator=( const CloseableComponent& ) = delete;
    };
 
    //= SharedUNOComponent
 
    template < class INTERFACE, class COMPONENT = DisposableComponent >
    class SharedUNOComponent
    {
    private:
        typedef COMPONENT                           Component;
 
    private:
        std::shared_ptr<Component>                            m_xComponent;
        css::uno::Reference< INTERFACE >            m_xTypedComponent;
 
    public:
        enum AssignmentMode
        {
            TakeOwnership,
            NoTakeOwnership
        };
 
    public:
        SharedUNOComponent()
        {
        }
 
        explicit SharedUNOComponent( const css::uno::Reference< INTERFACE >& _rxComponent, AssignmentMode eMode = TakeOwnership )
        {
            reset( _rxComponent, eMode );
        }
 
        SharedUNOComponent( const css::uno::BaseReference & _rRef, css::uno::UnoReference_QueryThrow _queryThrow )
        {
            set( _rRef, _queryThrow );
        }
 
//        SharedUNOComponent& operator=( const css::uno::Reference< INTERFACE >& _rxComponent );
        // This operator is intentionally not implemented. There is no canonic ownership after this operator
        // would have been applied: Should the SharedUNOComponent have the ownership of the component,
        // or shouldn't it? Hard to guess, and probably wrong in 50 percent of all cases, anyway. So,
        // instead of tempting clients of this class to use such a dangerous operator, we do
        // not offer it at all. If you need to assign a Reference< INTERFACE > to your SharedUNOComponent,
        // use the ->reset method.
 
        void reset( const css::uno::Reference< INTERFACE >& _rxComponent, AssignmentMode _eMode = TakeOwnership );
 
        inline bool set( const css::uno::BaseReference& _rRef, css::uno::UnoReference_Query _query );
 
        inline void set( const css::uno::BaseReference & _rRef, css::uno::UnoReference_QueryThrow _queryThrow );
 
        inline void set( const css::uno::Reference< INTERFACE >& _rRef, css::uno::UnoReference_SetThrow _setThrow );
        inline void set( const SharedUNOComponent& _rComp, css::uno::UnoReference_SetThrow _setThrow );
 
        INTERFACE* SAL_CALL operator->() const;
 
        operator const css::uno::Reference< INTERFACE >&() const
        {
            return m_xTypedComponent;
        }
 
        const css::uno::Reference< INTERFACE >& getTyped() const
        {
            return m_xTypedComponent;
        }
 
        bool is() const
        {
            return m_xTypedComponent.is();
        }
 
        void clear()
        {
            m_xComponent.reset();
            m_xTypedComponent.clear();
        }
    };
 
    template < class INTERFACE, class COMPONENT >
    INTERFACE* SAL_CALL SharedUNOComponent< INTERFACE, COMPONENT >::operator->() const
    {
        return m_xTypedComponent.operator->();
    }
 
    // assignments
    template < class INTERFACE, class COMPONENT >
    void SharedUNOComponent< INTERFACE, COMPONENT >::reset( const css::uno::Reference< INTERFACE >& _rxComponent, AssignmentMode _eMode )
    {
        m_xComponent.reset(_eMode == TakeOwnership ? new COMPONENT( _rxComponent ) : nullptr);
        m_xTypedComponent = _rxComponent;
    }
 
    // comparison operators
 
    template < class INTERFACE, class COMPONENT >
    bool operator==( const SharedUNOComponent< INTERFACE, COMPONENT >& _rLHS, const css::uno::Reference< INTERFACE >& _rRHS )
    {
        return _rLHS.getTyped() == _rRHS;
    }
 
    template < class INTERFACE, class COMPONENT >
    inline css::uno::Any SAL_CALL makeAny( const SharedUNOComponent< INTERFACE, COMPONENT >& value )
    {
        return css::uno::Any( value.getTyped() );
    }
 
    template < class INTERFACE, class COMPONENT >
    void SharedUNOComponent< INTERFACE, COMPONENT >::set( const css::uno::BaseReference & _rRef, css::uno::UnoReference_QueryThrow _queryThrow )
    {
        reset( css::uno::Reference< INTERFACE >( _rRef, _queryThrow ), TakeOwnership );
    }
 
    template < class INTERFACE, class COMPONENT >
    void SharedUNOComponent< INTERFACE, COMPONENT >::set( const css::uno::Reference< INTERFACE >& _rRef, css::uno::UnoReference_SetThrow _setThrow )
    {
        reset( css::uno::Reference< INTERFACE >( _rRef, _setThrow ), TakeOwnership );
    }
 
    template < class INTERFACE, class COMPONENT >
    void SharedUNOComponent< INTERFACE, COMPONENT >::set( const SharedUNOComponent& _rComp, css::uno::UnoReference_SetThrow _setThrow )
    {
        *this = _rComp;
        // provoke an exception in case the component is NULL
        m_xTypedComponent.set( m_xTypedComponent, _setThrow );
    }
 
    template < class INTERFACE, class COMPONENT >
    bool SharedUNOComponent< INTERFACE, COMPONENT >::set( const css::uno::BaseReference& _rRef, css::uno::UnoReference_Query _query )
    {
        reset( css::uno::Reference< INTERFACE >( _rRef, _query ) );
        return is();
    }
 
}   // namespace utl
 
#endif // INCLUDED_UNOTOOLS_SHAREDUNOCOMPONENT_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */