/**************************************************************
*
* 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 _DBA_COREDATAACCESS_MODELIMPL_HXX_
#define _DBA_COREDATAACCESS_MODELIMPL_HXX_
#include "apitools.hxx"
#include "bookmarkcontainer.hxx"
#include "ContentHelper.hxx"
#include "core_resource.hxx"
#include "documentevents.hxx"
/** === begin UNO includes === **/
#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/XPropertyAccess.hpp>
#include <com/sun/star/container/XContainerListener.hpp>
#include <com/sun/star/document/XDocumentSubStorageSupplier.hpp>
#include <com/sun/star/document/XEventListener.hpp>
#include <com/sun/star/document/XStorageBasedDocument.hpp>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/XStorage.hpp>
#include <com/sun/star/embed/XTransactionListener.hpp>
#include <com/sun/star/frame/XModel.hpp>
#include <com/sun/star/frame/XStorable.hpp>
#include <com/sun/star/lang/NotInitializedException.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
#include <com/sun/star/sdb/XBookmarksSupplier.hpp>
#include <com/sun/star/sdb/XCompletedConnection.hpp>
#include <com/sun/star/sdb/XFormDocumentsSupplier.hpp>
#include <com/sun/star/sdb/XQueryDefinitionsSupplier.hpp>
#include <com/sun/star/sdb/XReportDocumentsSupplier.hpp>
#include <com/sun/star/sdbc/XDataSource.hpp>
#include <com/sun/star/sdbc/XIsolatedConnection.hpp>
#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
#include <com/sun/star/util/XCloseable.hpp>
#include <com/sun/star/util/XFlushable.hpp>
#include <com/sun/star/util/XModifiable.hpp>
#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
#include <com/sun/star/util/XNumberFormatter.hpp>
#include <com/sun/star/util/XRefreshable.hpp>
#include <com/sun/star/sdb/XDocumentDataSource.hpp>
#include <com/sun/star/frame/DoubleInitializationException.hpp>
/** === end UNO includes === **/
#include <comphelper/broadcasthelper.hxx>
#include <comphelper/namedvaluecollection.hxx>
#include <comphelper/proparrhlp.hxx>
#include <comphelper/sharedmutex.hxx>
#include <connectivity/CommonTools.hxx>
#include <cppuhelper/propshlp.hxx>
#include <cppuhelper/weakref.hxx>
#include <sfx2/docmacromode.hxx>
#include <sfx2/docstoragemodifylistener.hxx>
#include <tools/string.hxx>
#include <unotools/sharedunocomponent.hxx>
#include <vos/mutex.hxx>
#include <memory>
namespace comphelper
{
class NamedValueCollection;
}
//........................................................................
namespace dbaccess
{
//........................................................................
typedef ::com::sun::star::uno::WeakReference< ::com::sun::star::sdbc::XConnection > OWeakConnection;
typedef std::vector< OWeakConnection > OWeakConnectionArray;
struct AsciiPropertyValue
{
// note: the canonic member order would be AsciiName / DefaultValue, but
// this crashes on unxlngi6.pro, since there's a bug which somehow results in
// getDefaultDataSourceSettings returning corrupted Any instances then.
::com::sun::star::uno::Any DefaultValue;
const sal_Char* AsciiName;
const ::com::sun::star::uno::Type& ValueType;
AsciiPropertyValue()
:DefaultValue( )
,AsciiName( NULL )
,ValueType( ::cppu::UnoType< ::cppu::UnoVoidType >::get() )
{
}
AsciiPropertyValue( const sal_Char* _pAsciiName, const ::com::sun::star::uno::Any& _rDefaultValue )
:DefaultValue( _rDefaultValue )
,AsciiName( _pAsciiName )
,ValueType( _rDefaultValue.getValueType() )
{
OSL_ENSURE( ValueType.getTypeClass() != ::com::sun::star::uno::TypeClass_VOID,
"AsciiPropertyValue::AsciiPropertyValue: NULL values not allowed here, use the other CTOR for this!" );
}
AsciiPropertyValue( const sal_Char* _pAsciiName, const ::com::sun::star::uno::Type& _rValeType )
:DefaultValue()
,AsciiName( _pAsciiName )
,ValueType( _rValeType )
{
OSL_ENSURE( ValueType.getTypeClass() != ::com::sun::star::uno::TypeClass_VOID,
"AsciiPropertyValue::AsciiPropertyValue: VOID property values not supported!" );
}
};
class ODatabaseContext;
class OSharedConnectionManager;
//============================================================
//= VosMutexFacade
//============================================================
/** a class which provides an IMutex interface to an OSL-based mutex
*/
class VosMutexFacade : public ::vos::IMutex
{
public:
/** beware of life time: the mutex you pass here must live as least as long
as the VosMutexFacade instance lives.
*/
VosMutexFacade( ::osl::Mutex& _rMutex );
// IMutex
virtual void SAL_CALL acquire();
virtual sal_Bool SAL_CALL tryToAcquire();
virtual void SAL_CALL release();
private:
::osl::Mutex& m_rMutex;
};
//============================================================
//= ODatabaseModelImpl
//============================================================
typedef ::utl::SharedUNOComponent< ::com::sun::star::embed::XStorage > SharedStorage;
class ODatabaseContext;
class DocumentStorageAccess;
class OSharedConnectionManager;
class ODatabaseModelImpl :public ::rtl::IReference
,public ::sfx2::IMacroDocumentAccess
,public ::sfx2::IModifiableDocument
{
public:
enum ObjectType
{
E_FORM = 0,
E_REPORT = 1,
E_QUERY = 2,
E_TABLE = 3
};
enum EmbeddedMacros
{
// the database document (storage) itself contains macros
eDocumentWideMacros,
// there are sub document( storage)s containing macros
eSubDocumentMacros,
// there are no known macro( storage)s
eNoMacros
};
private:
OModuleClient m_aModuleClient;
::com::sun::star::uno::WeakReference< ::com::sun::star::frame::XModel > m_xModel;
::com::sun::star::uno::WeakReference< ::com::sun::star::sdbc::XDataSource > m_xDataSource;
DocumentStorageAccess* m_pStorageAccess;
::comphelper::SharedMutex m_aMutex;
VosMutexFacade m_aMutexFacade;
::std::vector< TContentPtr > m_aContainer; // one for each ObjectType
::sfx2::DocumentMacroMode m_aMacroMode;
sal_Int16 m_nImposedMacroExecMode;
::com::sun::star::uno::Reference< ::com::sun::star::script::XStorageBasedLibraryContainer > m_xBasicLibraries;
::com::sun::star::uno::Reference< ::com::sun::star::script::XStorageBasedLibraryContainer > m_xDialogLibraries;
SharedStorage m_xDocumentStorage;
::rtl::Reference< ::sfx2::DocumentStorageModifyListener > m_pStorageModifyListener;
ODatabaseContext* m_pDBContext;
DocumentEventsData m_aDocumentEvents;
::comphelper::NamedValueCollection m_aMediaDescriptor;
/// the URL the document was loaded from
::rtl::OUString m_sDocFileLocation;
oslInterlockedCount m_refCount;
/// do we have any object (forms/reports) which contains macros?
::boost::optional< EmbeddedMacros > m_aEmbeddedMacros;
/// true if setting the Modified flag of the document is currently locked
bool m_bModificationLock;
/// true if and only if a database document existed previously (though meanwhile disposed), and was already initialized
bool m_bDocumentInitialized;
/** the URL which the document should report as it's URL
This might differ from ->m_sDocFileLocation in case the document was loaded
as part of a crash recovery process. In this case, ->m_sDocFileLocation points to
the temporary file where the DB had been saved to, after a crash.
->m_sDocumentURL then is the URL of the document which actually had
been recovered.
*/
::rtl::OUString m_sDocumentURL;
public:
OWeakConnectionArray m_aConnections;
const ::comphelper::ComponentContext m_aContext;
public:
::com::sun::star::uno::WeakReference< ::com::sun::star::container::XNameAccess > m_xCommandDefinitions;
::com::sun::star::uno::WeakReference< ::com::sun::star::container::XNameAccess > m_xTableDefinitions;
::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >
m_xNumberFormatsSupplier;
::rtl::OUString m_sConnectURL;
::rtl::OUString m_sName; // transient, our creator has to tell us the title
::rtl::OUString m_sUser;
::rtl::OUString m_aPassword; // transient !
::rtl::OUString m_sFailedPassword;
::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue>
m_aLayoutInformation;
sal_Int32 m_nLoginTimeout;
sal_Bool m_bReadOnly : 1;
sal_Bool m_bPasswordRequired : 1;
sal_Bool m_bSuppressVersionColumns : 1;
sal_Bool m_bModified : 1;
sal_Bool m_bDocumentReadOnly : 1;
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyAccess >
m_xSettings;
::com::sun::star::uno::Sequence< ::rtl::OUString > m_aTableFilter;
::com::sun::star::uno::Sequence< ::rtl::OUString > m_aTableTypeFilter;
OSharedConnectionManager* m_pSharedConnectionManager;
::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >
m_xSharedConnectionManager;
sal_uInt16 m_nControllerLockCount;
void reset();
/** determines whether the database document has an embedded data storage
*/
inline bool isEmbeddedDatabase() const { return ( m_sConnectURL.compareToAscii( "sdbc:embedded:", 14 ) == 0 ); }
/** stores the embedded storage ("database")
@param _bPreventRootCommits
Normally, committing the embedded storage results in also committing the root storage
- this is an automatism for data safety reasons.
If you pass <TRUE/> here, committing the root storage is prevented for this particular
call.
@return <TRUE/> if the storage could be commited, otherwise <FALSE/>
*/
bool commitEmbeddedStorage( bool _bPreventRootCommits = false );
/// commits all sub storages
void commitStorages()
SAL_THROW(( ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException ));
ODatabaseModelImpl(
const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxFactory,
ODatabaseContext& _pDBContext
);
virtual ~ODatabaseModelImpl();
ODatabaseModelImpl(
const ::rtl::OUString& _rRegistrationName,
const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxFactory,
ODatabaseContext& _rDBContext
);
// XEventListener
void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw(::com::sun::star::uno::RuntimeException);
void setModified( sal_Bool bModified );
void dispose();
inline ::rtl::OUString getURL() const { return m_sDocumentURL; }
inline ::rtl::OUString getDocFileLocation() const { return m_sDocFileLocation; }
::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >
getStorage(
const ObjectType _eType, const sal_Int32 _nDesiredMode = ::com::sun::star::embed::ElementModes::READWRITE );
// helper
const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >&
getNumberFormatsSupplier();
DocumentEventsData&
getDocumentEvents() { return m_aDocumentEvents; }
const ::comphelper::NamedValueCollection&
getMediaDescriptor() const { return m_aMediaDescriptor; }
void setResource(
const ::rtl::OUString& _rURL,
const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& _rArgs
);
void setDocFileLocation(
const ::rtl::OUString& i_rLoadedFrom
);
static ::comphelper::NamedValueCollection
stripLoadArguments( const ::comphelper::NamedValueCollection& _rArguments );
// other stuff
void flushTables();
// disposes all elements in m_aStorages, and clears it
void disposeStorages() SAL_THROW(());
/// creates a ->com::sun::star::embed::StorageFactory
::com::sun::star::uno::Reference< ::com::sun::star::lang::XSingleServiceFactory >
createStorageFactory() const;
/// commits our storage
void commitRootStorage();
/// commits a given storage if it's not readonly, ignoring (but asserting) all errors
static bool commitStorageIfWriteable_ignoreErrors(
const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& _rxStorage
)
SAL_THROW(());
void clearConnections();
::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > getOrCreateRootStorage();
inline ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > getRootStorage() const { return m_xDocumentStorage.getTyped(); }
inline void resetRootStroage() { impl_switchToStorage_throw( NULL ); }
/** returns the data source. If it doesn't exist it will be created
*/
::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XDataSource> getOrCreateDataSource();
/** returns the model, if there already exists one
*/
::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel > getModel_noCreate() const;
/** returns a new ->ODatabaseDocument
@param _bInitializeIfNecessary
calls XLoadable::initNew on the newly created model, if necessary
@precond
No ->ODatabaseDocument exists so far
@seealso
getModel_noCreate
*/
::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel > createNewModel_deliverOwnership( bool _bInitialize );
struct ResetModelAccess { friend class ODatabaseDocument; private: ResetModelAccess() { } };
/** resets the model to NULL
Only to be called when the model is being disposed
*/
void modelIsDisposing( const bool _wasInitialized, ResetModelAccess );
bool hadInitializedDocument() const { return m_bDocumentInitialized; }
DocumentStorageAccess*
getDocumentStorageAccess();
::com::sun::star::uno::Reference< ::com::sun::star::document::XDocumentSubStorageSupplier >
getDocumentSubStorageSupplier();
inline const ::comphelper::SharedMutex& getSharedMutex() const { return m_aMutex; }
/** @see osl_incrementInterlockedCount.
*/
virtual oslInterlockedCount SAL_CALL acquire();
/** @see osl_decrementInterlockedCount.
*/
virtual oslInterlockedCount SAL_CALL release();
/// returns a all known data source settings, including their default values
static const AsciiPropertyValue* getDefaultDataSourceSettings();
/** retrieves the requested container of objects (forms/reports/tables/queries)
*/
TContentPtr& getObjectContainer( const ObjectType _eType );
/** returns the name of the storage which is used to stored objects of the given type, if applicable
*/
static ::rtl::OUString
getObjectContainerStorageName( const ObjectType _eType );
/** revokes the data source registration at the database context
*/
void revokeDataSource() const;
/** determines whether a given object storage contains macros
*/
static bool objectHasMacros(
const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& _rxContainerStorage,
const ::rtl::OUString& _rPersistentName
);
/** determines which kind of embedded macros are present in the document
*/
EmbeddedMacros determineEmbeddedMacros();
/** checks our document's macro execution mode, using the interaction handler as supplied with our
load arguments
*/
bool checkMacrosOnLoading();
/** adjusts our document's macro execution mode, without using any UI, assuming the user
would reject execution of macros, if she would have been asked.
If checkMacrosOnLoading has been called before (and thus the macro execution mode
is already adjusted), then the current execution mode is simply returned.
@return
whether or not macro execution is allowed
*/
bool adjustMacroMode_AutoReject();
/** resets our macro execute mode, so next time the checkMacrosOnLoading is called, it will
behave as if it has never been called before
*/
void resetMacroExecutionMode();
/** ensures that ->m_xBasicLibraries resp. m_xDialogLibraries exists
@return
the requested library container. Is never <NULL/>.
@throws RuntimeException
if something does wrong, which indicates a server error in the installation
*/
::com::sun::star::uno::Reference< ::com::sun::star::script::XStorageBasedLibraryContainer >
getLibraryContainer( bool _bScript );
/** lets our library containers store themself into the given root storage
*/
void storeLibraryContainersTo( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& _rxToRootStorage );
/** rebases the document to the given storage
No actual committing, copying, saving, whatsoever happens. The storage is just remembered as the documents
new storage, nothing more.
@throws ::com::sun::star::lang::IllegalArgumentException
if the given storage is <NULL/>
@throws ::com::sun::star::lang::RuntimeException
if any of the invoked operations does so
*/
::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >
switchToStorage(
const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& _rxNewRootStorage
);
/** returns the macro mode imposed by an external instance, which passed it to attachResource
*/
sal_Int16 getImposedMacroExecMode() const
{
return m_nImposedMacroExecMode;
}
void setImposedMacroExecMode( const sal_Int16 _nMacroMode )
{
m_nImposedMacroExecMode = _nMacroMode;
}
public:
// IMacroDocumentAccess overridables
virtual sal_Int16 getCurrentMacroExecMode() const;
virtual sal_Bool setCurrentMacroExecMode( sal_uInt16 );
virtual ::rtl::OUString getDocumentLocation() const;
virtual ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > getZipStorageToSign();
virtual sal_Bool documentStorageHasMacros() const;
virtual ::com::sun::star::uno::Reference< ::com::sun::star::document::XEmbeddedScripts > getEmbeddedDocumentScripts() const;
virtual sal_Int16 getScriptingSignatureState();
virtual sal_Bool hasTrustedScriptingSignature( sal_Bool bAllowUIToAddAuthor );
virtual void showBrokenSignatureWarning( const ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionHandler >& _rxInteraction ) const;
// IModifiableDocument
virtual void storageIsModified();
// don't use directly, use the ModifyLock class instead
void lockModify() { m_bModificationLock = true; }
void unlockModify() { m_bModificationLock = false; }
bool isModifyLocked() const { return m_bModificationLock; }
private:
void impl_construct_nothrow();
::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >
impl_switchToStorage_throw( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& _rxNewRootStorage );
/** switches to the given document URL, which denotes the logical URL of the document, not necessariy the
URL where the doc was loaded/recovered from
*/
void impl_switchToLogicalURL(
const ::rtl::OUString& i_rDocumentURL
);
};
/** a small base class for UNO components whose functionality depends on a ODatabaseModelImpl
*/
class ModelDependentComponent
{
protected:
::rtl::Reference< ODatabaseModelImpl > m_pImpl;
mutable ::comphelper::SharedMutex m_aMutex;
protected:
ModelDependentComponent( const ::rtl::Reference< ODatabaseModelImpl >& _model );
virtual ~ModelDependentComponent();
/** returns the component itself
*/
virtual ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > getThis() const = 0;
inline ::osl::Mutex& getMutex() const
{
return m_aMutex;
}
public:
struct GuardAccess { friend class ModelMethodGuard; private: GuardAccess() { } };
/** returns the mutex used for thread safety
@throws ::com::sun::star::lang::DisposedException
if m_pImpl is <NULL/>. Usually, you will set this member in your derived
component's <code>dispose</code> method to <NULL/>.
*/
inline ::osl::Mutex& getMutex( GuardAccess ) const
{
return getMutex();
}
inline ::rtl::Reference< ODatabaseModelImpl > getImpl( GuardAccess )
{
return m_pImpl;
}
/// checks whether the component is already disposed, throws a DisposedException if so
inline void checkDisposed() const
{
if ( !m_pImpl.is() )
throw ::com::sun::star::lang::DisposedException( ::rtl::OUString::createFromAscii( "Component is already disposed." ), getThis() );
}
inline void lockModify()
{
m_pImpl->lockModify();
}
inline void unlockModify()
{
m_pImpl->unlockModify();
}
};
class ModifyLock
{
public:
ModifyLock( ModelDependentComponent& _component )
:m_rComponent( _component )
{
m_rComponent.lockModify();
}
~ModifyLock()
{
m_rComponent.unlockModify();
}
private:
ModelDependentComponent& m_rComponent;
};
/** a guard for public methods of objects dependent on a ODatabaseModelImpl instance
Just put this guard onto the stack at the beginning of your method. Don't bother yourself
with a MutexGuard, checks for being disposed, and the like.
*/
class ModelMethodGuard : public ::osl::ResettableMutexGuard
{
private:
typedef ::osl::ResettableMutexGuard BaseMutexGuard;
public:
/** constructs the guard
@param _component
the component whose functionality depends on a ODatabaseModelImpl instance
@throws ::com::sun::star::lang::DisposedException
If the given component is already disposed
*/
ModelMethodGuard( const ModelDependentComponent& _component )
:BaseMutexGuard( _component.getMutex( ModelDependentComponent::GuardAccess() ) )
{
_component.checkDisposed();
}
~ModelMethodGuard()
{
}
};
//........................................................................
} // namespace dbaccess
//........................................................................
#endif // _DBA_COREDATAACCESS_DATALINK_HXX_