office-gobmx/include/ucbhelper/interactionrequest.hxx
Noel Grandin 4b795d15cd loplugin:finalclasses in ucbhelper
Change-Id: I52140333b274952d71afa13ba2d8edfcdf2b1425
Reviewed-on: https://gerrit.libreoffice.org/81767
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
2019-10-31 07:02:41 +01:00

546 lines
19 KiB
C++

/* -*- 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_UCBHELPER_INTERACTIONREQUEST_HXX
#define INCLUDED_UCBHELPER_INTERACTIONREQUEST_HXX
#include <com/sun/star/lang/XTypeProvider.hpp>
#include <com/sun/star/task/XInteractionRequest.hpp>
#include <com/sun/star/task/XInteractionAbort.hpp>
#include <com/sun/star/task/XInteractionRetry.hpp>
#include <com/sun/star/task/XInteractionApprove.hpp>
#include <com/sun/star/task/XInteractionDisapprove.hpp>
#include <com/sun/star/ucb/XInteractionAuthFallback.hpp>
#include <com/sun/star/ucb/XInteractionReplaceExistingData.hpp>
#include <com/sun/star/ucb/XInteractionSupplyAuthentication2.hpp>
#include <cppuhelper/implbase.hxx>
#include <ucbhelper/ucbhelperdllapi.h>
#include <memory>
namespace rtl { template <class reference_type> class Reference; }
namespace ucbhelper {
class InteractionContinuation;
struct InteractionRequest_Impl;
/**
* This class implements the interface XInteractionRequest. Instances can
* be passed directly to XInteractionHandler::handle(...). Each interaction
* request contains an exception describing the error and a number of
* interaction continuations describing the possible "answers" for the request.
* After the request was passed to XInteractionHandler::handle(...) the method
* getSelection() returns the continuation chosen by the interaction handler.
*
* The typical usage of this class would be:
*
* 1) Create exception object that shall be handled by the interaction handler.
* 2) Create InteractionRequest, supply exception as ctor parameter
* 3) Create continuations needed and add them to a sequence
* 4) Supply the continuations to the InteractionRequest by calling
* setContinuations(...)
*
* This class can also be used as base class for more specialized requests,
* like authentication requests.
*/
class UCBHELPER_DLLPUBLIC InteractionRequest :
public cppu::WeakImplHelper<css::task::XInteractionRequest>
{
std::unique_ptr<InteractionRequest_Impl> m_pImpl;
protected:
void setRequest( const css::uno::Any & rRequest );
InteractionRequest();
virtual ~InteractionRequest() override;
public:
/**
* Constructor.
*
* @param rRequest is the exception describing the error.
*/
InteractionRequest( const css::uno::Any & rRequest );
/**
* This method sets the continuations for the request.
*
* @param rContinuations contains the possible continuations.
*/
void setContinuations(
const css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > & rContinuations );
// XInteractionRequest
virtual css::uno::Any SAL_CALL
getRequest() override;
virtual css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > SAL_CALL
getContinuations() override;
// Non-interface methods.
/**
* After passing this request to XInteractionHandler::handle, this method
* returns the continuation that was chosen by the interaction handler.
*
* @return the continuation chosen by an interaction handler or an empty
* reference, if the request was not (yet) handled.
*/
rtl::Reference< InteractionContinuation > const & getSelection() const;
/**
* This method sets a continuation for the request. It also can be used
* to reset the continuation set by a previous XInteractionHandler::handle
* call in order to use this request object more than once.
*
* @param rxSelection is the interaction continuation to activate for
* the request or an empty reference in order to reset the
* current selection.
*/
void
setSelection(
const rtl::Reference< InteractionContinuation > & rxSelection );
};
/**
* This class is the base for implementations of the interface
* XInteractionContinuation. Classes derived from this bas class work together
* with class InteractionRequest.
*
* Derived classes must implement their XInteractionContinuation::select()
* method the way that they simply call recordSelection() which is provided by
* this class.
*/
class UCBHELPER_DLLPUBLIC InteractionContinuation : public cppu::OWeakObject
{
InteractionRequest* m_pRequest;
protected:
/**
* This method marks this continuation as "selected" at the request it
* belongs to.
*
* Derived classes must implement their XInteractionContinuation::select()
* method the way that they call this method.
*/
void recordSelection();
virtual ~InteractionContinuation() override;
public:
InteractionContinuation( InteractionRequest * pRequest );
};
/**
* This class implements a standard interaction continuation, namely the
* interface XInteractionAbort. Instances of this class can be passed
* along with an interaction request to indicate the possibility to abort
* the operation that caused the request.
*/
class UCBHELPER_DLLPUBLIC InteractionAbort final : public InteractionContinuation,
public css::lang::XTypeProvider,
public css::task::XInteractionAbort
{
public:
InteractionAbort( InteractionRequest * pRequest )
: InteractionContinuation( pRequest ) {}
// XInterface
virtual css::uno::Any SAL_CALL
queryInterface( const css::uno::Type & rType ) override;
virtual void SAL_CALL acquire()
throw() override;
virtual void SAL_CALL release()
throw() override;
// XTypeProvider
virtual css::uno::Sequence< css::uno::Type > SAL_CALL
getTypes() override;
virtual css::uno::Sequence< sal_Int8 > SAL_CALL
getImplementationId() override;
// XInteractionContinuation
virtual void SAL_CALL select() override;
};
/**
* This class implements a standard interaction continuation, namely the
* interface XInteractionRetry. Instances of this class can be passed
* along with an interaction request to indicate the possibility to retry
* the operation that caused the request.
*/
class UCBHELPER_DLLPUBLIC InteractionRetry final : public InteractionContinuation,
public css::lang::XTypeProvider,
public css::task::XInteractionRetry
{
public:
InteractionRetry( InteractionRequest * pRequest )
: InteractionContinuation( pRequest ) {}
// XInterface
virtual css::uno::Any SAL_CALL
queryInterface( const css::uno::Type & rType ) override;
virtual void SAL_CALL acquire()
throw() override;
virtual void SAL_CALL release()
throw() override;
// XTypeProvider
virtual css::uno::Sequence< css::uno::Type > SAL_CALL
getTypes() override;
virtual css::uno::Sequence< sal_Int8 > SAL_CALL
getImplementationId() override;
// XInteractionContinuation
virtual void SAL_CALL select() override;
};
/**
* This class implements a standard interaction continuation, namely the
* interface XInteractionApprove. Instances of this class can be passed
* along with an interaction request to indicate the possibility to approve
* the request.
*/
class UCBHELPER_DLLPUBLIC InteractionApprove final : public InteractionContinuation,
public css::lang::XTypeProvider,
public css::task::XInteractionApprove
{
public:
InteractionApprove( InteractionRequest * pRequest )
: InteractionContinuation( pRequest ) {}
// XInterface
virtual css::uno::Any SAL_CALL
queryInterface( const css::uno::Type & rType ) override;
virtual void SAL_CALL acquire()
throw() override;
virtual void SAL_CALL release()
throw() override;
// XTypeProvider
virtual css::uno::Sequence< css::uno::Type > SAL_CALL
getTypes() override;
virtual css::uno::Sequence< sal_Int8 > SAL_CALL
getImplementationId() override;
// XInteractionContinuation
virtual void SAL_CALL select() override;
};
/**
* This class implements a standard interaction continuation, namely the
* interface XInteractionDisapprove. Instances of this class can be passed
* along with an interaction request to indicate the possibility to disapprove
* the request.
*/
class UCBHELPER_DLLPUBLIC InteractionDisapprove final : public InteractionContinuation,
public css::lang::XTypeProvider,
public css::task::XInteractionDisapprove
{
public:
InteractionDisapprove( InteractionRequest * pRequest )
: InteractionContinuation( pRequest ) {}
// XInterface
virtual css::uno::Any SAL_CALL
queryInterface( const css::uno::Type & rType ) override;
virtual void SAL_CALL acquire()
throw() override;
virtual void SAL_CALL release()
throw() override;
// XTypeProvider
virtual css::uno::Sequence< css::uno::Type > SAL_CALL
getTypes() override;
virtual css::uno::Sequence< sal_Int8 > SAL_CALL
getImplementationId() override;
// XInteractionContinuation
virtual void SAL_CALL select() override;
};
/**
* This class implements a standard interaction continuation, namely the
* interface XInteractionSupplyAuthentication. Instances of this class can be
* passed along with an authentication interaction request to enable the
* interaction handler to supply the missing authentication data.
*/
class UCBHELPER_DLLPUBLIC InteractionSupplyAuthentication final :
public InteractionContinuation,
public css::lang::XTypeProvider,
public css::ucb::XInteractionSupplyAuthentication2
{
css::uno::Sequence< css::ucb::RememberAuthentication > const
m_aRememberPasswordModes;
css::uno::Sequence< css::ucb::RememberAuthentication > const
m_aRememberAccountModes;
OUString m_aRealm;
OUString m_aUserName;
OUString m_aPassword;
css::ucb::RememberAuthentication m_eRememberPasswordMode;
css::ucb::RememberAuthentication const m_eDefaultRememberPasswordMode;
css::ucb::RememberAuthentication const m_eDefaultRememberAccountMode;
bool const m_bCanSetRealm : 1;
bool const m_bCanSetUserName : 1;
bool const m_bCanSetPassword : 1;
bool const m_bCanSetAccount : 1;
bool const m_bCanUseSystemCredentials : 1;
bool m_bUseSystemCredentials : 1;
public:
/**
* Constructor.
*
* Note: The remember-authentication stuff is interesting only for
* clients implementing own password storage functionality.
*
* @param rxRequest is the interaction request that owns this continuation.
* @param bCanSetRealm indicates, whether the realm given with the
* authentication request is read-only.
* @param bCanSetUserName indicates, whether the username given with the
* authentication request is read-only.
* @param bCanSetPassword indicates, whether the password given with the
* authentication request is read-only.
* @param bCanSetAccount indicates, whether the account given with the
* authentication request is read-only.
* @param rRememberPasswordModes specifies the authentication-remember-
* modes for passwords supported by the requesting client.
* @param eDefaultRememberPasswordMode specifies the default
* authentication-remember-mode for passwords preferred by the
* requesting client.
* @param rRememberAccountModes specifies the authentication-remember-
* modes for accounts supported by the requesting client.
* @param eDefaultRememberAccountMode specifies the default
* authentication-remember-mode for accounts preferred by the
* requesting client.
* @param bCanUseSystemCredentials indicates whether issuer of the
* authentication request can obtain and use system credentials
* for authentication.
*
* @see css::ucb::AuthenticationRequest
* @see css::ucb::RememberAuthentication
*/
inline InteractionSupplyAuthentication(
InteractionRequest * pRequest,
bool bCanSetRealm,
bool bCanSetUserName,
bool bCanSetPassword,
bool bCanSetAccount,
const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberPasswordModes,
const css::ucb::RememberAuthentication eDefaultRememberPasswordMode,
const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberAccountModes,
const css::ucb::RememberAuthentication eDefaultRememberAccountMode,
bool bCanUseSystemCredentials );
// XInterface
virtual css::uno::Any SAL_CALL
queryInterface( const css::uno::Type & rType ) override;
virtual void SAL_CALL acquire()
throw() override;
virtual void SAL_CALL release()
throw() override;
// XTypeProvider
virtual css::uno::Sequence< css::uno::Type > SAL_CALL
getTypes() override;
virtual css::uno::Sequence< sal_Int8 > SAL_CALL
getImplementationId() override;
// XInteractionContinuation
virtual void SAL_CALL select() override;
// XInteractionSupplyAuthentication
virtual sal_Bool SAL_CALL
canSetRealm() override;
virtual void SAL_CALL
setRealm( const OUString& Realm ) override;
virtual sal_Bool SAL_CALL
canSetUserName() override;
virtual void SAL_CALL
setUserName( const OUString& UserName ) override;
virtual sal_Bool SAL_CALL
canSetPassword() override;
virtual void SAL_CALL
setPassword( const OUString& Password ) override;
virtual css::uno::Sequence<
css::ucb::RememberAuthentication > SAL_CALL
getRememberPasswordModes(
css::ucb::RememberAuthentication& Default ) override;
virtual void SAL_CALL
setRememberPassword( css::ucb::RememberAuthentication Remember ) override;
virtual sal_Bool SAL_CALL
canSetAccount() override;
virtual void SAL_CALL
setAccount( const OUString& Account ) override;
virtual css::uno::Sequence< css::ucb::RememberAuthentication > SAL_CALL
getRememberAccountModes(
css::ucb::RememberAuthentication& Default ) override;
virtual void SAL_CALL
setRememberAccount( css::ucb::RememberAuthentication Remember ) override;
// XInteractionSupplyAuthentication2
virtual sal_Bool SAL_CALL canUseSystemCredentials( sal_Bool& Default ) override;
virtual void SAL_CALL setUseSystemCredentials( sal_Bool UseSystemCredentials ) override;
// Non-interface methods.
/**
* This method returns the realm that was supplied by the interaction
* handler.
*
* @return the realm.
*/
const OUString & getRealm() const { return m_aRealm; }
/**
* This method returns the username that was supplied by the interaction
* handler.
*
* @return the username.
*/
const OUString & getUserName() const { return m_aUserName; }
/**
* This method returns the password that was supplied by the interaction
* handler.
*
* @return the password.
*/
const OUString & getPassword() const { return m_aPassword; }
/**
* This method returns the authentication remember-mode for the password
* that was supplied by the interaction handler.
*
* @return the remember-mode for the password.
*/
const css::ucb::RememberAuthentication &
getRememberPasswordMode() const { return m_eRememberPasswordMode; }
bool getUseSystemCredentials() const { return m_bUseSystemCredentials; }
};
inline InteractionSupplyAuthentication::InteractionSupplyAuthentication(
InteractionRequest * pRequest,
bool bCanSetRealm,
bool bCanSetUserName,
bool bCanSetPassword,
bool bCanSetAccount,
const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberPasswordModes,
const css::ucb::RememberAuthentication eDefaultRememberPasswordMode,
const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberAccountModes,
const css::ucb::RememberAuthentication eDefaultRememberAccountMode,
bool bCanUseSystemCredentials )
: InteractionContinuation( pRequest ),
m_aRememberPasswordModes( rRememberPasswordModes ),
m_aRememberAccountModes( rRememberAccountModes ),
m_eRememberPasswordMode( eDefaultRememberPasswordMode ),
m_eDefaultRememberPasswordMode( eDefaultRememberPasswordMode ),
m_eDefaultRememberAccountMode( eDefaultRememberAccountMode ),
m_bCanSetRealm( bCanSetRealm ),
m_bCanSetUserName( bCanSetUserName ),
m_bCanSetPassword( bCanSetPassword ),
m_bCanSetAccount( bCanSetAccount ),
m_bCanUseSystemCredentials( bCanUseSystemCredentials ),
m_bUseSystemCredentials( false )
{
}
/**
* This class implements a standard interaction continuation, namely the
* interface XInteractionReplaceExistingData. Instances of this class can be
* passed along with an interaction request to indicate the possibility to
* replace existing data.
*/
class InteractionReplaceExistingData final :
public InteractionContinuation,
public css::lang::XTypeProvider,
public css::ucb::XInteractionReplaceExistingData
{
public:
InteractionReplaceExistingData( InteractionRequest * pRequest )
: InteractionContinuation( pRequest ) {}
// XInterface
virtual css::uno::Any SAL_CALL
queryInterface( const css::uno::Type & rType ) override;
virtual void SAL_CALL acquire()
throw() override;
virtual void SAL_CALL release()
throw() override;
// XTypeProvider
virtual css::uno::Sequence< css::uno::Type > SAL_CALL
getTypes() override;
virtual css::uno::Sequence< sal_Int8 > SAL_CALL
getImplementationId() override;
// XInteractionContinuation
virtual void SAL_CALL select() override;
};
class UCBHELPER_DLLPUBLIC InteractionAuthFallback final :
public InteractionContinuation,
public css::ucb::XInteractionAuthFallback
{
OUString m_aCode;
public:
InteractionAuthFallback( InteractionRequest * pRequest )
: InteractionContinuation( pRequest ) {}
// XInterface
virtual css::uno::Any SAL_CALL
queryInterface( const css::uno::Type & rType ) override;
virtual void SAL_CALL acquire()
throw() override;
virtual void SAL_CALL release()
throw() override;
// XInteractionContinuation
virtual void SAL_CALL select() override;
// XAuthFallback
virtual void SAL_CALL setCode( const OUString& code ) override;
/// @throws css::uno::RuntimeException
const OUString& getCode() const;
};
} // namespace ucbhelper
#endif /* ! INCLUDED_UCBHELPER_INTERACTIONREQUEST_HXX */
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */