strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[API CHANGE] Deprecate css.registry.XSimpleRegistry::mergeKey

Browse source 
...and let its implementations just throw a RuntimeException, now that regmerge
has been removed in "[API CHANGE] Remove deprecated idlc and regmerge from the
SDK".  Deprecate css.registry.MergeConflictException along with it (though
stoc/source/implementationregistration/ still uses it internally).  And remove
the previously unused include/registry/writer.hxx along with the newly unused
include/registry/writer.h, RegistryTypeWriter, and RegistryTypeReader.

Change-Id: I10fd286617975dc0ef9f74460a3a3eab8060939d
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/123615
Tested-by: Jenkins
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
This commit is contained in:
Stephan Bergmann 2021-09-17 13:37:42 +02:00
parent 3ae546f97b
commit 25fc5f91ab
17 changed files with 11 additions and 2664 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
include/registry/refltype.hxx
View file

@ -23,17 +23,6 @@
#include <registry/types.hxx>
#include <sal/types.h>
/** specifies the type source of a binary type blob.
Currently only RT_UNO_IDL type is used.
*/
enum RTTypeSource
{
RT_UNO_IDL,
RT_CORBA_IDL,
RT_JAVA
};
/** specifies a helper class for const values.
This class is used for easy handling of constants or enum values
@ -55,20 +44,6 @@ public:
}
};
/** deprecated.
An earlier version of UNO used a unique identifier for interfaces. In the
current version of UNO this uik was eliminated and this type is no longer used.
*/
struct RTUik
{
sal_uInt32 m_Data1;
sal_uInt16 m_Data2;
sal_uInt16 m_Data3;
sal_uInt32 m_Data4;
sal_uInt32 m_Data5;
};
/// specifies the calling convention for type reader/writer api
#define TYPEREG_CALLTYPE SAL_CALL

26
include/registry/registry.hxx
View file

@ -40,7 +40,6 @@ struct Registry_Api
RegError (REGISTRY_CALLTYPE *openRegistry) (rtl_uString*, RegHandle*, RegAccessMode);
RegError (REGISTRY_CALLTYPE *closeRegistry) (RegHandle);
RegError (REGISTRY_CALLTYPE *destroyRegistry) (RegHandle, rtl_uString*);
RegError (REGISTRY_CALLTYPE *mergeKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*, sal_Bool, sal_Bool);
void (REGISTRY_CALLTYPE *acquireKey) (RegKeyHandle);
void (REGISTRY_CALLTYPE *releaseKey) (RegKeyHandle);
sal_Bool (REGISTRY_CALLTYPE *isKeyReadOnly) (RegKeyHandle);
@ -154,25 +153,6 @@ public:
*/
inline RegError destroy(const OUString& registryName);
/** merges the registry information of the specified key with the registry
information of the specified file.
All existing keys will be extended and existing key values will be overwritten.
@param rKey references a currently open key. The key which information is merged by this
function is a subkey of this key
@param keyName specifies the name of the key which will be merged.
If keyName is an empty string the registry information under the key specified
by rKey is merged with the information from the specified file.
@param regFileName specifies the file containing the registry information.
@param bReport if TRUE the function reports warnings on stdout if a key already exists.
@return RegError::NO_ERROR if succeeds else an error code. If it returns an error the registry will
restore the state before merging.
*/
inline RegError mergeKey(RegistryKey& rKey,
const OUString& keyName,
const OUString& regFileName,
bool bReport);
friend class RegistryKey;
friend class RegistryKeyArray;
friend class RegistryKeyNames;
@ -1050,10 +1030,4 @@ inline RegError Registry::destroy(const OUString& registryName)
return ret;
}
inline RegError Registry::mergeKey(RegistryKey& rKey,
const OUString& keyName,
const OUString& regFileName,
bool bReport)
{ return m_pApi->mergeKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData, false/*bWarnings*/, bReport); }
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

262
include/registry/writer.h
View file

@ -1,262 +0,0 @@
/* -*- 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_REGISTRY_WRITER_H
#define INCLUDED_REGISTRY_WRITER_H
#include <registry/regdllapi.h>
#include <registry/types.hxx>
#include <registry/version.h>
#include <rtl/ustring.h>
#include <sal/types.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
Creates a type writer working on a binary blob that represents a UNOIDL type.
<p>Operations on a returned handle are not multi-thread&ndash;safe.</p>
@param version the version of the created type writer; must not be negative
@param documentation the documentation; must not be null
@param fileName the file name; must not be null (deprecated, use an empty string)
@param typeClass the type class of the created type writer
@param published whether the created type writer is published; for a type
class that cannot be published, this should be false
@param typeName the type name of the created type writer; must not be null
@param superTypeCount the number of super types of the created type writer
@param fieldCount the number of fields of the created type writer
@param methodCount the number of methods of the created type writer
@param referenceCount the number of references of the created type writer
@return a handle on the type writer; if an out-of-memory condition occurs,
null is returned, and no type writer is created
@since UDK 3.2.0
*/
REG_DLLPUBLIC void * typereg_writer_create(
typereg_Version version, rtl_uString const * documentation,
rtl_uString const * fileName, RTTypeClass typeClass, sal_Bool published,
rtl_uString const * typeName, sal_uInt16 superTypeCount,
sal_uInt16 fieldCount, sal_uInt16 methodCount, sal_uInt16 referenceCount)
SAL_THROW_EXTERN_C();
/**
Destroys a type writer.
@param handle a handle on a type writer obtained from a call to
<code>typereg_writer_create</code>; must not be null
@since UDK 3.2.0
*/
REG_DLLPUBLIC void typereg_writer_destroy(void * handle) SAL_THROW_EXTERN_C();
/**
Sets the type name of a super type of a type writer.
@param handle a handle on a type writer; must not be null
@param index a valid index into the range of super types of the given type
writer
@param typeName the super type name; must not be null
@return false iff an out-of-memory condition occurred, in which case the type
writer is not modified
@since UDK 3.2.0
*/
REG_DLLPUBLIC sal_Bool typereg_writer_setSuperTypeName(
void const * handle, sal_uInt16 index, rtl_uString const * typeName)
SAL_THROW_EXTERN_C();
/**
Sets the data of a field of a type writer.
@param handle a handle on a type writer; must not be null
@param index a valid index into the range of fields of the given type writer
@param documentation the documentation of the field; must not be null
@param fileName the file name of the field; must not be null (deprecated, use an empty string)
@param flags the flags of the field
@param name the name of the field; must not be null
@param typeName the type name of the field; must not be null
@param valueType the type of the value of the field
@param valueValue the value of the value of the field
@return false iff an out-of-memory condition occurred, in which case the type
writer is not modified
@since UDK 3.2.0
*/
REG_DLLPUBLIC sal_Bool typereg_writer_setFieldData(
void * handle, sal_uInt16 index, rtl_uString const * documentation,
rtl_uString const * fileName, RTFieldAccess flags, rtl_uString const * name,
rtl_uString const * typeName, RTValueType valueType,
RTConstValueUnion valueValue)
SAL_THROW_EXTERN_C();
/**
Sets the data of a method of a type writer.
@param handle a handle on a type writer; must not be null
@param index a valid index into the range of methods of the given type writer
@param documentation the documentation of the method; must not be null
@param flags the flags of the method
@param name the name of the method; must not be null
@param returnTypeName the return type name of the method; must not be null
@param parameterCount the number of parameters of the method
@param exceptionCount the number of exceptions of the method
@return false iff an out-of-memory condition occurred, in which case the type
writer is not modified
@since UDK 3.2.0
*/
REG_DLLPUBLIC sal_Bool typereg_writer_setMethodData(
void * handle, sal_uInt16 index, rtl_uString const * documentation,
RTMethodMode flags, rtl_uString const * name,
rtl_uString const * returnTypeName, sal_uInt16 parameterCount,
sal_uInt16 exceptionCount)
SAL_THROW_EXTERN_C();
/**
Sets the data of a parameter of a method of a type writer.
@param handle a handle on a type writer; must not be null
@param methodIndex a valid index into the range of methods of the given type
writer
@param parameterIndex a valid index into the range of parameters of the given
method
@param flags the flags of the parameter
@param name the name of the parameter; must not be null
@param typeName the type name of the parameter; must not be null
@return false iff an out-of-memory condition occurred, in which case the type
writer is not modified
@since UDK 3.2.0
*/
REG_DLLPUBLIC sal_Bool typereg_writer_setMethodParameterData(
void const * handle, sal_uInt16 methodIndex, sal_uInt16 parameterIndex,
RTParamMode flags, rtl_uString const * name, rtl_uString const * typeName)
SAL_THROW_EXTERN_C();
/**
Sets an exception type name of a method of a type writer.
@param handle a handle on a type writer; must not be null
@param methodIndex a valid index into the range of methods of the given type
writer
@param exceptionIndex a valid index into the range of exceptions of the given
method
@param typeName the exception type name; must not be null
@return false iff an out-of-memory condition occurred, in which case the type
writer is not modified
@since UDK 3.2.0
*/
REG_DLLPUBLIC sal_Bool typereg_writer_setMethodExceptionTypeName(
void const * handle, sal_uInt16 methodIndex, sal_uInt16 exceptionIndex,
rtl_uString const * typeName)
SAL_THROW_EXTERN_C();
/**
Sets the data of a reference of a type writer.
@param handle a handle on a type writer; must not be null
@param index a valid index into the range of references of the given type
writer
@param documentation the documentation of the reference; must not be null
@param sort the sort of the reference
@param flags the flags of the reference
@param typeName the type name of the reference; must not be null
@return false iff an out-of-memory condition occurred, in which case the type
writer is not modified
@since UDK 3.2.0
*/
REG_DLLPUBLIC sal_Bool typereg_writer_setReferenceData(
void * handle, sal_uInt16 index, rtl_uString const * documentation,
RTReferenceType sort, RTFieldAccess flags, rtl_uString const * typeName)
SAL_THROW_EXTERN_C();
/**
Returns the blob of a type writer.
@param handle a handle on a type writer; must not be null
@param size an out-parameter obtaining the size of the blob; must not be null
@return a (byte-aligned) pointer to the blob; the returned pointer and the
returned <code>size</code> remain valid until the next function is called on
the given type writer; if an out-of-memory condition occurs, null is returned
and <code>size</code> is not modified
*/
REG_DLLPUBLIC void const * typereg_writer_getBlob(void * handle, sal_uInt32 * size)
SAL_THROW_EXTERN_C();
#ifdef __cplusplus
}
#endif
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

291
include/registry/writer.hxx
View file

@ -1,291 +0,0 @@
/* -*- 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_REGISTRY_WRITER_HXX
#define INCLUDED_REGISTRY_WRITER_HXX
#include <registry/writer.h>
#include <registry/refltype.hxx>
#include <registry/types.hxx>
#include <registry/version.h>
#include <rtl/ustring.hxx>
#include <sal/types.h>
#include <new>
namespace typereg {
/**
A type writer working on a binary blob that represents a UNOIDL type.
<p>Instances of this class are not multi-thread&ndash;safe.</p>
@since UDK 3.2.0
*/
class Writer {
public:
/**
Creates a type writer.
@param version the version of the created type writer; must not be
negative
@param documentation the documentation
@param fileName the file name (deprecated, use an empty string)
@param typeClass the type class of the created type writer
@param published whether the created type writer is published; for a type
class that cannot be published, this should be false
@param typeName the type name of the created type writer
@param superTypeCount the number of super types of the created type
writer
@param fieldCount the number of fields of the created type writer
@param methodCount the number of methods of the created type writer
@param referenceCount the number of references of the created type writer
@exception std::bad_alloc is raised if an out-of-memory condition occurs
*/
Writer(
typereg_Version version, OUString const & documentation,
OUString const & fileName, RTTypeClass typeClass, bool published,
OUString const & typeName, sal_uInt16 superTypeCount,
sal_uInt16 fieldCount, sal_uInt16 methodCount,
sal_uInt16 referenceCount):
m_handle(
typereg_writer_create(
version, documentation.pData, fileName.pData, typeClass,
published, typeName.pData, superTypeCount, fieldCount,
methodCount, referenceCount))
{
if (m_handle == nullptr) {
throw std::bad_alloc();
}
}
/**
Destroys this <code>Writer</code> instance.
*/
~Writer() {
typereg_writer_destroy(m_handle);
}
/**
Sets the type name of a super type of this type writer.
@param index a valid index into the range of super types of this type
writer
@param typeName the super type name
@exception std::bad_alloc is raised if an out-of-memory condition occurs
*/
void setSuperTypeName(sal_uInt16 index, OUString const & typeName) {
if (!typereg_writer_setSuperTypeName(m_handle, index, typeName.pData)) {
throw std::bad_alloc();
}
}
/**
Sets the data of a field of this type writer.
@param index a valid index into the range of fields of this type writer
@param documentation the documentation of the field
@param fileName the file name of the field (deprecated, use an empty string)
@param flags the flags of the field
@param name the name of the field
@param typeName the type name of the field
@param value the value of the field
@exception std::bad_alloc is raised if an out-of-memory condition occurs
*/
void setFieldData(
sal_uInt16 index, OUString const & documentation,
OUString const & fileName, RTFieldAccess flags, OUString const & name,
OUString const & typeName, RTConstValue const & value)
{
if (!typereg_writer_setFieldData(
m_handle, index, documentation.pData, fileName.pData, flags,
name.pData, typeName.pData, value.m_type, value.m_value))
{
throw std::bad_alloc();
}
}
/**
Sets the data of a method of this type writer.
@param index a valid index into the range of methods of this type writer
@param documentation the documentation of the method
@param flags the flags of the method
@param name the name of the method
@param returnTypeName the return type name of the method
@param parameterCount the number of parameters of the method
@param exceptionCount the number of exceptions of the method
@exception std::bad_alloc is raised if an out-of-memory condition occurs
*/
void setMethodData(
sal_uInt16 index, OUString const & documentation,
RTMethodMode flags, OUString const & name,
OUString const & returnTypeName, sal_uInt16 parameterCount,
sal_uInt16 exceptionCount)
{
if (!typereg_writer_setMethodData(
m_handle, index, documentation.pData, flags, name.pData,
returnTypeName.pData, parameterCount, exceptionCount))
{
throw std::bad_alloc();
}
}
/**
Sets the data of a parameter of a method of this type writer.
@param methodIndex a valid index into the range of methods of this type
writer
@param parameterIndex a valid index into the range of parameters of the
given method
@param flags the flags of the parameter
@param name the name of the parameter
@param typeName the type name of the parameter
@exception std::bad_alloc is raised if an out-of-memory condition occurs
*/
void setMethodParameterData(
sal_uInt16 methodIndex, sal_uInt16 parameterIndex,
RTParamMode flags, OUString const & name,
OUString const & typeName) const
{
if (!typereg_writer_setMethodParameterData(
m_handle, methodIndex, parameterIndex, flags, name.pData,
typeName.pData))
{
throw std::bad_alloc();
}
}
/**
Sets an exception type name of a method of this type writer.
@param methodIndex a valid index into the range of methods of this type
writer
@param exceptionIndex a valid index into the range of exceptions of the
given method
@param typeName the exception type name
@exception std::bad_alloc is raised if an out-of-memory condition occurs
*/
void setMethodExceptionTypeName(
sal_uInt16 methodIndex, sal_uInt16 exceptionIndex,
OUString const & typeName)
{
if (!typereg_writer_setMethodExceptionTypeName(
m_handle, methodIndex, exceptionIndex, typeName.pData))
{
throw std::bad_alloc();
}
}
/**
Sets the data of a reference of this type writer.
@param index a valid index into the range of references of this type
writer
@param documentation the documentation of the reference
@param sort the sort of the reference
@param flags the flags of the reference
@param typeName the type name of the reference
@exception std::bad_alloc is raised if an out-of-memory condition occurs
*/
void setReferenceData(
sal_uInt16 index, OUString const & documentation,
RTReferenceType sort, RTFieldAccess flags,
OUString const & typeName)
{
if (!typereg_writer_setReferenceData(
m_handle, index, documentation.pData, sort, flags,
typeName.pData))
{
throw std::bad_alloc();
}
}
/**
Returns the blob of this type writer.
@param size an out-parameter obtaining the size of the blob
@return a (byte-aligned) pointer to the blob; the returned pointer and
the returned <code>size</code> remain valid until the next function is
called on this type writer
@exception std::bad_alloc is raised if an out-of-memory condition occurs
(in which case <code>size</code> is not modified
*/
void const * getBlob(sal_uInt32 * size) {
void const * p = typereg_writer_getBlob(m_handle, size);
if (p == nullptr) {
throw std::bad_alloc();
}
return p;
}
private:
Writer(Writer const &) = delete;
Writer& operator =(Writer const &) = delete;
void * m_handle;
};
}
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

2
registry/IwyuFilter_registry.yaml
View file

@ -7,8 +7,6 @@ excludelist:
registry/source/reflwrit.cxx:
# OSL_BIGENDIAN is being checked
- osl/endian.h
# Needed for correct linker visibility
- registry/writer.h
registry/source/reflread.cxx:
# OSL_BIGENDIAN is being checked
- osl/endian.h

106
registry/source/reflread.cxx
View file

@ -27,9 +27,9 @@
#include <sal/types.h>
#include <osl/endian.h>
#include <osl/diagnose.h>
#include "reflread.hxx"
#include <sal/log.hxx>
#include <registry/refltype.hxx>
#include <registry/typereg_reader.hxx>
#include <registry/version.h>
@ -1213,13 +1213,6 @@ bool TYPEREG_CALLTYPE typereg_reader_create(
}
}
static TypeReaderImpl TYPEREG_CALLTYPE createEntry(const sal_uInt8* buffer, sal_uInt32 len)
{
void * handle;
typereg_reader_create(buffer, len, &handle);
return handle;
}
void TYPEREG_CALLTYPE typereg_reader_acquire(void * hEntry)
{
TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
@ -1294,23 +1287,6 @@ void TYPEREG_CALLTYPE typereg_reader_getTypeName(void * hEntry, rtl_uString** pT
}
static void TYPEREG_CALLTYPE getSuperTypeName(TypeReaderImpl hEntry, rtl_uString** pSuperTypeName)
{
TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
if (pEntry != nullptr && pEntry->m_nSuperTypes != 0) {
try {
const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(pEntry->m_offset_SUPERTYPES )); //+ (index * sizeof(sal_uInt16))));
rtl_string2UString(
pSuperTypeName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
return;
} catch (BlopObject::BoundsError &) {
SAL_WARN("registry", "bad data");
}
}
rtl_uString_new(pSuperTypeName);
}
void TYPEREG_CALLTYPE typereg_reader_getDocumentation(void * hEntry, rtl_uString** pDoku)
{
TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
@ -1355,11 +1331,6 @@ sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getFieldCount(void * hEntry)
return pEntry->m_pFields->m_numOfEntries;
}
static sal_uInt32 TYPEREG_CALLTYPE getFieldCount(TypeReaderImpl hEntry)
{
return typereg_reader_getFieldCount(hEntry);
}
void TYPEREG_CALLTYPE typereg_reader_getFieldName(void * hEntry, rtl_uString** pFieldName, sal_uInt16 index)
{
TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
@ -1419,13 +1390,6 @@ bool TYPEREG_CALLTYPE typereg_reader_getFieldValue(
return true;
}
static RTValueType TYPEREG_CALLTYPE getFieldConstValue(TypeReaderImpl hEntry, sal_uInt16 index, RTConstValueUnion* value)
{
RTValueType t = RT_TYPE_NONE;
typereg_reader_getFieldValue(hEntry, index, &t, value);
return t;
}
void TYPEREG_CALLTYPE typereg_reader_getFieldDocumentation(void * hEntry, rtl_uString** pDoku, sal_uInt16 index)
{
TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
@ -1689,72 +1653,4 @@ void TYPEREG_CALLTYPE typereg_reader_getSuperTypeName(
rtl_uString_new(pSuperTypeName);
}
RegistryTypeReader::RegistryTypeReader(const sal_uInt8* buffer,
sal_uInt32 bufferLen)
: m_hImpl(nullptr)
{
m_hImpl = createEntry(buffer, bufferLen);
}
RegistryTypeReader::~RegistryTypeReader()
{ typereg_reader_release(m_hImpl); }
RTTypeClass RegistryTypeReader::getTypeClass() const
{ return typereg_reader_getTypeClass(m_hImpl); }
OUString RegistryTypeReader::getTypeName() const
{
OUString sRet;
typereg_reader_getTypeName(m_hImpl, &sRet.pData);
return sRet;
}
OUString RegistryTypeReader::getSuperTypeName() const
{
OUString sRet;
::getSuperTypeName(m_hImpl, &sRet.pData);
return sRet;
}
sal_uInt32 RegistryTypeReader::getFieldCount() const
{ return ::getFieldCount(m_hImpl); }
OUString RegistryTypeReader::getFieldName( sal_uInt16 index ) const
{
OUString sRet;
typereg_reader_getFieldName(m_hImpl, &sRet.pData, index);
return sRet;
}
OUString RegistryTypeReader::getFieldType( sal_uInt16 index ) const
{
OUString sRet;
typereg_reader_getFieldTypeName(m_hImpl, &sRet.pData, index);
return sRet;
}
RTFieldAccess RegistryTypeReader::getFieldAccess( sal_uInt16 index ) const
{ return typereg_reader_getFieldFlags(m_hImpl, index); }
RTConstValue RegistryTypeReader::getFieldConstValue( sal_uInt16 index ) const
{
RTConstValue ret;
ret.m_type = ::getFieldConstValue(m_hImpl, index, &ret.m_value);
return ret;
}
OUString RegistryTypeReader::getFieldDoku( sal_uInt16 index ) const
{
OUString sRet;
typereg_reader_getFieldDocumentation(m_hImpl, &sRet.pData, index);
return sRet;
}
OUString RegistryTypeReader::getFieldFileName( sal_uInt16 index ) const
{
OUString sRet;
typereg_reader_getFieldFileName(m_hImpl, &sRet.pData, index);
return sRet;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

114
registry/source/reflread.hxx
View file

@ -1,114 +0,0 @@
/* -*- 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_REGISTRY_SOURCE_REFLREAD_HXX
#define INCLUDED_REGISTRY_SOURCE_REFLREAD_HXX
#include <registry/refltype.hxx>
#include <rtl/ustring.hxx>
/// Implementation handle
typedef void* TypeReaderImpl;
/** RegistryTypeReades reads a binary type blob.
This class provides the necessary functions to read type information
for all kinds of types of a type blob.
@deprecated
use typereg::Reader instead
*/
class RegistryTypeReader
{
public:
/** Constructor.
@param buffer points to the binary data block.
@param bufferLen specifies the size of the binary data block.
*/
RegistryTypeReader(const sal_uInt8* buffer,
sal_uInt32 bufferLen);
/// Destructor. The Destructor frees the data block if the copyData flag was TRUE.
~RegistryTypeReader();
/** returns the typeclass of the type represented by this blob.
This function will always return the type class without the internal
RT_TYPE_PUBLISHED flag set.
*/
RTTypeClass getTypeClass() const;
/** returns the full qualified name of the type.
*/
OUString getTypeName() const;
/** returns the full qualified name of the supertype.
*/
OUString getSuperTypeName() const;
/** returns the number of fields (attributes/properties, enum values or number
of constants in a module).
*/
sal_uInt32 getFieldCount() const;
/** returns the name of the field specified by index.
*/
OUString getFieldName( sal_uInt16 index ) const;
/** returns the full qualified name of the field specified by index.
*/
OUString getFieldType( sal_uInt16 index ) const;
/** returns the access mode of the field specified by index.
*/
RTFieldAccess getFieldAccess( sal_uInt16 index ) const;
/** returns the value of the field specified by index.
This function returns the value of an enum value or of a constant.
*/
RTConstValue getFieldConstValue( sal_uInt16 index ) const;
/** returns the documentation string for the field specified by index.
Each field of a type can have their own documentation.
*/
OUString getFieldDoku( sal_uInt16 index ) const;
/** returns the IDL filename of the field specified by index.
The IDL filename of a field can differ from the filename of the ype itself
because modules and also constants can be defined in different IDL files.
*/
OUString getFieldFileName( sal_uInt16 index ) const;
private:
RegistryTypeReader(RegistryTypeReader const &) = delete;
void operator =(RegistryTypeReader const &) = delete;
/// stores the handle of an implementation class
TypeReaderImpl m_hImpl;
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

1210
registry/source/reflwrit.cxx
View file

File diff suppressed because it is too large Load diff

103
registry/source/reflwrit.hxx
View file

@ -1,103 +0,0 @@
/* -*- 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_REGISTRY_SOURCE_REFLWRIT_HXX
#define INCLUDED_REGISTRY_SOURCE_REFLWRIT_HXX
#include <registry/types.hxx>
#include <rtl/ustring.hxx>
class RTConstValue;
/// Implementation handle
typedef void* TypeWriterImpl;
/** RegistryTypeWriter writes/creates a binary type blob.
This class provides the necessary functions to write type information
for all kinds of types into a blob.
@deprecated
use typereg::Writer instead
*/
class RegistryTypeWriter
{
public:
/** Constructor.
@param RTTypeClass specifies the type of the new blob.
@param typeName specifies the full qualified type name with '/' as separator.
@param superTypeName specifies the full qualified type name of the base type
with '/' as separator.
@param fieldCount specifies the number of fields (eg. number of attributes/properties,
enum values or constants).
*/
RegistryTypeWriter(RTTypeClass RTTypeClass,
const OUString& typeName,
const OUString& superTypeName,
sal_uInt16 fieldCount);
/** Destructor. The Destructor frees the internal data block.
The pointer (returned by getBlop) will be set to NULL.
*/
~RegistryTypeWriter();
/** sets the data for a field member of a type blob.
@param index indicates the index of the field.
@param name specifies the name.
@param typeName specifies the full qualified typename.
@param doku specifies the documentation string of the field.
@param fileName specifies the name of the IDL file where the field is defined.
@param access specifies the access mode of the field.
@param constValue specifies the value of the field. The value is only interesting
for enum values or constants.
*/
void setFieldData( sal_uInt16 index,
const OUString& name,
const OUString& typeName,
const OUString& doku,
const OUString& fileName,
RTFieldAccess access,
const RTConstValue& constValue);
/** returns a pointer to the new type blob.
The pointer will be invalid (NULL) if the instance of
the RegistryTypeWriter will be destroyed.
*/
const sal_uInt8* getBlop();
/** returns the size of the new type blob in bytes.
*/
sal_uInt32 getBlopSize();
private:
RegistryTypeWriter(RegistryTypeWriter const &) = delete;
void operator =(RegistryTypeWriter const &) = delete;
/// stores the handle of an implementation class
TypeWriterImpl m_hImpl;
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

400
registry/source/regimpl.cxx
View file

@ -32,10 +32,6 @@
#include <unistd.h>
#endif
#include "reflread.hxx"
#include "reflwrit.hxx"
#include <registry/reader.hxx>
#include <registry/refltype.hxx>
#include <registry/types.hxx>
@ -850,402 +846,6 @@ RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
return RegError::NO_ERROR;
}
RegError ORegistry::loadKey(RegKeyHandle hKey, const OUString& regFileName,
bool bWarnings, bool bReport)
{
ORegKey* pKey = static_cast< ORegKey* >(hKey);
ORegistry aReg;
RegError _ret = aReg.initRegistry(regFileName, RegAccessMode::READONLY);
if (_ret != RegError::NO_ERROR)
return _ret;
ORegKey* pRootKey = aReg.getRootKey();
REG_GUARD(m_mutex);
OStoreDirectory::iterator iter;
OStoreDirectory rStoreDir(pRootKey->getStoreDir());
storeError _err = rStoreDir.first(iter);
while (_err == store_E_None)
{
OUString const keyName(iter.m_pszName, iter.m_nLength);
if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
{
_ret = loadAndSaveKeys(pKey, pRootKey, keyName, 0, bWarnings, bReport);
}
else
{
_ret = loadAndSaveValue(pKey, pRootKey, keyName, 0, bWarnings, bReport);
}
if (_ret == RegError::MERGE_ERROR)
break;
if (_ret == RegError::MERGE_CONFLICT && bWarnings)
break;
_err = rStoreDir.next(iter);
}
rStoreDir = OStoreDirectory();
(void) aReg.releaseKey(pRootKey);
return _ret;
}
RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
ORegKey const * pSourceKey,
const OUString& valueName,
sal_uInt32 nCut,
bool bWarnings,
bool bReport)
{
OStoreStream rValue;
RegValueType valueType;
sal_uInt32 valueSize;
sal_uInt32 nSize;
storeAccessMode sourceAccess = storeAccessMode::ReadWrite;
OUString sTargetPath(pTargetKey->getName());
OUString sSourcePath(pSourceKey->getName());
if (pSourceKey->isReadOnly())
{
sourceAccess = storeAccessMode::ReadOnly;
}
if (nCut)
{
sTargetPath = sSourcePath.copy(nCut);
} else
{
if (sTargetPath.getLength() > 1)
{
if (sSourcePath.getLength() > 1)
sTargetPath += sSourcePath;
} else
sTargetPath = sSourcePath;
}
if (sTargetPath.getLength() > 1) sTargetPath += ROOT;
if (sSourcePath.getLength() > 1) sSourcePath += ROOT;
if (rValue.create(pSourceKey->getStoreFile(), sSourcePath, valueName, sourceAccess))
{
return RegError::VALUE_NOT_EXISTS;
}
std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE);
sal_uInt32 rwBytes;
if (rValue.readAt(0, aBuffer.data(), VALUE_HEADERSIZE, rwBytes))
{
return RegError::INVALID_VALUE;
}
if (rwBytes != VALUE_HEADERSIZE)
{
return RegError::INVALID_VALUE;
}
RegError _ret = RegError::NO_ERROR;
sal_uInt8 type = aBuffer[0];
valueType = static_cast<RegValueType>(type);
readUINT32(aBuffer.data() + VALUE_TYPEOFFSET, valueSize);
nSize = VALUE_HEADERSIZE + valueSize;
aBuffer.resize(nSize);
if (rValue.readAt(0, aBuffer.data(), nSize, rwBytes))
{
return RegError::INVALID_VALUE;
}
if (rwBytes != nSize)
{
return RegError::INVALID_VALUE;
}
OStoreFile rTargetFile(pTargetKey->getStoreFile());
if (!rValue.create(rTargetFile, sTargetPath, valueName, storeAccessMode::ReadWrite))
{
if (valueType == RegValueType::BINARY)
{
_ret = checkBlop(
rValue, sTargetPath, valueSize, aBuffer.data() + VALUE_HEADEROFFSET,
bReport);
if (_ret != RegError::NO_ERROR)
{
if (_ret == RegError::MERGE_ERROR ||
(_ret == RegError::MERGE_CONFLICT && bWarnings))
{
return _ret;
}
} else
{
return _ret;
}
}
}
if (rValue.create(rTargetFile, sTargetPath, valueName, storeAccessMode::Create))
{
return RegError::INVALID_VALUE;
}
if (rValue.writeAt(0, aBuffer.data(), nSize, rwBytes))
{
return RegError::INVALID_VALUE;
}
if (rwBytes != nSize)
{
return RegError::INVALID_VALUE;
}
pTargetKey->setModified();
return _ret;
}
RegError ORegistry::checkBlop(OStoreStream& rValue,
std::u16string_view sTargetPath,
sal_uInt32 srcValueSize,
sal_uInt8 const * pSrcBuffer,
bool bReport)
{
RegistryTypeReader reader(pSrcBuffer, srcValueSize);
if (reader.getTypeClass() == RT_TYPE_INVALID)
{
return RegError::INVALID_VALUE;
}
std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE);
sal_uInt32 rwBytes;
OString targetPath(OUStringToOString(sTargetPath, RTL_TEXTENCODING_UTF8));
if (!rValue.readAt(0, aBuffer.data(), VALUE_HEADERSIZE, rwBytes) &&
(rwBytes == VALUE_HEADERSIZE))
{
sal_uInt8 type = aBuffer[0];
RegValueType valueType = static_cast<RegValueType>(type);
sal_uInt32 valueSize;
readUINT32(aBuffer.data() + VALUE_TYPEOFFSET, valueSize);
if (valueType == RegValueType::BINARY)
{
aBuffer.resize(valueSize);
if (!rValue.readAt(VALUE_HEADEROFFSET, aBuffer.data(), valueSize, rwBytes) &&
(rwBytes == valueSize))
{
RegistryTypeReader reader2(aBuffer.data(), valueSize);
if ((reader.getTypeClass() != reader2.getTypeClass())
|| reader2.getTypeClass() == RT_TYPE_INVALID)
{
if (bReport)
{
fprintf(stdout, "ERROR: values of blop from key \"%s\" has different types.\n",
targetPath.getStr());
}
return RegError::MERGE_ERROR;
}
if (reader.getTypeClass() == RT_TYPE_MODULE)
{
if (reader.getFieldCount() > 0 &&
reader2.getFieldCount() > 0)
{
mergeModuleValue(rValue, reader, reader2);
return RegError::NO_ERROR;
} else
if (reader2.getFieldCount() > 0)
{
return RegError::NO_ERROR;
} else
{
return RegError::MERGE_CONFLICT;
}
} else
{
if (bReport)
{
fprintf(stderr, "WARNING: value of key \"%s\" already exists.\n",
targetPath.getStr());
}
return RegError::MERGE_CONFLICT;
}
} else
{
if (bReport)
{
fprintf(stderr, "ERROR: values of key \"%s\" contains bad data.\n",
targetPath.getStr());
}
return RegError::MERGE_ERROR;
}
} else
{
if (bReport)
{
fprintf(stderr, "ERROR: values of key \"%s\" has different types.\n",
targetPath.getStr());
}
return RegError::MERGE_ERROR;
}
} else
{
return RegError::INVALID_VALUE;
}
}
static sal_uInt32 checkTypeReaders(RegistryTypeReader const & reader1,
RegistryTypeReader const & reader2,
std::set< OUString >& nameSet)
{
sal_uInt32 count=0;
for (sal_uInt32 i=0 ; i < reader1.getFieldCount(); i++)
{
nameSet.insert(reader1.getFieldName(i));
count++;
}
for (sal_uInt32 i=0 ; i < reader2.getFieldCount(); i++)
{
if (nameSet.insert(reader2.getFieldName(i)).second)
count++;
}
return count;
}
RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
RegistryTypeReader const & reader,
RegistryTypeReader const & reader2)
{
std::set< OUString > nameSet;
sal_uInt32 count = checkTypeReaders(reader, reader2, nameSet);
if (count == reader.getFieldCount())
return RegError::NO_ERROR;
sal_uInt16 index = 0;
RegistryTypeWriter writer(reader.getTypeClass(),
reader.getTypeName(),
reader.getSuperTypeName(),
static_cast<sal_uInt16>(count));
for (sal_uInt32 i=0 ; i < reader.getFieldCount(); i++)
{
writer.setFieldData(index,
reader.getFieldName(i),
reader.getFieldType(i),
reader.getFieldDoku(i),
reader.getFieldFileName(i),
reader.getFieldAccess(i),
reader.getFieldConstValue(i));
index++;
}
for (sal_uInt32 i=0 ; i < reader2.getFieldCount(); i++)
{
if (nameSet.find(reader2.getFieldName(i)) == nameSet.end())
{
writer.setFieldData(index,
reader2.getFieldName(i),
reader2.getFieldType(i),
reader2.getFieldDoku(i),
reader2.getFieldFileName(i),
reader2.getFieldAccess(i),
reader2.getFieldConstValue(i));
index++;
}
}
const sal_uInt8* pBlop = writer.getBlop();
sal_uInt32 aBlopSize = writer.getBlopSize();
sal_uInt8 type = sal_uInt8(RegValueType::BINARY);
std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE + aBlopSize);
memcpy(aBuffer.data(), &type, 1);
writeUINT32(aBuffer.data() + VALUE_TYPEOFFSET, aBlopSize);
memcpy(aBuffer.data() + VALUE_HEADEROFFSET, pBlop, aBlopSize);
sal_uInt32 rwBytes;
if (rTargetValue.writeAt(0, aBuffer.data(), VALUE_HEADERSIZE+aBlopSize, rwBytes))
{
return RegError::INVALID_VALUE;
}
if (rwBytes != VALUE_HEADERSIZE+aBlopSize)
{
return RegError::INVALID_VALUE;
}
return RegError::NO_ERROR;
}
RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
ORegKey* pSourceKey,
const OUString& keyName,
sal_uInt32 nCut,
bool bWarnings,
bool bReport)
{
RegError _ret = RegError::NO_ERROR;
OUString sRelPath(pSourceKey->getName().copy(nCut));
OUString sFullPath;
if(pTargetKey->getName().getLength() > 1)
sFullPath += pTargetKey->getName();
sFullPath += sRelPath;
if (sRelPath.getLength() > 1 || sFullPath.isEmpty())
sFullPath += ROOT;
OUString sFullKeyName = sFullPath + keyName;
OStoreDirectory rStoreDir;
if (rStoreDir.create(pTargetKey->getStoreFile(), sFullPath, keyName, storeAccessMode::Create))
{
return RegError::CREATE_KEY_FAILED;
}
if (m_openKeyTable.count(sFullKeyName) > 0)
{
m_openKeyTable[sFullKeyName]->setDeleted(false);
}
ORegKey* pTmpKey = nullptr;
_ret = pSourceKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pTmpKey));
if (_ret != RegError::NO_ERROR)
return _ret;
OStoreDirectory::iterator iter;
OStoreDirectory rTmpStoreDir(pTmpKey->getStoreDir());
storeError _err = rTmpStoreDir.first(iter);
while (_err == store_E_None)
{
OUString const sName(iter.m_pszName, iter.m_nLength);
if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
{
_ret = loadAndSaveKeys(pTargetKey, pTmpKey,
sName, nCut, bWarnings, bReport);
} else
{
_ret = loadAndSaveValue(pTargetKey, pTmpKey,
sName, nCut, bWarnings, bReport);
}
if (_ret == RegError::MERGE_ERROR)
break;
if (_ret == RegError::MERGE_CONFLICT && bWarnings)
break;
_err = rTmpStoreDir.next(iter);
}
pSourceKey->releaseKey(pTmpKey);
return _ret;
}
ORegKey* ORegistry::getRootKey()
{
m_openKeyTable[ROOT]->acquire();

30
registry/source/regimpl.hxx
View file

@ -40,7 +40,6 @@
osl::Guard< osl::Mutex > aGuard( mutex );
class ORegKey;
class RegistryTypeReader;
class ORegistry
{
@ -76,11 +75,6 @@ public:
RegError deleteKey(RegKeyHandle hKey, std::u16string_view keyName);
RegError loadKey(RegKeyHandle hKey,
const OUString& regFileName,
bool bWarnings,
bool bReport);
RegError dumpRegistry(RegKeyHandle hKey) const;
~ORegistry();
@ -106,30 +100,6 @@ private:
RegError deleteSubkeysAndValues(ORegKey* pKey);
static RegError loadAndSaveValue(ORegKey* pTargetKey,
ORegKey const * pSourceKey,
const OUString& valueName,
sal_uInt32 nCut,
bool bWarnings,
bool bReport);
static RegError checkBlop(store::OStoreStream& rValue,
std::u16string_view sTargetPath,
sal_uInt32 srcValueSize,
sal_uInt8 const * pSrcBuffer,
bool bReport);
static RegError mergeModuleValue(store::OStoreStream& rTargetValue,
RegistryTypeReader const & reader,
RegistryTypeReader const & reader2);
RegError loadAndSaveKeys(ORegKey* pTargetKey,
ORegKey* pSourceKey,
const OUString& keyName,
sal_uInt32 nCut,
bool bWarnings,
bool bReport);
RegError dumpValue(const OUString& sPath,
const OUString& sName,
sal_Int16 nSpace) const;

50
registry/source/registry.cxx
View file

@ -213,55 +213,6 @@ static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
}
// mergeKey
static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
RegKeyHandle hKey,
rtl_uString* keyName,
rtl_uString* regFileName,
sal_Bool bWarnings,
sal_Bool bReport)
{
ORegistry* pReg = static_cast< ORegistry* >(hReg);
if (!pReg)
return RegError::INVALID_REGISTRY;
if (!pReg->isOpen())
return RegError::REGISTRY_NOT_OPEN;
ORegKey* pKey = static_cast< ORegKey* >(hKey);
if (!pKey)
return RegError::INVALID_KEY;
if (pKey->getRegistry() != pReg)
return RegError::INVALID_KEY;
if (pKey->isDeleted())
return RegError::INVALID_KEY;
if (pKey->isReadOnly())
return RegError::REGISTRY_READONLY;
if (keyName->length)
{
ORegKey* pNewKey = nullptr;
RegError _ret = pKey->createKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pNewKey));
if (_ret != RegError::NO_ERROR)
return _ret;
_ret = pReg->loadKey(pNewKey, regFileName, bWarnings, bReport);
if (_ret != RegError::NO_ERROR && (_ret != RegError::MERGE_CONFLICT || bWarnings))
{
if (pNewKey != pKey)
(void) pKey->closeKey(pNewKey);
else
(void) pKey->releaseKey(pNewKey);
return _ret;
}
return (pNewKey != pKey) ? pKey->closeKey(pNewKey) : pKey->releaseKey(pNewKey);
}
return pReg->loadKey(pKey, regFileName, bWarnings, bReport);
}
// dumpRegistry
static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
@ -298,7 +249,6 @@ Registry_Api* REGISTRY_CALLTYPE initRegistry_Api()
&openRegistry,
&closeRegistry,
&destroyRegistry,
&mergeKey,
&acquireKey,
&releaseKey,
&isKeyReadOnly,

4
solenv/clang-format/excludelist
View file

@ -5506,8 +5506,6 @@ include/registry/reader.hxx
include/registry/registry.hxx
include/registry/typereg_reader.hxx
include/registry/version.h
include/registry/writer.h
include/registry/writer.hxx
include/rtl/alloc.h
include/rtl/bootstrap.h
include/rtl/bootstrap.hxx
@ -7386,9 +7384,7 @@ registry/source/keyimpl.cxx
registry/source/keyimpl.hxx
registry/source/reflcnst.hxx
registry/source/reflread.cxx
registry/source/reflread.hxx
registry/source/reflwrit.cxx
registry/source/reflwrit.hxx
registry/source/regimpl.cxx
registry/source/regimpl.hxx
registry/source/registry.cxx

10
stoc/source/defaultregistry/defaultregistry.cxx
View file

@ -1169,15 +1169,9 @@ sal_Bool SAL_CALL NestedRegistryImpl::isReadOnly( )
}
void SAL_CALL NestedRegistryImpl::mergeKey( const OUString& aKeyName, const OUString& aUrl )
void SAL_CALL NestedRegistryImpl::mergeKey( const OUString&, const OUString& )
{
Guard< Mutex > aGuard( m_mutex );
if ( m_localReg.is() && m_localReg->isValid() )
{
m_localReg->mergeKey(aKeyName, aUrl);
m_state++;
}
throw css::uno::RuntimeException("css.registry.NestedRegistry::mergeKey: not implemented");
}
} // namespace

25
stoc/source/simpleregistry/simpleregistry.cxx
View file

@ -26,7 +26,6 @@
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/registry/InvalidRegistryException.hpp>
#include <com/sun/star/registry/InvalidValueException.hpp>
#include <com/sun/star/registry/MergeConflictException.hpp>
#include <com/sun/star/registry/RegistryKeyType.hpp>
#include <com/sun/star/registry/XRegistryKey.hpp>
#include <com/sun/star/registry/XSimpleRegistry.hpp>
@ -903,29 +902,9 @@ sal_Bool SimpleRegistry::isReadOnly()
}
void SimpleRegistry::mergeKey(
OUString const & aKeyName, OUString const & aUrl)
OUString const &, OUString const &)
{
std::scoped_lock guard(mutex_);
RegistryKey root;
RegError err = registry_.openRootKey(root);
if (err == RegError::NO_ERROR) {
err = registry_.mergeKey(root, aKeyName, aUrl, false);
}
switch (err) {
case RegError::NO_ERROR:
case RegError::MERGE_CONFLICT:
break;
case RegError::MERGE_ERROR:
throw css::registry::MergeConflictException(
"com.sun.star.registry.SimpleRegistry.mergeKey:"
" underlying Registry::mergeKey() = RegError::MERGE_ERROR",
static_cast< cppu::OWeakObject * >(this));
default:
throw css::registry::InvalidRegistryException(
"com.sun.star.registry.SimpleRegistry.mergeKey:"
" underlying Registry::getRootKey/mergeKey() = " + OUString::number(static_cast<int>(err)),
static_cast< OWeakObject * >(this));
}
throw css::uno::RuntimeException("css.registry.SimpleRegistry::mergeKey: not implemented");
}
}

2
udkapi/com/sun/star/registry/MergeConflictException.idl
View file

@ -27,6 +27,8 @@
/** is thrown if entries of two registries are contradictory in the context of
XSimpleRegistry::mergeKey()e() method.
@deprecated as XSimpleRegistry::mergeKey is deprecated as well
*/
published exception MergeConflictException: com::sun::star::uno::Exception
{

15
udkapi/com/sun/star/registry/XSimpleRegistry.idl
View file

@ -102,19 +102,10 @@ published interface XSimpleRegistry: com::sun::star::uno::XInterface
boolean isReadOnly()
raises( com::sun::star::registry::InvalidRegistryException );
/** DEPRECATED: this method lacks a registry key (better than a URL).
/** merges a registry under the specified key.
merges a registry under the specified key.
<p>If the key does not exist it will be created. Existing
keys will be overridden from keys of registry specified by
<var>aUrl</var>.
@throws InvalidRegistryException
if the registry is not open.
@throws MergeConflictException
if any differences occur during merging
@deprecated The merge functionality is deprecated and not implemented. Implementations will
throw a com::sun::star::RuntimeException.
*/
void mergeKey( [in] string aKeyName,
[in] string aUrl )