/* -*- 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 .
*/
class ODatabaseContext; class DocumentStorageAccess; class ODatabaseSource; class ODatabaseDocument;
/** The class OSharedConnectionManager implements a structure to share connections. It owns the master connections which will be disposed when the last connection proxy is gone.
*/ // need to hold the digest struct TDigestHolder
{
sal_uInt8 m_pBuffer[RTL_DIGEST_LENGTH_SHA1];
TDigestHolder()
{
m_pBuffer[0] = 0;
}
};
class OSharedConnectionManager : public ::cppu::WeakImplHelper< css::lang::XEventListener >
{ // contains the currently used master connections struct TConnectionHolder
{
rtl::Reference< OConnection > xMasterConnection;
oslInterlockedCount nALiveCount;
};
// the less-compare functor, used for the stl::map struct TDigestLess
{ booloperator() (const TDigestHolder& x, const TDigestHolder& y) const
{
sal_uInt32 i; for(i=0;i < RTL_DIGEST_LENGTH_SHA1 && (x.m_pBuffer[i] >= y.m_pBuffer[i]); ++i)
; return i < RTL_DIGEST_LENGTH_SHA1;
}
};
typedef std::map< TDigestHolder,TConnectionHolder,TDigestLess> TConnectionMap; // holds the master connections typedef std::map< css::uno::Reference< css::sdbc::XConnection >,TConnectionMap::iterator> TSharedConnectionMap;// holds the shared connections
::osl::Mutex m_aMutex;
TConnectionMap m_aConnections; // remember the master connection in conjunction with the digest
TSharedConnectionMap m_aSharedConnection; // the shared connections with conjunction with an iterator into the connections map
css::uno::Reference< css::reflection::XProxyFactory > m_xProxyFactory;
class ODatabaseModelImpl :public ::sfx2::IMacroDocumentAccess
,public ::sfx2::IModifiableDocument
{ public:
enumclass ObjectType
{
Form = 0,
Report = 1,
Query = 2,
Table = 3,
LAST = Table
};
enumclass EmbeddedMacros
{ // the database document (storage) itself contains macros
DocumentWide, // there are sub document( storage)s containing macros
SubDocument, // there are no known macro( storage)s
NONE
};
::comphelper::NamedValueCollection m_aMediaDescriptor; /// the URL the document was loaded from
OUString m_sDocFileLocation;
oslInterlockedCount m_refCount;
/// do we have any object (forms/reports) which contains macros?
::std::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 its 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.
*/
OUString m_sDocumentURL;
/** determines whether the database document has an embedded data storage
*/ bool isEmbeddedDatabase() const { return m_sConnectURL.startsWith("sdbc:embedded:"); }
/** 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 committed, otherwise <FALSE/>
*/ bool commitEmbeddedStorage( bool _bPreventRootCommits = false );
/// commits all sub storages void commitStorages();
// disposes all elements in m_aStorages, and clears it void disposeStorages();
/// creates a ->css::embed::StorageFactory
css::uno::Reference< css::lang::XSingleServiceFactory >
createStorageFactory() const;
/// commits our storage void commitRootStorage();
/// commits a given storage if it's not readonly, ignoring (but asserting) all errors bool commitStorageIfWriteable_ignoreErrors( const css::uno::Reference< css::embed::XStorage >& _rxStorage
);
/// returns all known data source settings, including their default values static std::span<const DefaultPropertyValue> 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 OUString
getObjectContainerStorageName( const ObjectType _eType );
/** 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
*/
css::uno::Reference< css::script::XStorageBasedLibraryContainer >
getLibraryContainer( bool _bScript );
/** lets our library containers store themselves into the given root storage
*/ void storeLibraryContainersTo( const css::uno::Reference< css::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 css::lang::IllegalArgumentException if the given storage is <NULL/> @throws css::lang::RuntimeException if any of the invoked operations does so
*/
css::uno::Reference< css::embed::XStorage >
switchToStorage( const css::uno::Reference< css::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;
}
/** switches to the given document URL, which denotes the logical URL of the document, not necessarily the URL where the doc was loaded/recovered from
*/ void impl_switchToLogicalURL( const OUString& i_rDocumentURL
);
};
/** a small base class for UNO components whose functionality depends on an ODatabaseModelImpl
*/ class ModelDependentComponent
{ protected:
::rtl::Reference< ODatabaseModelImpl > m_pImpl;
::osl::Mutex m_aMutex; // only use this to init WeakComponentImplHelper
public: /// checks whether the component is already disposed, throws a DisposedException if so void checkDisposed() const
{ if ( !m_pImpl.is() ) throw css::lang::DisposedException( u"Component is already disposed."_ustr, getThis() );
}
/** a guard for public methods of objects dependent on an 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
{ private: // to avoid deadlocks, lock SolarMutex
SolarMutexResettableGuard m_SolarGuard;
public: /** constructs the guard
@param _component the component whose functionality depends on an ODatabaseModelImpl instance
@throws css::lang::DisposedException If the given component is already disposed
*/ explicit ModelMethodGuard( const ModelDependentComponent& _component )
{
_component.checkDisposed();
}
void clear()
{ // note: this only releases *once* so may still be locked
m_SolarGuard.clear();
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
