diff options
Diffstat (limited to 'sal/inc/rtl')
38 files changed, 14146 insertions, 0 deletions
diff --git a/sal/inc/rtl/alloc.h b/sal/inc/rtl/alloc.h new file mode 100644 index 000000000000..7b3967de716b --- /dev/null +++ b/sal/inc/rtl/alloc.h @@ -0,0 +1,266 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_ALLOC_H_ +#define _RTL_ALLOC_H_ + +# include <sal/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + + +/** Allocate memory. + @descr A call to this function will return NULL upon the requested + memory size being either zero or larger than currently allocatable. + + @param Bytes [in] memory size. + @return pointer to allocated memory. + */ +void * SAL_CALL rtl_allocateMemory ( + sal_Size Bytes +) SAL_THROW_EXTERN_C(); + + +/** Reallocate memory. + @descr A call to this function with parameter 'Ptr' being NULL + is equivalent to a rtl_allocateMemory() call. + + A call to this function with parameter 'Bytes' being 0 + is equivalent to a rtl_freeMemory() call. + + @see rtl_allocateMemory() + @see rtl_freeMemory() + + @param Ptr [in] pointer to previously allocated memory. + @param Bytes [in] new memory size. + @return pointer to reallocated memory. May differ from Ptr. + */ +void * SAL_CALL rtl_reallocateMemory ( + void * Ptr, + sal_Size Bytes +) SAL_THROW_EXTERN_C(); + + +/** Free memory. + @param Ptr [in] pointer to previously allocated memory. + @return none. Memory is released. Ptr is invalid. + */ +void SAL_CALL rtl_freeMemory ( + void * Ptr +) SAL_THROW_EXTERN_C(); + + +/** Allocate and zero memory. + @descr A call to this function will return NULL upon the requested + memory size being either zero or larger than currently allocatable. + + @param Bytes [in] memory size. + @return pointer to allocated and zero'ed memory. + */ +void * SAL_CALL rtl_allocateZeroMemory ( + sal_Size Bytes +) SAL_THROW_EXTERN_C(); + + +/** Zero and free memory. + @param Ptr [in] pointer to previously allocated memory. + @param Bytes [in] memory size. + @return none. Memory is zero'ed and released. Ptr is invalid. + */ +void SAL_CALL rtl_freeZeroMemory ( + void * Ptr, + sal_Size Bytes +) SAL_THROW_EXTERN_C(); + + +/** Opaque rtl_arena_type. + */ +typedef struct rtl_arena_st rtl_arena_type; + +#define RTL_ARENA_NAME_LENGTH 31 + + +/** rtl_arena_create() + * + * @param pName [in] descriptive name; for debugging purposes. + * @param quantum [in] resource allocation unit / granularity; rounded up to next power of 2. + * @param quantum_cache_max [in] max resources to cache; rounded up to next multiple of quantum; usually 0. + * @param source_arena [in] passed as argument to source_alloc, source_free; usually NULL. + * @param source_alloc [in] function to allocate resources; usually rtl_arena_alloc. + * @param source_free [in] function to free resources; usually rtl_arena_free. + * @param nFlags [in] flags; usually 0. + * + * @return pointer to rtl_arena_type, or NULL upon failure. + * + * @see rtl_arena_destroy() + */ +rtl_arena_type * +SAL_CALL rtl_arena_create ( + const char * pName, + sal_Size quantum, + sal_Size quantum_cache_max, + rtl_arena_type * source_arena, + void * (SAL_CALL * source_alloc)(rtl_arena_type *, sal_Size *), + void (SAL_CALL * source_free) (rtl_arena_type *, void *, sal_Size), + int nFlags +) SAL_THROW_EXTERN_C(); + + +/** rtl_arena_destroy() + * + * @param pArena [in] the arena to destroy. + * @return None + * + * @see rtl_arena_create() + */ +void +SAL_CALL rtl_arena_destroy ( + rtl_arena_type * pArena +) SAL_THROW_EXTERN_C(); + + +/** rtl_arena_alloc() + * + * @param pArena [in] arena from which resource is allocated. + * @param pBytes [inout] size of resource to allocate. + * + * @return allocated resource, or NULL upon failure. + * + * @see rtl_arena_free() + */ +void * +SAL_CALL rtl_arena_alloc ( + rtl_arena_type * pArena, + sal_Size * pBytes +) SAL_THROW_EXTERN_C(); + + +/** rtl_arena_free() + * + * @param pArena [in] arena from which resource was allocated. + * @param pAddr [in] resource to free. + * @param nBytes [in] size of resource. + * + * @return None. + * + * @see rtl_arena_alloc() + */ +void +SAL_CALL rtl_arena_free ( + rtl_arena_type * pArena, + void * pAddr, + sal_Size nBytes +) SAL_THROW_EXTERN_C(); + + +/** Opaque rtl_cache_type. + */ +typedef struct rtl_cache_st rtl_cache_type; + +#define RTL_CACHE_NAME_LENGTH 31 + +#define RTL_CACHE_FLAG_BULKDESTROY 1 + +/** rtl_cache_create() + * + * @param pName [in] descriptive name; for debugging purposes. + * @param nObjSize [in] object size. + * @param nObjAlign [in] object alignment; usually 0 for suitable default. + * @param constructor [in] object constructor callback function; returning 1 for success or 0 for failure. + * @param destructor [in] object destructor callback function. + * @param reclaim [in] reclaim callback function. + * @param pUserArg [in] opaque argument passed to callback functions. + * @param nFlags [in] flags. + * + * @return pointer to rtl_cache_type, or NULL upon failure. + * + * @see rtl_cache_destroy() + */ +rtl_cache_type * +SAL_CALL rtl_cache_create ( + const char * pName, + sal_Size nObjSize, + sal_Size nObjAlign, + int (SAL_CALL * constructor)(void * pObj, void * pUserArg), + void (SAL_CALL * destructor) (void * pObj, void * pUserArg), + void (SAL_CALL * reclaim) (void * pUserArg), + void * pUserArg, + rtl_arena_type * pSource, + int nFlags +) SAL_THROW_EXTERN_C(); + + +/** rtl_cache_destroy() + * + * @param pCache [in] the cache to destroy. + * + * @return None. + * + * @see rtl_cache_create() + */ +void +SAL_CALL rtl_cache_destroy ( + rtl_cache_type * pCache +) SAL_THROW_EXTERN_C(); + + +/** rtl_cache_alloc() + * + * @param pCache [in] cache from which object is allocated. + * + * @return pointer to allocated object, or NULL upon failure. + */ +void * +SAL_CALL rtl_cache_alloc ( + rtl_cache_type * pCache +) SAL_THROW_EXTERN_C(); + + +/** rtl_cache_free() + * + * @param pCache [in] cache from which object was allocated. + * @param pObj [in] object to free. + * + * @return None. + * + * @see rtl_cache_alloc() + */ +void +SAL_CALL rtl_cache_free ( + rtl_cache_type * pCache, + void * pObj +) SAL_THROW_EXTERN_C(); + + +#ifdef __cplusplus +} +#endif + +#endif /*_RTL_ALLOC_H_ */ + diff --git a/sal/inc/rtl/allocator.hxx b/sal/inc/rtl/allocator.hxx new file mode 100644 index 000000000000..c753a98189a3 --- /dev/null +++ b/sal/inc/rtl/allocator.hxx @@ -0,0 +1,192 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#if !defined INCLUDED_RTL_ALLOCATOR_HXX +#define INCLUDED_RTL_ALLOCATOR_HXX + +#if ! defined(_SAL_TYPES_H_) +#include "sal/types.h" +#endif +#if ! defined(_RTL_ALLOC_H_) +#include "rtl/alloc.h" +#endif + +#include <cstddef> + +//###################################################### +// This is no general purpose STL allocator but one +// necessary to use STL for some implementation but +// avoid linking sal against the STLPort library!!! +// For more information on when and how to define a +// custom stl allocator have a look at Scott Meyers: +// "Effective STL", Nicolai M. Josuttis: +// "The C++ Standard Library - A Tutorial and Reference" +// and at http://www.josuttis.com/cppcode/allocator.html + +namespace rtl { + +/** @internal */ +template<class T> +class Allocator +{ +public: + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef ::std::size_t size_type; + typedef ::std::ptrdiff_t difference_type; + + //----------------------------------------- + template<class U> + struct rebind + { + typedef Allocator<U> other; + }; + + //----------------------------------------- + pointer address (reference value) const + { + return &value; + } + + //----------------------------------------- + const_pointer address (const_reference value) const + { + return &value; + } + + //----------------------------------------- + Allocator() SAL_THROW(()) + {} + + //----------------------------------------- + template<class U> + Allocator (const Allocator<U>&) SAL_THROW(()) + {} + + //----------------------------------------- + Allocator(const Allocator&) SAL_THROW(()) + {} + + //----------------------------------------- + ~Allocator() SAL_THROW(()) + {} + + //----------------------------------------- + size_type max_size() const SAL_THROW(()) + { + return size_type(-1)/sizeof(T); + } + + //----------------------------------------- + /* Normally the code for allocate should + throw a std::bad_alloc exception if the + requested memory could not be allocated: + (C++ standard 20.4.1.1): + + pointer allocate (size_type n, const void* hint = 0) + { + pointer p = reinterpret_cast<pointer>( + rtl_allocateMemory(sal_uInt32(n * sizeof(T)))); + + if (NULL == p) + throw ::std::bad_alloc(); + + return p; + } + + but some compilers do not compile it if exceptions + are not enabled, e.g. GCC under Linux and it is + in general not desired to compile sal with exceptions + enabled. */ + pointer allocate (size_type n, const void* hint = 0) + { + hint = hint; /* avoid warnings */ + return reinterpret_cast<pointer>( + rtl_allocateMemory(sal_uInt32(n * sizeof(T)))); + } + + //----------------------------------------- + void deallocate (pointer p, size_type /* n */) + { + rtl_freeMemory(p); + } + + //----------------------------------------- + void construct (pointer p, const T& value) + { + new ((void*)p)T(value); + } + + //----------------------------------------- + void destroy (pointer p) + { + p->~T(); + } +}; + +//###################################################### +// Custom STL allocators must be stateless (see +// references above) that's why the operators below +// return always true or false + +/** @internal */ +template<class T, class U> +inline bool operator== (const Allocator<T>&, const Allocator<U>&) SAL_THROW(()) +{ + return true; +} + +/** @internal */ +template<class T, class U> +inline bool operator!= (const Allocator<T>&, const Allocator<U>&) SAL_THROW(()) +{ + return false; +} + +} /* namespace rtl */ + +//###################################################### +/** REQUIRED BY STLPort (see stlport '_alloc.h'): + Hack for compilers that do not support member + template classes (e.g. MSVC 6) + + @internal +*/ +namespace _STL +{ + /** @internal */ + template<class T, class U> + inline ::rtl::Allocator<U> & __stl_alloc_rebind (::rtl::Allocator<T> & a, U const *) + { + return (::rtl::Allocator<U>&)(a); + } +} + +#endif /* INCLUDED_RTL_ALLOCATOR_HXX */ + diff --git a/sal/inc/rtl/bootstrap.h b/sal/inc/rtl/bootstrap.h new file mode 100644 index 000000000000..1c33c45b1fa1 --- /dev/null +++ b/sal/inc/rtl/bootstrap.h @@ -0,0 +1,233 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_BOOTSTRAP_H_ +#define _RTL_BOOTSTRAP_H_ + +#include <rtl/ustring.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + @HTML + @file + + The described concept provides a platform independent way to access + minimum bootstrap settings for every application by excplitly or + implicitly passing the values to the application.<p> + + MULTI-LEVEL STRATEGY FOR RETRIEVAL OF BOOTSTRAP VALUES :<p> + + The 1st level is tried first. On failure, + the next level is tried. Every query starts at the first level again, so + that one setting may be taken from the 3rd and one from the 1st level.<p> + + 1st level: explicitly set variables via rtl_bootstrap_set() + + 2nd level: command line arguments. A "-env:SETTINGNAME=value" is given on + command line. This allows to give an application a certain setting, even + if an ini-file exists (espicially useful for e.g. daemons that want to + start an executable with dynamical changing settings).<p> + + 3rd level: environment variables. The application tries to get the + setting from the environment.<p> + + 4th level: executable ini-file. Every application looks for an ini-file. + The filename defaults to /absoulte/path/to/executable[rc|.ini] + (without .bin or .exe suffix). The ini-filename can be + set by the special command line parameter + '-env:INIFILENAME=/absolute/path/to/inifile' at runtime or it may + be set at compiletime by an API-call.<p> + + 5th level: URE_BOOTSTRAP ini-file. If the bootstrap variable URE_BOOTSTRAP + expands to the URL of an ini-file, that ini-file is searched.<p> + + 6th level: default. An application can have some default settings decided + at compile time, which allow the application to run even with no + deployment settings. <p> + + If neither of the above levels leads to an successful retrieval of the value + (no default possible), the application may fail to start.<p> + + NAMING CONVENTIONS <p> + + Naming conventions for names of bootstrap values : + Names may only include characters, that are allowed charcters for + environment variables. This excludes '.', ' ', ';', ':' and any non-ascii + character. Names are case insensitive.<p> + + An ini-file is only allowed to have one section, which must be named '[Bootstrap]'. + The section may be omitted. + The section name does not appear in the name of the corresponding + environment variable or commandline arg. + Values maybe arbitrary unicode strings, they must be encoded in UTF8.<p> + + Example:<p> + + in an ini-file: + <code> + [Sectionname] + Name=value + </code><p> + + as commandline arg: + <code>-env:Name=value</code><p> + + as environment + <code> + setenv Name value + set Name=value + </code><p> + + SPECIAL VARIABLES: + + <ul> + <li> INIFILENAME<br> + This variable allows to set the inifilename. This makes only sense, if the filename + is different than the executable file name. It must be given on command line. If it is + given the executable ini-file is ignored. + </li> +*/ + +/** may be called by an application to set an ini-filename. + + <p> + Must be called before rtl_bootstrap_get(). May not be called twice. + If it is never called, a the filename executable.ini (win) + or execuablerc (unx) is assumed. + + @param pName Name of the inifile with path but WITHOUT + suffix (.ini or rc) +*/ +void SAL_CALL rtl_bootstrap_setIniFileName( rtl_uString *pName ) + SAL_THROW_EXTERN_C(); + +/** + @param ppValue + out parameter. Contains always a valid rtl_uString pointer. + @param pName + The name of the bootstrap setting to be retrieved. + @param pDefault + maybe NULL. If once the default is + returned, successive calls always return this + default value, even when called with different + defaults. + + @return <code>sal_True</code>, when a value could be retrieved successfully, + <code>sal_False</code>, when none of the 4 methods gave a value. ppValue + then contains ane empty string. + When a pDefault value is given, the function returns always + <code>sal_True</code>. +*/ +sal_Bool SAL_CALL rtl_bootstrap_get( rtl_uString *pName, rtl_uString **ppValue, rtl_uString *pDefault ) + SAL_THROW_EXTERN_C(); + +/** Sets a bootstrap parameter. + + @param pName + name of bootstrap parameter + @param pValue + value of bootstrap parameter +*/ +void SAL_CALL rtl_bootstrap_set( rtl_uString * pName, rtl_uString * pValue ) + SAL_THROW_EXTERN_C(); + + +typedef void * rtlBootstrapHandle; + +/** + Opens a bootstrap argument container. + @param pIniName [in] The name of the ini-file to use, if <code>NULL</code> defaults + to the excutables name + @return Handle for a boostrap argument container +*/ +rtlBootstrapHandle SAL_CALL rtl_bootstrap_args_open(rtl_uString * pIniName) + SAL_THROW_EXTERN_C(); + +/** + Closes a boostrap agument container. + @param handle [in] The handle got by <code>rtl_bootstrap_args_open()</code> +*/ +void SAL_CALL rtl_bootstrap_args_close(rtlBootstrapHandle handle) + SAL_THROW_EXTERN_C(); + +/** + @param handle [in] The handle got by <code>rtl_bootstrap_args_open()</code> + @param pName [in] The name of the variable to be retrieved + @param ppValue [out] The result of the retrieval. *ppValue may be null in case of failure. + @param pDefault [in] The default value for the retrieval, may be <code>NULL</code> + + @return The status of the retrieval, <code>sal_True</code> on success. +*/ +sal_Bool SAL_CALL rtl_bootstrap_get_from_handle(rtlBootstrapHandle handle, rtl_uString *pName, rtl_uString **ppValue, rtl_uString *pDefault) + SAL_THROW_EXTERN_C(); + + +/** Returns the name of the inifile associated with this handle. + + @param ppIniName contains after the call the name of the ini-filename. +*/ +void SAL_CALL rtl_bootstrap_get_iniName_from_handle(rtlBootstrapHandle handle, rtl_uString ** ppIniName) + SAL_THROW_EXTERN_C(); + +/** Expands a macro using bootstrap variables. + + @param handle [in] The handle got by <code>rtl_bootstrap_args_open()</code> + @param macro [inout] The macro to be expanded +*/ +void SAL_CALL rtl_bootstrap_expandMacros_from_handle( + rtlBootstrapHandle handle, rtl_uString ** macro ) + SAL_THROW_EXTERN_C(); +/** Expands a macro using default bootstrap variables. + + @param macro [inout] The macro to be expanded +*/ +void SAL_CALL rtl_bootstrap_expandMacros( + rtl_uString ** macro ) + SAL_THROW_EXTERN_C(); + +/** Escapes special characters ("$" and "\"). + + @param value + an arbitrary, non-NULL value + + @param encoded + non-NULL out parameter, receiving the given value with all occurences of + special characters ("$" and "\") escaped + + @since UDK 3.2.9 +*/ +void SAL_CALL rtl_bootstrap_encode( + rtl_uString const * value, rtl_uString ** encoded ) + SAL_THROW_EXTERN_C(); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/sal/inc/rtl/bootstrap.hxx b/sal/inc/rtl/bootstrap.hxx new file mode 100644 index 000000000000..f8f1f7a95f48 --- /dev/null +++ b/sal/inc/rtl/bootstrap.hxx @@ -0,0 +1,234 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_BOOTSTRAP_HXX_ +#define _RTL_BOOTSTRAP_HXX_ +#include <rtl/ustring.hxx> +#include <rtl/bootstrap.h> + +namespace rtl +{ + class Bootstrap + { + void * _handle; + + /** @internal */ + inline Bootstrap( Bootstrap const & ); // not impl + /** @internal */ + inline Bootstrap & operator = ( Bootstrap const & ); // not impl + + public: + /** + @see rtl_bootstrap_setIniFileName() + */ + static inline void SAL_CALL setIniFilename( const ::rtl::OUString &sFile ); + + /** Retrieves a bootstrap parameter + @param sName name of the bootstrap value. case insensitive. + @param outValue (out parameter). On success contains the value, otherwise + an empty string. + @return sal_False, if no value could be retrieved, otherwise sal_True + @see rtl_bootstrap_get() + */ + static inline sal_Bool get( + const ::rtl::OUString &sName, + ::rtl::OUString &outValue ); + + /** Retrieves a bootstrap parameter + + @param sName name of the bootstrap value. case insensitive. + @param outValue (out parameter). Contains the value associated with sName. + @param aDefault if none of the other methods retrieved a value, outValue + is assigned to a Default. + + @see rtl_bootstrap_get() + */ + static inline void get( + const ::rtl::OUString &sName, + ::rtl::OUString &outValue, + const ::rtl::OUString &aDefault ); + + /** Sets a bootstrap parameter. + + @param pName + name of bootstrap parameter + @param pValue + value of bootstrap parameter + + @see rtl_bootstrap_set() + */ + static inline void set( ::rtl::OUString const & name, ::rtl::OUString const & value ) + SAL_THROW( () ); + + /** default ctor. + */ + inline Bootstrap(); + + /** Opens a bootstrap argment container + @see rtl_bootstrap_args_open() + */ + inline Bootstrap(const OUString & iniName); + + /** Closes a bootstrap argument container + @see rtl_bootstrap_args_close() + */ + inline ~Bootstrap(); + + /** Retrieves a bootstrap argument. + + It is first tried to retrieve the value via the global function + and second via the special bootstrap container. + @see rtl_bootstrap_get_from_handle() + */ + + inline sal_Bool getFrom(const ::rtl::OUString &sName, + ::rtl::OUString &outValue) const; + + /** Retrieves a bootstrap argument. + + It is first tried to retrieve the value via the global function + and second via the special bootstrap container. + @see rtl_bootstrap_get_from_handle() + */ + inline void getFrom(const ::rtl::OUString &sName, + ::rtl::OUString &outValue, + const ::rtl::OUString &aDefault) const; + + /** Retrieves the name of the underlying ini-file. + @see rtl_bootstrap_get_iniName_from_handle() + */ + inline void getIniName(::rtl::OUString & iniName) const; + + /** Expands a macro using bootstrap variables. + + @param macro [inout] The macro to be expanded + */ + inline void expandMacrosFrom( ::rtl::OUString & macro ) const SAL_THROW( () ) + { rtl_bootstrap_expandMacros_from_handle( _handle, ¯o.pData ); } + + /** Expands a macro using default bootstrap variables. + + @param macro [inout] The macro to be expanded + */ + static inline void expandMacros( ::rtl::OUString & macro ) SAL_THROW( () ) + { rtl_bootstrap_expandMacros( ¯o.pData ); } + + /** Provides the bootstrap internal handle. + + @return bootstrap handle + */ + inline rtlBootstrapHandle getHandle() const SAL_THROW( () ) + { return _handle; } + + /** Escapes special characters ("$" and "\"). + + @param value + an arbitrary value + + @return + the given value, with all occurences of special characters ("$" and + "\") escaped + + @since UDK 3.2.9 + */ + static inline ::rtl::OUString encode( ::rtl::OUString const & value ) + SAL_THROW( () ); + }; + + //---------------------------------------------------------------------------- + // IMPLEMENTATION + //---------------------------------------------------------------------------- + inline void Bootstrap::setIniFilename( const ::rtl::OUString &sFile ) + { + rtl_bootstrap_setIniFileName( sFile.pData ); + } + + inline sal_Bool Bootstrap::get( const ::rtl::OUString &sName, + ::rtl::OUString & outValue ) + { + return rtl_bootstrap_get( sName.pData , &(outValue.pData) , 0 ); + } + + inline void Bootstrap::get( const ::rtl::OUString &sName, + ::rtl::OUString & outValue, + const ::rtl::OUString & sDefault ) + { + rtl_bootstrap_get( sName.pData , &(outValue.pData) , sDefault.pData ); + } + + inline void Bootstrap::set( ::rtl::OUString const & name, ::rtl::OUString const & value ) + SAL_THROW( () ) + { + rtl_bootstrap_set( name.pData, value.pData ); + } + + inline Bootstrap::Bootstrap() + { + _handle = 0; + } + + inline Bootstrap::Bootstrap(const OUString & iniName) + { + if(iniName.getLength()) + _handle = rtl_bootstrap_args_open(iniName.pData); + + else + _handle = 0; + } + + inline Bootstrap::~Bootstrap() + { + rtl_bootstrap_args_close(_handle); + } + + + inline sal_Bool Bootstrap::getFrom(const ::rtl::OUString &sName, + ::rtl::OUString &outValue) const + { + return rtl_bootstrap_get_from_handle(_handle, sName.pData, &outValue.pData, 0); + } + + inline void Bootstrap::getFrom(const ::rtl::OUString &sName, + ::rtl::OUString &outValue, + const ::rtl::OUString &aDefault) const + { + rtl_bootstrap_get_from_handle(_handle, sName.pData, &outValue.pData, aDefault.pData); + } + + inline void Bootstrap::getIniName(::rtl::OUString & iniName) const + { + rtl_bootstrap_get_iniName_from_handle(_handle, &iniName.pData); + } + + inline ::rtl::OUString Bootstrap::encode( ::rtl::OUString const & value ) + SAL_THROW( () ) + { + ::rtl::OUString encoded; + rtl_bootstrap_encode(value.pData, &encoded.pData); + return encoded; + } +} +#endif diff --git a/sal/inc/rtl/byteseq.h b/sal/inc/rtl/byteseq.h new file mode 100644 index 000000000000..3c0b6862b70b --- /dev/null +++ b/sal/inc/rtl/byteseq.h @@ -0,0 +1,322 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_BYTESEQ_H_ +#define _RTL_BYTESEQ_H_ + +#include <sal/types.h> +#include <rtl/alloc.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** Assures that the reference count of the given byte sequence is one. Otherwise a new copy + of the sequence is created with a reference count of one. + + @param ppSequence sequence +*/ +void SAL_CALL rtl_byte_sequence_reference2One( + sal_Sequence ** ppSequence ) + SAL_THROW_EXTERN_C(); + +/** Reallocates length of byte sequence. + + @param ppSequence sequence + @param nSize new size of sequence +*/ +void SAL_CALL rtl_byte_sequence_realloc( + sal_Sequence ** ppSequence, sal_Int32 nSize ) + SAL_THROW_EXTERN_C(); + +/** Acquires the byte sequence + + @param pSequence sequence, that is to be acquired +*/ +void SAL_CALL rtl_byte_sequence_acquire( + sal_Sequence *pSequence ) + SAL_THROW_EXTERN_C(); + +/** Releases the byte sequence. If the refcount drops to zero, the sequence is freed. + + @param pSequence sequence, that is to be released; invalid after call +*/ +void SAL_CALL rtl_byte_sequence_release( + sal_Sequence *pSequence ) + SAL_THROW_EXTERN_C(); + +/** Constructs a bytes sequence with length nLength. All bytes are set to zero. + + @param ppSequence inout sequence; on entry *ppSequence may be null, otherwise it is released; + after the call, *ppSequence contains the newly constructed sequence + @param nLength length of new sequence +*/ +void SAL_CALL rtl_byte_sequence_construct( + sal_Sequence **ppSequence , sal_Int32 nLength ) + SAL_THROW_EXTERN_C(); + +/** Constructs a bytes sequence with length nLength. The data is not initialized. + + @param ppSequence inout sequence; on entry *ppSequence may be null, otherwise it is released; + after the call, *ppSequence contains the newly constructed sequence + @param nLength length of new sequence +*/ +void SAL_CALL rtl_byte_sequence_constructNoDefault( + sal_Sequence **ppSequence , sal_Int32 nLength ) + SAL_THROW_EXTERN_C(); + +/** Constructs a byte sequence with length nLength and copies nLength bytes from pData. + + @param ppSequence inout sequence; on entry *ppSequence may be null, otherwise it is released; + after the call, *ppSequence contains the newly constructed sequence + @param pData initial data + @param nLength length of new sequence +*/ +void SAL_CALL rtl_byte_sequence_constructFromArray( + sal_Sequence **ppSequence, const sal_Int8 *pData , sal_Int32 nLength ) + SAL_THROW_EXTERN_C(); + +/** Assigns the byte sequence pSequence to *ppSequence. + + @param ppSequence inout sequence; on entry *ppSequence may be null, otherwise it is released; + after the call, *ppSequence references pSequence + @param pSequence the source sequence +*/ +void SAL_CALL rtl_byte_sequence_assign( + sal_Sequence **ppSequence , sal_Sequence *pSequence ) + SAL_THROW_EXTERN_C(); + +/** Compares two byte sequences. + + @return true, if the data within the sequences are identical; false otherwise +*/ +sal_Bool SAL_CALL rtl_byte_sequence_equals( + sal_Sequence *pSequence1 , sal_Sequence *pSequence2 ) + SAL_THROW_EXTERN_C(); + +/** Returns the data array pointer of the sequence. + + @return read-pointer to the data array of the sequence. If rtl_byte_sequence_reference2One() + has been called before, the pointer may be casted to a non const pointer and + the sequence may be modified +*/ +const sal_Int8 *SAL_CALL rtl_byte_sequence_getConstArray( + sal_Sequence *pSequence ) + SAL_THROW_EXTERN_C(); + +/** Returns the length of the sequence + + @param pSequence sequence handle + @return length of the sequence +*/ +sal_Int32 SAL_CALL rtl_byte_sequence_getLength( + sal_Sequence *pSequence ) + SAL_THROW_EXTERN_C(); + +#ifdef __cplusplus +} +namespace rtl +{ + +enum __ByteSequence_NoDefault +{ + /** This enum value can be used to create a bytesequence with uninitalized data + */ + BYTESEQ_NODEFAULT = 0xcafe +}; + +enum __ByteSequence_NoAcquire +{ + /** This enum value can be used to create a bytesequence from a C-Handle without + acquiring the handle. + */ + BYTESEQ_NOACQUIRE = 0xcafebabe +}; + +/** C++ class representing a SAL byte sequence. + C++ Sequences are reference counted and shared, so the sequence keeps a handle to its data. + To keep value semantics, copies are only generated if the sequence is to be modified + (new handle). +*/ +class ByteSequence +{ + /** sequence handle + @internal + */ + sal_Sequence * _pSequence; + +public: + // these are here to force memory de/allocation to sal lib. + /** @internal */ + inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () ) + { return ::rtl_allocateMemory( nSize ); } + /** @internal */ + inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () ) + { ::rtl_freeMemory( pMem ); } + /** @internal */ + inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () ) + { return pMem; } + /** @internal */ + inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () ) + {} + + /** Default constructor: Creates an empty sequence. + */ + inline ByteSequence() SAL_THROW( () ); + /** Copy constructor: Creates a copy of given sequence. + + @param rSeq another byte sequence + */ + inline ByteSequence( const ByteSequence & rSeq ) SAL_THROW( () ); + /** Copy constructor Creates a copy from the C-Handle. + + @param pSequence another byte sequence handle + */ + inline ByteSequence( sal_Sequence *pSequence ) SAL_THROW( () ); + /** Constructor: Creates a copy of given data bytes. + + @param pElements an array of bytes + @param len number of bytes + */ + inline ByteSequence( const sal_Int8 * pElements, sal_Int32 len ); + /** Constructor: Creates sequence of given length and initializes all bytes to 0. + + @param len initial sequence length + */ + inline ByteSequence( sal_Int32 len ); + /** Constructor: Creates sequence of given length and does NOT initialize data. + Use this ctor for performance optimization only. + + @param len initial sequence length + @param nodefault dummy parameter forcing explicit BYTESEQ_NODEFAULT + */ + inline ByteSequence( sal_Int32 len , enum __ByteSequence_NoDefault nodefault ); + /** Constructor: + Creates a sequence from a C-Handle without acquiring the handle, thus taking + over owenership. Eitherway the handle is release by the destructor. + This ctor is useful, when working with a c-interface (it safes a pair of + acquire and release call and is thus a performance optimization only). + + @param pSequence sequence handle to be taken over + @param noacquire dummy parameter forcing explicit BYTESEQ_NOACQUIRE + */ + inline ByteSequence( sal_Sequence *pSequence , enum __ByteSequence_NoAcquire noacquire ) SAL_THROW( () ); + /** Destructor: Releases sequence handle. Last handle will free memory. + */ + inline ~ByteSequence() SAL_THROW( () ); + + /** Assignment operator: Acquires given sequence handle and releases a previously set handle. + + @param rSeq another byte sequence + @return this sequence + */ + inline ByteSequence & SAL_CALL operator = ( const ByteSequence & rSeq ) SAL_THROW( () ); + + /** Gets the length of sequence. + + @return length of sequence + */ + inline sal_Int32 SAL_CALL getLength() const SAL_THROW( () ) + { return _pSequence->nElements; } + + /** Gets a pointer to byte array for READING. If the sequence has a length of 0, then the + returned pointer is undefined. + + @return pointer to byte array + */ + inline const sal_Int8 * SAL_CALL getConstArray() const SAL_THROW( () ) + { return (const sal_Int8 *)_pSequence->elements; } + /** Gets a pointer to elements array for READING AND WRITING. In general if the sequence + has a handle acquired by other sequences (reference count > 1), then a new sequence is + created copying all bytes to keep value semantics! + If the sequence has a length of 0, then the returned pointer is undefined. + + @return pointer to elements array + */ + inline sal_Int8 * SAL_CALL getArray(); + + /** Non-const index operator: + Obtains a reference to byte indexed at given position. + In general if the sequence has a handle acquired by other + sequences (reference count > 1), then a new sequence is created + copying all bytes to keep value semantics! + + @attention + The implementation does NOT check for array bounds! + + @param nIndex index + @return non-const C++ reference to element at index nIndex + */ + inline sal_Int8 & SAL_CALL operator [] ( sal_Int32 nIndex ); + + /** Const index operator: Obtains a reference to byte indexed at given position. + The implementation does NOT check for array bounds! + + @param nIndex index + @return const C++ reference to byte at element of indenx nIndex + */ + inline const sal_Int8 & SAL_CALL operator [] ( sal_Int32 nIndex ) const SAL_THROW( () ) + { return getConstArray()[ nIndex ]; } + + /** Equality operator: Compares two sequences. + + @param rSeq another byte sequence (right side) + @return true if both sequences are equal, false otherwise + */ + inline sal_Bool SAL_CALL operator == ( const ByteSequence & rSeq ) const SAL_THROW( () ); + /** Unequality operator: Compares two sequences. + + @param rSeq another byte sequence (right side) + @return false if both sequences are equal, true otherwise + */ + inline sal_Bool SAL_CALL operator != ( const ByteSequence & rSeq ) const SAL_THROW( () ); + + /** Reallocates sequence to new length. If the sequence has a handle acquired by other sequences + (reference count > 1), then the remaining elements are copied to a new sequence handle to + keep value semantics! + + @param nSize new size of sequence + */ + inline void SAL_CALL realloc( sal_Int32 nSize ); + + /** Returns the UNnacquired C handle of the sequence + + @return UNacquired handle of the sequence + */ + inline sal_Sequence * SAL_CALL getHandle() const SAL_THROW( () ) + { return _pSequence; } + /** Returns the UNnacquired C handle of the sequence (for compatibility reasons) + + @return UNacquired handle of the sequence + */ + inline sal_Sequence * SAL_CALL get() const SAL_THROW( () ) + { return _pSequence; } +}; + +} +#endif +#endif diff --git a/sal/inc/rtl/byteseq.hxx b/sal/inc/rtl/byteseq.hxx new file mode 100644 index 000000000000..698e4f01df05 --- /dev/null +++ b/sal/inc/rtl/byteseq.hxx @@ -0,0 +1,143 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_BYTESEQ_HXX_ +#define _RTL_BYTESEQ_HXX_ + +#include <osl/interlck.h> +#include <rtl/byteseq.h> +#include <rtl/alloc.h> +#include <rtl/memory.h> + +#if ! defined EXCEPTIONS_OFF +#include <new> +#endif + + +namespace rtl +{ + +//__________________________________________________________________________________________________ +inline ByteSequence::ByteSequence() SAL_THROW( () ) + : _pSequence( 0 ) +{ + ::rtl_byte_sequence_construct( &_pSequence, 0 ); +} +//__________________________________________________________________________________________________ +inline ByteSequence::ByteSequence( const ByteSequence & rSeq ) SAL_THROW( () ) + : _pSequence( 0 ) +{ + ::rtl_byte_sequence_assign( &_pSequence, rSeq._pSequence ); +} +//__________________________________________________________________________________________________ +inline ByteSequence::ByteSequence( sal_Sequence *pSequence) SAL_THROW( () ) + : _pSequence( pSequence ) +{ + ::rtl_byte_sequence_acquire( pSequence ); +} +//__________________________________________________________________________________________________ +inline ByteSequence::ByteSequence( const sal_Int8 * pElements, sal_Int32 len ) + : _pSequence( 0 ) +{ + ::rtl_byte_sequence_constructFromArray( &_pSequence, pElements, len ); +#if ! defined EXCEPTIONS_OFF + if (_pSequence == 0) + throw ::std::bad_alloc(); +#endif +} +//__________________________________________________________________________________________________ +inline ByteSequence::ByteSequence( sal_Int32 len, enum __ByteSequence_NoDefault ) + : _pSequence( 0 ) +{ + ::rtl_byte_sequence_constructNoDefault( &_pSequence, len ); +#if ! defined EXCEPTIONS_OFF + if (_pSequence == 0) + throw ::std::bad_alloc(); +#endif +} +//__________________________________________________________________________________________________ +inline ByteSequence::ByteSequence( sal_Sequence *pSequence, enum __ByteSequence_NoAcquire ) SAL_THROW( () ) + : _pSequence( pSequence ) +{ +} +//__________________________________________________________________________________________________ +inline ByteSequence::ByteSequence( sal_Int32 len ) + : _pSequence( 0 ) +{ + ::rtl_byte_sequence_construct( &_pSequence, len ); +#if ! defined EXCEPTIONS_OFF + if (_pSequence == 0) + throw ::std::bad_alloc(); +#endif +} +//__________________________________________________________________________________________________ +inline ByteSequence::~ByteSequence() SAL_THROW( () ) +{ + ::rtl_byte_sequence_release( _pSequence ); +} +//__________________________________________________________________________________________________ +inline ByteSequence & ByteSequence::operator = ( const ByteSequence & rSeq ) SAL_THROW( () ) +{ + ::rtl_byte_sequence_assign( &_pSequence, rSeq._pSequence ); + return *this; +} +//__________________________________________________________________________________________________ +inline sal_Bool ByteSequence::operator == ( const ByteSequence & rSeq ) const SAL_THROW( () ) +{ + return ::rtl_byte_sequence_equals( _pSequence, rSeq._pSequence ); +} +//__________________________________________________________________________________________________ +inline sal_Int8 * ByteSequence::getArray() +{ + ::rtl_byte_sequence_reference2One( &_pSequence ); +#if ! defined EXCEPTIONS_OFF + if (_pSequence == 0) + throw ::std::bad_alloc(); +#endif + return (sal_Int8 *)_pSequence->elements; +} +//__________________________________________________________________________________________________ +inline void ByteSequence::realloc( sal_Int32 nSize ) +{ + ::rtl_byte_sequence_realloc( &_pSequence, nSize ); +#if ! defined EXCEPTIONS_OFF + if (_pSequence == 0) + throw ::std::bad_alloc(); +#endif +} +//__________________________________________________________________________________________________ +inline sal_Int8 & ByteSequence::operator [] ( sal_Int32 nIndex ) +{ + return getArray()[ nIndex ]; +} +//__________________________________________________________________________________________________ +inline sal_Bool ByteSequence::operator != ( const ByteSequence & rSeq ) const SAL_THROW( () ) +{ + return (! operator == ( rSeq )); +} + +} +#endif diff --git a/sal/inc/rtl/cipher.h b/sal/inc/rtl/cipher.h new file mode 100644 index 000000000000..8cb2a2f2256b --- /dev/null +++ b/sal/inc/rtl/cipher.h @@ -0,0 +1,319 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_CIPHER_H_ +#define _RTL_CIPHER_H_ "$Revision: 1.7 $" + +#include <sal/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/*======================================================================== + * + * rtlCipher interface. + * + *======================================================================*/ +/** Cipher Handle opaque type. + */ +typedef void* rtlCipher; + + +/** Cipher Algorithm enumeration. + @see rtl_cipher_create() + */ +enum __rtl_CipherAlgorithm +{ + rtl_Cipher_AlgorithmBF, + rtl_Cipher_AlgorithmARCFOUR, + rtl_Cipher_AlgorithmInvalid, + rtl_Cipher_Algorithm_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Cipher Algorithm type. + */ +typedef enum __rtl_CipherAlgorithm rtlCipherAlgorithm; + + +/** Cipher Mode enumeration. + @see rtl_cipher_create() + */ +enum __rtl_CipherMode +{ + rtl_Cipher_ModeECB, + rtl_Cipher_ModeCBC, + rtl_Cipher_ModeStream, + rtl_Cipher_ModeInvalid, + rtl_Cipher_Mode_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Cipher Mode type. + */ +typedef enum __rtl_CipherMode rtlCipherMode; + + +/** Cipher Direction enumeration. + @see rtl_cipher_init() + */ +enum __rtl_CipherDirection +{ + rtl_Cipher_DirectionBoth, + rtl_Cipher_DirectionDecode, + rtl_Cipher_DirectionEncode, + rtl_Cipher_DirectionInvalid, + rtl_Cipher_Direction_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Cipher Direction type. + */ +typedef enum __rtl_CipherDirection rtlCipherDirection; + + +/** Error Code enumeration. + */ +enum __rtl_CipherError +{ + rtl_Cipher_E_None, + rtl_Cipher_E_Argument, + rtl_Cipher_E_Algorithm, + rtl_Cipher_E_Direction, + rtl_Cipher_E_Mode, + rtl_Cipher_E_BufferSize, + rtl_Cipher_E_Memory, + rtl_Cipher_E_Unknown, + rtl_Cipher_E_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Error Code type. + */ +typedef enum __rtl_CipherError rtlCipherError; + + +/** Create a cipher handle for the given algorithm and mode. + @see rtlCipherAlgorithm + @see rtlCipherMode + + @param Algorithm [in] cipher algorithm. + @param Mode [in] cipher mode. + @return Cipher handle, or 0 upon failure. + */ +rtlCipher SAL_CALL rtl_cipher_create ( + rtlCipherAlgorithm Algorithm, + rtlCipherMode Mode +) SAL_THROW_EXTERN_C(); + + +/** Inititialize a cipher for the given direction. + @see rtlCipherDirection + + @param Cipher [in] cipher handle. + @param Direction [in] cipher direction. + @param pKeyData [in] key material buffer. + @param nKeyLen [in] key material length in bytes. + @param pArgData [in] initialization vector buffer. + @param nArgLen [in] initialization vector length in bytes. + @return rtl_Cipher_E_None upon success. + */ +rtlCipherError SAL_CALL rtl_cipher_init ( + rtlCipher Cipher, + rtlCipherDirection Direction, + const sal_uInt8 *pKeyData, sal_Size nKeyLen, + const sal_uInt8 *pArgData, sal_Size nArgLen +) SAL_THROW_EXTERN_C(); + + +/** Encode a buffer under a given cipher algorithm. + @precond Initialized for a compatible cipher direction. + @see rtl_cipher_init() + + @param Cipher [in] cipher handle. + @param pData [in] plaintext buffer. + @param nDatLen [in] plaintext length in bytes. + @param pBuffer [out] ciphertext buffer. + @param nBufLen [in] ciphertext length in bytes. + @return rtl_Cipher_E_None upon success. + */ +rtlCipherError SAL_CALL rtl_cipher_encode ( + rtlCipher Cipher, + const void *pData, sal_Size nDatLen, + sal_uInt8 *pBuffer, sal_Size nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Decode a buffer under a given cipher algorithm. + @precond Initialized for a compatible cipher direction. + @see rtl_cipher_init() + + @param Cipher [in] cipher handle. + @param pData [in] ciphertext buffer. + @param nDatLen [in] ciphertext length in bytes. + @param pBuffer [out] plaintext buffer. + @param nBufLen [in] plaintext length in bytes. + @return rtl_Cipher_E_None upon success. + */ +rtlCipherError SAL_CALL rtl_cipher_decode ( + rtlCipher Cipher, + const void *pData, sal_Size nDatLen, + sal_uInt8 *pBuffer, sal_Size nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Destroy a cipher handle. + @param Cipher [in] cipher handle to be destroyed. + @return None. Cipher handle destroyed and invalid. + */ +void SAL_CALL rtl_cipher_destroy ( + rtlCipher Cipher +) SAL_THROW_EXTERN_C(); + + +/*======================================================================== + * + * rtl_cipherBF (Blowfish) interface. + * + *======================================================================*/ +/** Create a Blowfish cipher handle for the given mode. + @descr The Blowfish block cipher algorithm is specified in + Bruce Schneier: Applied Cryptography, 2nd edition, ch. 14.3 + + @see rtl_cipher_create() + */ +rtlCipher SAL_CALL rtl_cipher_createBF ( + rtlCipherMode Mode +) SAL_THROW_EXTERN_C(); + + +/** Inititialize a Blowfish cipher for the given direction. + @see rtl_cipher_init() + */ +rtlCipherError SAL_CALL rtl_cipher_initBF ( + rtlCipher Cipher, + rtlCipherDirection Direction, + const sal_uInt8 *pKeyData, sal_Size nKeyLen, + const sal_uInt8 *pArgData, sal_Size nArgLen +) SAL_THROW_EXTERN_C(); + + +/** Encode a buffer under the Blowfish cipher algorithm. + @see rtl_cipher_encode() + */ +rtlCipherError SAL_CALL rtl_cipher_encodeBF ( + rtlCipher Cipher, + const void *pData, sal_Size nDatLen, + sal_uInt8 *pBuffer, sal_Size nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Decode a buffer under the Blowfish cipher algorithm. + @see rtl_cipher_decode() + */ +rtlCipherError SAL_CALL rtl_cipher_decodeBF ( + rtlCipher Cipher, + const void *pData, sal_Size nDatLen, + sal_uInt8 *pBuffer, sal_Size nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Destroy a Blowfish cipher handle. + @see rtl_cipher_destroy() + */ +void SAL_CALL rtl_cipher_destroyBF ( + rtlCipher Cipher +) SAL_THROW_EXTERN_C(); + + +/*======================================================================== + * + * rtl_cipherARCFOUR (RC4) interface. + * + *======================================================================*/ +/** Create a RC4 cipher handle for the given mode. + @descr The RC4 symmetric stream cipher algorithm is specified in + Bruce Schneier: Applied Cryptography, 2nd edition, ch. 17.1 + + @see rtl_cipher_create() + + @param Mode [in] cipher mode. Must be rtl_Cipher_ModeStream. + @return Cipher handle, or 0 upon failure. + */ +rtlCipher SAL_CALL rtl_cipher_createARCFOUR ( + rtlCipherMode Mode +) SAL_THROW_EXTERN_C(); + + +/** Inititialize a RC4 cipher for the given direction. + @see rtl_cipher_init() + */ +rtlCipherError SAL_CALL rtl_cipher_initARCFOUR ( + rtlCipher Cipher, + rtlCipherDirection Direction, + const sal_uInt8 *pKeyData, sal_Size nKeyLen, + const sal_uInt8 *pArgData, sal_Size nArgLen +) SAL_THROW_EXTERN_C(); + + +/** Encode a buffer under the RC4 cipher algorithm. + @see rtl_cipher_encode() + */ +rtlCipherError SAL_CALL rtl_cipher_encodeARCFOUR ( + rtlCipher Cipher, + const void *pData, sal_Size nDatLen, + sal_uInt8 *pBuffer, sal_Size nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Decode a buffer under the RC4 cipher algorithm. + @see rtl_cipher_decode() + */ +rtlCipherError SAL_CALL rtl_cipher_decodeARCFOUR ( + rtlCipher Cipher, + const void *pData, sal_Size nDatLen, + sal_uInt8 *pBuffer, sal_Size nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Destroy a RC4 cipher handle. + @see rtl_cipher_destroy() + */ +void SAL_CALL rtl_cipher_destroyARCFOUR ( + rtlCipher Cipher +) SAL_THROW_EXTERN_C(); + + +/*======================================================================== + * + * The End. + * + *======================================================================*/ + +#ifdef __cplusplus +} +#endif + +#endif /* !_RTL_CIPHER_H_ */ + diff --git a/sal/inc/rtl/crc.h b/sal/inc/rtl/crc.h new file mode 100644 index 000000000000..f30a873c67f2 --- /dev/null +++ b/sal/inc/rtl/crc.h @@ -0,0 +1,66 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_CRC_H_ +#define _RTL_CRC_H_ "$Revision: 1.4 $" + +#include <sal/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/*======================================================================== + * + * rtl_crc32 interface. + * + *======================================================================*/ +/** Evaluate CRC32 over given data. + @descr This function evaluates the CRC polynomial 0xEDB88320. + + @param Crc [in] CRC32 over previous data or zero. + @param Data [in] data buffer. + @param DatLen [in] data buffer length. + @return new CRC32 value. + */ +sal_uInt32 SAL_CALL rtl_crc32 ( + sal_uInt32 Crc, + const void *Data, sal_uInt32 DatLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * The End. + * + *======================================================================*/ + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_CRC_H_ */ + diff --git a/sal/inc/rtl/digest.h b/sal/inc/rtl/digest.h new file mode 100644 index 000000000000..c0e3a346b90b --- /dev/null +++ b/sal/inc/rtl/digest.h @@ -0,0 +1,639 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_DIGEST_H_ +#define _RTL_DIGEST_H_ "$Revision: 1.8 $" + +#include <sal/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/*======================================================================== + * + * rtlDigest. + * + *======================================================================*/ +/** Digest Handle opaque type. + */ +typedef void* rtlDigest; + + +/** Digest Algorithm enumeration. + @see rtl_digest_create() + */ +enum __rtl_DigestAlgorithm +{ + rtl_Digest_AlgorithmMD2, + rtl_Digest_AlgorithmMD5, + rtl_Digest_AlgorithmSHA, + rtl_Digest_AlgorithmSHA1, + + rtl_Digest_AlgorithmHMAC_MD5, + rtl_Digest_AlgorithmHMAC_SHA1, + + rtl_Digest_AlgorithmInvalid, + rtl_Digest_Algorithm_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Digest Algorithm type. + */ +typedef enum __rtl_DigestAlgorithm rtlDigestAlgorithm; + + +/** Error Code enumeration. + */ +enum __rtl_DigestError +{ + rtl_Digest_E_None, + rtl_Digest_E_Argument, + rtl_Digest_E_Algorithm, + rtl_Digest_E_BufferSize, + rtl_Digest_E_Memory, + rtl_Digest_E_Unknown, + rtl_Digest_E_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Error Code type. + */ +typedef enum __rtl_DigestError rtlDigestError; + + +/** Create a digest handle for the given algorithm. + @see rtlDigestAlgorithm + + @param Algorithm [in] digest algorithm. + @return Digest handle, or 0 upon failure. + */ +rtlDigest SAL_CALL rtl_digest_create ( + rtlDigestAlgorithm Algorithm +) SAL_THROW_EXTERN_C(); + + +/** Destroy a digest handle. + @postcond Digest handle destroyed and invalid. + @param Digest [in] digest handle to be destroyed. + @return None. + */ +void SAL_CALL rtl_digest_destroy ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Query the algorithm of a given digest. + @param Digest [in] digest handle. + @return digest algorithm, or rtl_Digest_AlgorithmInvalid upon failure. + */ +rtlDigestAlgorithm SAL_CALL rtl_digest_queryAlgorithm ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Query the length of a given digest. + @param Digest [in] digest handle. + @return digest length, or 0 upon failure. + */ +sal_uInt32 SAL_CALL rtl_digest_queryLength ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Initialize a digest with given data. + @param Digest [in] digest handle. + @param pData [in] data buffer. + @param nDatLen [in] data length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_init ( + rtlDigest Digest, + const sal_uInt8 *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Update a digest with given data. + @param Digest [in] digest handle. + @param pData [in] data buffer. + @param nDatLen [in] data length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_update ( + rtlDigest Digest, + const void *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Finalize a digest and retrieve the digest value. + @precond Digest value length must not be less than digest length. + @postcond Digest initialized to accept another update sequence. + @see rtl_digest_queryLength() + @see rtl_digest_update() + + @param Digest [in] digest handle. + @param pBuffer [in] digest value buffer. + @param nBufLen [in] digest value length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_get ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * rtl_digest_MD2 interface. + * + *======================================================================*/ +#define RTL_DIGEST_LENGTH_MD2 16 + +/** Create a MD2 digest handle. + @descr The MD2 digest algorithm is specified in + + RFC 1319 (Informational) + The MD2 Message-Digest Algorithm + + @see rtl_digest_create() + */ +rtlDigest SAL_CALL rtl_digest_createMD2 (void) SAL_THROW_EXTERN_C(); + + +/** Destroy a MD2 digest handle. + @see rtl_digest_destroy() + */ +void SAL_CALL rtl_digest_destroyMD2 ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Update a MD2 digest with given data. + @see rtl_digest_update() + */ +rtlDigestError SAL_CALL rtl_digest_updateMD2 ( + rtlDigest Digest, + const void *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Finalize a MD2 digest and retrieve the digest value. + @see rtl_digest_get() + */ +rtlDigestError SAL_CALL rtl_digest_getMD2 ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Evaluate a MD2 digest value from given data. + @descr This function performs an optimized call sequence on a + single data buffer, avoiding digest creation and destruction. + + @see rtl_digest_updateMD2() + @see rtl_digest_getMD2() + + @param pData [in] data buffer. + @param nDatLen [in] data length. + @param pBuffer [in] digest value buffer. + @param nBufLen [in] digest value length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_MD2 ( + const void *pData, sal_uInt32 nDatLen, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * rtl_digest_MD5 interface. + * + *======================================================================*/ +#define RTL_DIGEST_LENGTH_MD5 16 + +/** Create a MD5 digest handle. + @descr The MD5 digest algorithm is specified in + + RFC 1321 (Informational) + The MD5 Message-Digest Algorithm + + @see rtl_digest_create() + */ +rtlDigest SAL_CALL rtl_digest_createMD5 (void) SAL_THROW_EXTERN_C(); + + +/** Destroy a MD5 digest handle. + @see rtl_digest_destroy() + */ +void SAL_CALL rtl_digest_destroyMD5 ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Update a MD5 digest with given data. + @see rtl_digest_update() + */ +rtlDigestError SAL_CALL rtl_digest_updateMD5 ( + rtlDigest Digest, + const void *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Finalize a MD5 digest and retrieve the digest value. + @see rtl_digest_get() + */ +rtlDigestError SAL_CALL rtl_digest_getMD5 ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Retrieve the raw (not finalized) MD5 digest value. + @descr This function is a non-standard replacement for + rtl_digest_getMD5() and must be used with caution. + + @postcond Digest initialized to accept another update sequence. + @see rtl_digest_get() + */ +rtlDigestError SAL_CALL rtl_digest_rawMD5 ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Evaluate a MD5 digest value from given data. + @descr This function performs an optimized call sequence on a + single data buffer, avoiding digest creation and destruction. + + @see rtl_digest_updateMD5() + @see rtl_digest_getMD5() + + @param pData [in] data buffer. + @param nDatLen [in] data length. + @param pBuffer [in] digest value buffer. + @param nBufLen [in] digest value length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_MD5 ( + const void *pData, sal_uInt32 nDatLen, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * rtl_digest_SHA interface. + * + *======================================================================*/ +#define RTL_DIGEST_LENGTH_SHA 20 + +/** Create a SHA digest handle. + @descr The SHA digest algorithm is specified in + + FIPS PUB 180 (Superseded by FIPS PUB 180-1) + Secure Hash Standard + + @see rtl_digest_create() + */ +rtlDigest SAL_CALL rtl_digest_createSHA (void) SAL_THROW_EXTERN_C(); + + +/** Destroy a SHA digest handle. + @see rtl_digest_destroy() + */ +void SAL_CALL rtl_digest_destroySHA ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Update a SHA digest with given data. + @see rtl_digest_update() + */ +rtlDigestError SAL_CALL rtl_digest_updateSHA ( + rtlDigest Digest, + const void *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Finalize a SHA digest and retrieve the digest value. + @see rtl_digest_get() + */ +rtlDigestError SAL_CALL rtl_digest_getSHA ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Evaluate a SHA digest value from given data. + @descr This function performs an optimized call sequence on a + single data buffer, avoiding digest creation and destruction. + + @see rtl_digest_updateSHA() + @see rtl_digest_getSHA() + + @param pData [in] data buffer. + @param nDatLen [in] data length. + @param pBuffer [in] digest value buffer. + @param nBufLen [in] digest value length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_SHA ( + const void *pData, sal_uInt32 nDatLen, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * rtl_digest_SHA1 interface. + * + *======================================================================*/ +#define RTL_DIGEST_LENGTH_SHA1 20 + +/** Create a SHA1 digest handle. + @descr The SHA1 digest algorithm is specified in + + FIPS PUB 180-1 (Supersedes FIPS PUB 180) + Secure Hash Standard + + @see rtl_digest_create() + */ +rtlDigest SAL_CALL rtl_digest_createSHA1 (void) SAL_THROW_EXTERN_C(); + + +/** Destroy a SHA1 digest handle. + @see rtl_digest_destroy() + */ +void SAL_CALL rtl_digest_destroySHA1 ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Update a SHA1 digest with given data. + @see rtl_digest_update() + */ +rtlDigestError SAL_CALL rtl_digest_updateSHA1 ( + rtlDigest Digest, + const void *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Finalize a SHA1 digest and retrieve the digest value. + @see rtl_digest_get() + */ +rtlDigestError SAL_CALL rtl_digest_getSHA1 ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Evaluate a SHA1 digest value from given data. + @descr This function performs an optimized call sequence on a + single data buffer, avoiding digest creation and destruction. + + @see rtl_digest_updateSHA1() + @see rtl_digest_getSHA1() + + @param pData [in] data buffer. + @param nDatLen [in] data length. + @param pBuffer [in] digest value buffer. + @param nBufLen [in] digest value length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_SHA1 ( + const void *pData, sal_uInt32 nDatLen, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * rtl_digest_HMAC_MD5 interface. + * + *======================================================================*/ +#define RTL_DIGEST_LENGTH_HMAC_MD5 RTL_DIGEST_LENGTH_MD5 + +/** Create a HMAC_MD5 digest handle. + @descr The HMAC_MD5 digest algorithm is specified in + + RFC 2104 (Informational) + HMAC: Keyed-Hashing for Message Authentication + + @see rtl_digest_create() + */ +rtlDigest SAL_CALL rtl_digest_createHMAC_MD5 (void) SAL_THROW_EXTERN_C(); + + +/** Destroy a HMAC_MD5 digest handle. + @see rtl_digest_destroy() + */ +void SAL_CALL rtl_digest_destroyHMAC_MD5 ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Initialize a HMAC_MD5 digest. + @see rtl_digest_init() + + @param Digest [in] digest handle. + @param pKeyData [in] key material buffer. + @param nKeyLen [in] key material length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_initHMAC_MD5 ( + rtlDigest Digest, + const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen +) SAL_THROW_EXTERN_C(); + + +/** Update a HMAC_MD5 digest with given data. + @see rtl_digest_update() + */ +rtlDigestError SAL_CALL rtl_digest_updateHMAC_MD5 ( + rtlDigest Digest, + const void *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Finalize a HMAC_MD5 digest and retrieve the digest value. + @see rtl_digest_get() + */ +rtlDigestError SAL_CALL rtl_digest_getHMAC_MD5 ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Evaluate a HMAC_MD5 digest value from given data. + @descr This function performs an optimized call sequence on a + single data buffer, avoiding digest creation and destruction. + + @see rtl_digest_initHMAC_MD5() + @see rtl_digest_updateHMAC_MD5() + @see rtl_digest_getHMAC_MD5() + + @param pKeyData [in] key material buffer. + @param nKeyLen [in] key material length. + @param pData [in] data buffer. + @param nDatLen [in] data length. + @param pBuffer [in] digest value buffer. + @param nBufLen [in] digest value length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_HMAC_MD5 ( + const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen, + const void *pData, sal_uInt32 nDatLen, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * rtl_digest_HMAC_SHA1 interface. + * + *======================================================================*/ +#define RTL_DIGEST_LENGTH_HMAC_SHA1 RTL_DIGEST_LENGTH_SHA1 + +/** Create a HMAC_SHA1 digest handle. + @descr The HMAC_SHA1 digest algorithm is specified in + + RFC 2104 (Informational) + HMAC: Keyed-Hashing for Message Authentication + RFC 2898 (Informational) + PKCS #5: Password-Based Cryptography Specification Version 2.0 + + @see rtl_digest_create() + */ +rtlDigest SAL_CALL rtl_digest_createHMAC_SHA1 (void) SAL_THROW_EXTERN_C(); + + +/** Destroy a HMAC_SHA1 digest handle. + @see rtl_digest_destroy() + */ +void SAL_CALL rtl_digest_destroyHMAC_SHA1 ( + rtlDigest Digest +) SAL_THROW_EXTERN_C(); + + +/** Initialize a HMAC_SHA1 digest. + @see rtl_digest_init() + + @param Digest [in] digest handle. + @param pKeyData [in] key material buffer. + @param nKeyLen [in] key material length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_initHMAC_SHA1 ( + rtlDigest Digest, + const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen +) SAL_THROW_EXTERN_C(); + + +/** Update a HMAC_SHA1 digest with given data. + @see rtl_digest_update() + */ +rtlDigestError SAL_CALL rtl_digest_updateHMAC_SHA1 ( + rtlDigest Digest, + const void *pData, sal_uInt32 nDatLen +) SAL_THROW_EXTERN_C(); + + +/** Finalize a HMAC_SHA1 digest and retrieve the digest value. + @see rtl_digest_get() + */ +rtlDigestError SAL_CALL rtl_digest_getHMAC_SHA1 ( + rtlDigest Digest, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + + +/** Evaluate a HMAC_SHA1 digest value from given data. + @descr This function performs an optimized call sequence on a + single data buffer, avoiding digest creation and destruction. + + @see rtl_digest_initHMAC_SHA1() + @see rtl_digest_updateHMAC_SHA1() + @see rtl_digest_getHMAC_SHA1() + + @param pKeyData [in] key material buffer. + @param nKeyLen [in] key material length. + @param pData [in] data buffer. + @param nDatLen [in] data length. + @param pBuffer [in] digest value buffer. + @param nBufLen [in] digest value length. + + @return rtl_Digest_E_None upon success. + */ +rtlDigestError SAL_CALL rtl_digest_HMAC_SHA1 ( + const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen, + const void *pData, sal_uInt32 nDatLen, + sal_uInt8 *pBuffer, sal_uInt32 nBufLen +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * rtl_digest_PBKDF2 interface. + * + *======================================================================*/ +/** Password-Based Key Derivation Function. + @descr The PBKDF2 key derivation function is specified in + + RFC 2898 (Informational) + PKCS #5: Password-Based Cryptography Specification Version 2.0 + + @param pKeyData [out] derived key + @param nKeyLen [in] derived key length + @param pPassData [in] password + @param nPassLen [in] password length + @param pSaltData [in] salt + @param nSaltLen [in] salt length + @param nCount [in] iteration count + + @return rtl_Digest_E_None upon success. +*/ +rtlDigestError SAL_CALL rtl_digest_PBKDF2 ( + sal_uInt8 *pKeyData , sal_uInt32 nKeyLen, + const sal_uInt8 *pPassData, sal_uInt32 nPassLen, + const sal_uInt8 *pSaltData, sal_uInt32 nSaltLen, + sal_uInt32 nCount +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * The End. + * + *======================================================================*/ + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_DIGEST_H_ */ + diff --git a/sal/inc/rtl/instance.hxx b/sal/inc/rtl/instance.hxx new file mode 100644 index 000000000000..0bf4806bafd4 --- /dev/null +++ b/sal/inc/rtl/instance.hxx @@ -0,0 +1,472 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#if !defined INCLUDED_RTL_INSTANCE_HXX +#define INCLUDED_RTL_INSTANCE_HXX + +#include "osl/doublecheckedlocking.h" +#include "osl/getglobalmutex.hxx" + +namespace { + +/** A non-broken version of the double-checked locking pattern. + + See + <http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html> + for a description of double-checked locking, why it is broken, and how it + can be fixed. Always use this template instead of spelling out the + double-checked locking pattern explicitly, and only in those rare cases + where that is not possible and you have to spell it out explicitly, at + least call OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER() at the right + places. That way, all platform-dependent code to make double-checked + locking work can be kept in one place. + + Usage scenarios: + + 1 Static instance (most common case) + + Pattern: + + T * getInstance() + { + static T * pInstance = 0; + if (!pInstance) + { + ::osl::MutexGuard aGuard(::osl::Mutex::getGlobalMutex()); + if (!pInstance) + { + static T aInstance; + pInstance = &aInstance; + } + } + return pInstance; + } + + Code: + + #include "rtl/instance.hxx" + #include "osl/getglobalmutex.hxx" + + namespace { + struct Init + { + T * operator()() + { + static T aInstance; + return &aInstance; + } + }; + } + + T * getInstance() + { + return rtl_Instance< T, Init, ::osl::MutexGuard, + ::osl::GetGlobalMutex >::create( + Init(), ::osl::GetGlobalMutex()); + } + + 2 Dynamic instance + + Pattern: + + T * getInstance() + { + static T * pInstance = 0; + if (!pInstance) + { + ::osl::MutexGuard aGuard(::osl::Mutex::getGlobalMutex()); + if (!pInstance) + pInstance = new T; + } + return pInstance; + } + + Code: + + #include "rtl/instance.hxx" + #include "osl/getglobalmutex.hxx" + + namespace { + struct Init + { + T * operator()() + { + return new T; + } + }; + } + + T * getInstance() + { + return rtl_Instance< T, Init, ::osl::MutexGuard, + ::osl::GetGlobalMutex >::create( + Init(), ::osl::GetGlobalMutex()); + } + + 3 Other guard/mutex + + Pattern: + + T * getInstance() + { + static T * pInstance = 0; + if (!pInstance) + { + SomeGuard aGuard(pSomeMutex); + if (!pInstance) + { + static T aInstance; + pInstance = &aInstance; + } + } + return pInstance; + } + + Code: + + #include "rtl/instance.hxx" + + namespace { + struct InitInstance + { + T * operator()() + { + static T aInstance; + return &aInstance; + } + }; + + struct InitGuard + { + SomeMutex * operator()() + { + return pSomeMutex; + } + }; + } + + T * getInstance() + { + return rtl_Instance< T, InitInstance, + SomeGuard, InitGuard >::create( + InitInstance(), InitMutex()); + } + + 4 Calculate extra data + + Pattern: + + T * getInstance() + { + static T * pInstance = 0; + if (!pInstance) + { + Data aData(...); + ::osl::MutexGuard aGuard(::osl::Mutex::getGlobalMutex()); + if (!pInstance) + { + static T aInstance(aData); + pInstance = &aInstance; + } + } + return pInstance; + } + + Code: + + #include "rtl/instance.hxx" + #include "osl/getglobalmutex.hxx" + + namespace { + struct InitInstance + { + T * operator()() + { + static T aInstance; + return &aInstance; + } + } + + struct InitData + { + Data const & operator()() + { + return ...; + } + } + } + + T * getInstance() + { + return rtl_Instance< T, InitInstance, + ::osl::Mutex, ::osl::GetGlobalMutex, + Data, InitData >::create( + InitInstance(), ::osl::GetGlobalMutex(), InitData()); + } + + Some comments: + + For any instantiation of rtl_Instance, at most one call to a create method + may occur in the program code: Each occurance of a create method within + the program code is supposed to return a fresh object instance on the + first call, and that same object instance on subsequent calls; but + independent occurances of create methods are supposed to return + independent object instances. Since there is a one-to-one correspondence + between object instances and instantiations of rtl_Instance, the + requirement should be clear. One measure to enforce the requirement is + that rtl_Instance lives in an unnamed namespace, so that instantiations of + rtl_Instance in different translation units will definitely be different + instantiations. A drawback of that measure is that the name of the class + needs a funny "hand coded" prefix "rtl_" instead of a proper namespace + prefix like "::rtl::". + + A known problem with this template is when two occurences of calls to + create methods with identical template arguments appear in one translation + unit. Those two places will share a single object instance. This can be + avoided by using different Init structs (see the above code samples) in + the two places. + + There is no need to make m_pInstance volatile, in order to avoid usage of + stale copies of m_pInstance: At the first check, a thread will see that + m_pInstance contains either 0 or a valid pointer. If it contains a valid + pointer, it cannot be stale, and that pointer is used. If it contains 0, + acquiring the mutex will ensure that the second check sees a non-stale + value in all cases. + + On some compilers, the create methods would not be inlined if they + contained any static variables, so m_pInstance is made a class member + instead (and the create methods are inlined). But on MSC, the definition + of the class member m_pInstance would cause compilation to fail with an + internal compiler error. Since MSC is able to inline methods containing + static variables, m_pInstance is moved into the methods there. Note that + this only works well because for any instantiation of rtl_Instance at most + one call to a create method should be present, anyway. + */ +template< typename Inst, typename InstCtor, + typename Guard, typename GuardCtor, + typename Data = int, typename DataCtor = int > +class rtl_Instance +{ +public: + static inline Inst * create(InstCtor aInstCtor, GuardCtor aGuardCtor) + { +#if defined _MSC_VER + static Inst * m_pInstance = 0; +#endif // _MSC_VER + Inst * p = m_pInstance; + if (!p) + { + Guard aGuard(aGuardCtor()); + p = m_pInstance; + if (!p) + { + p = aInstCtor(); + OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); + m_pInstance = p; + } + } + else + { + OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); + } + return p; + } + + static inline Inst * create(InstCtor aInstCtor, GuardCtor aGuardCtor, + DataCtor aDataCtor) + { +#if defined _MSC_VER + static Inst * m_pInstance = 0; +#endif // _MSC_VER + Inst * p = m_pInstance; + if (!p) + { + Data aData(aDataCtor()); + Guard aGuard(aGuardCtor()); + p = m_pInstance; + if (!p) + { + p = aInstCtor(aData); + OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); + m_pInstance = p; + } + } + else + { + OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); + } + return p; + } + +private: +#if !defined _MSC_VER + static Inst * m_pInstance; +#endif // _MSC_VER +}; + +#if !defined _MSC_VER +template< typename Inst, typename InstCtor, + typename Guard, typename GuardCtor, + typename Data, typename DataCtor > +Inst * +rtl_Instance< Inst, InstCtor, Guard, GuardCtor, Data, DataCtor >::m_pInstance += 0; +#endif // _MSC_VER + +} + +namespace rtl { + +/** Helper base class for a late-initialized (default-constructed) + static variable, implementing the double-checked locking pattern correctly. + + @derive + Derive from this class (common practice), e.g. + <pre> + struct MyStatic : public rtl::Static<MyType, MyStatic> {}; + ... + MyType & rStatic = MyStatic::get(); + ... + </pre> + + @tplparam T + variable's type + @tplparam Unique + Implementation trick to make the inner static holder unique, + using the outer class + (the one that derives from this base class) +*/ +template<typename T, typename Unique> +class Static { +public: + /** Gets the static. Mutual exclusion is performed using the + osl global mutex. + + @return + static variable + */ + static T & get() { + return *rtl_Instance< + T, StaticInstance, + ::osl::MutexGuard, ::osl::GetGlobalMutex >::create( + StaticInstance(), ::osl::GetGlobalMutex() ); + } +private: + struct StaticInstance { + T * operator () () { + static T instance; + return &instance; + } + }; +}; + +/** Helper class for a late-initialized static aggregate, e.g. an array, + implementing the double-checked locking pattern correctly. + + @tplparam T + aggregate's element type + @tplparam InitAggregate + initializer functor class +*/ +template<typename T, typename InitAggregate> +class StaticAggregate { +public: + /** Gets the static aggregate, late-initializing. + Mutual exclusion is performed using the osl global mutex. + + @return + aggregate + */ + static T * get() { + return rtl_Instance< + T, InitAggregate, + ::osl::MutexGuard, ::osl::GetGlobalMutex >::create( + InitAggregate(), ::osl::GetGlobalMutex() ); + } +}; + +/** Helper base class for a late-initialized static variable, + implementing the double-checked locking pattern correctly. + + @derive + Derive from this class (common practice), + providing an initializer functor class, e.g. + <pre> + struct MyStatic : public rtl::StaticWithInit<MyType, MyStatic> { + MyType operator () () { + ... + return MyType( ... ); + } + }; + ... + MyType & rStatic = MyStatic::get(); + ... + </pre> + + @tplparam T + variable's type + @tplparam InitData + initializer functor class + @tplparam Unique + Implementation trick to make the inner static holder unique, + using the outer class + (the one that derives from this base class). + Default is InitData (common practice). + @tplparam Data + Initializer functor's return type. + Default is T (common practice). +*/ +template<typename T, typename InitData, + typename Unique = InitData, typename Data = T> +class StaticWithInit { +public: + /** Gets the static. Mutual exclusion is performed using the + osl global mutex. + + @return + static variable + */ + static T & get() { + return *rtl_Instance< + T, StaticInstanceWithInit, + ::osl::MutexGuard, ::osl::GetGlobalMutex, + Data, InitData >::create( StaticInstanceWithInit(), + ::osl::GetGlobalMutex(), + InitData() ); + } +private: + struct StaticInstanceWithInit { + T * operator () ( Data d ) { + static T instance(d); + return &instance; + } + }; +}; + +} // namespace rtl + +#endif // INCLUDED_RTL_INSTANCE_HXX diff --git a/sal/inc/rtl/locale.h b/sal/inc/rtl/locale.h new file mode 100644 index 000000000000..f2b0016942a3 --- /dev/null +++ b/sal/inc/rtl/locale.h @@ -0,0 +1,140 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_LOCALE_H_ +#define _RTL_LOCALE_H_ + +#include <rtl/ustring.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef SAL_W32 +# pragma pack(push, 8) +#elif defined(SAL_OS2) +# pragma pack(push, 4) +#endif + +/** + The implementation structur of a locale. Do not create this structure + direct. Only use the functions rtl_locale_register and + rtl_locale_setDefault. The strings Language, Country and Variant + are constants, so it is not necessary to acquire and release them. + */ +typedef struct _rtl_Locale +{ + /** + Lowercase two-letter ISO 639-1 or three-letter ISO 639-3 code. + */ + rtl_uString * Language; + /** + uppercase two-letter ISO-3166 code. + */ + rtl_uString * Country; + /** + Lowercase vendor and browser specific code. + */ + rtl_uString * Variant; + /** + The merged hash value of the Language, Country and Variant strings. + */ + sal_Int32 HashCode; +} rtl_Locale; + +#if defined( SAL_W32) || defined(SAL_OS2) +#pragma pack(pop) +#endif + +/** + Register a locale from language, country and variant. + @param language lowercase two-letter ISO 639-1 or three-letter ISO 639-3 code. + @param country uppercase two-letter ISO-3166 code. May be null. + @param variant vendor and browser specific code. May be null. + */ +rtl_Locale * SAL_CALL rtl_locale_register( const sal_Unicode * language, const sal_Unicode * country, const sal_Unicode * variant ); + +/** + Common method of getting the current default Locale. + Used for the presentation: menus, dialogs, etc. + Generally set once when your applet or application is initialized, + then never reset. (If you do reset the default locale, you + probably want to reload your GUI, so that the change is reflected + in your interface.) + <p>More advanced programs will allow users to use different locales + for different fields, e.g. in a spreadsheet. + <BR>Note that the initial setting will match the host system. + */ +rtl_Locale * SAL_CALL rtl_locale_getDefault(); + +/** + Sets the default. + Normally set once at the beginning of applet or application, + then never reset. <code>setDefault</code> does not reset the host locale. + @param language lowercase two-letter ISO 639-1 or three-letter ISO 639-3 code. + @param country uppercase two-letter ISO-3166 code. + @param variant vendor and browser specific code. See class description. + */ +void SAL_CALL rtl_locale_setDefault( const sal_Unicode * language, const sal_Unicode * country, const sal_Unicode * variant ); + +/** + Getter for programmatic name of field, + a lowercased two-letter ISO 639-1 or three-letter ISO 639-3 code. + @see #getDisplayLanguage + */ +rtl_uString * SAL_CALL rtl_locale_getLanguage( rtl_Locale * This ); + +/** + Getter for programmatic name of field, + an uppercased two-letter ISO-3166 code. + @see #getDisplayCountry + */ +rtl_uString * SAL_CALL rtl_locale_getCountry( rtl_Locale * This ); + +/** + Getter for programmatic name of field. + @see #getDisplayVariant + */ +rtl_uString * SAL_CALL rtl_locale_getVariant( rtl_Locale * This ); + +/** + Returns the hash code of the locale This. + */ +sal_Int32 SAL_CALL rtl_locale_hashCode( rtl_Locale * This ); + +/** + Returns true if the locals are equal, otherwis false. + */ +sal_Int32 SAL_CALL rtl_locale_equals( rtl_Locale * This, rtl_Locale * obj ); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_LOCALE_H_ */ + + diff --git a/sal/inc/rtl/locale.hxx b/sal/inc/rtl/locale.hxx new file mode 100644 index 000000000000..7e6526c0e9bc --- /dev/null +++ b/sal/inc/rtl/locale.hxx @@ -0,0 +1,266 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_LOCALE_HXX_ +#define _RTL_LOCALE_HXX_ + +#include <rtl/locale.h> +#include <rtl/ustring.hxx> + +#ifdef __cplusplus + +namespace rtl +{ + +/** + A <code>OLocale</code> object represents a specific geographical, political, + or cultural region. An operation that requires a <code>OLocale</code> to perform + its task is called <em>locale-sensitive</em> and uses the <code>OLocale</code> + to tailor information for the user. For example, displaying a number + is a locale-sensitive operation--the number should be formatted + according to the customs/conventions of the user's native country, + region, or culture. + + <P> + You create a <code>OLocale</code> object using one of the two constructors in + this class: + <blockquote> + <pre> + OLocale(String language, String country) + OLocale(String language, String country, String variant) + </pre> + </blockquote> + The first argument to both constructors is a valid <STRONG>ISO + Language Code.</STRONG> These codes are the lower-case two-letter + codes as defined by ISO-639. + You can find a full list of these codes at a number of sites, such as: + <BR><a href ="http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt"> + <code>http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt</code></a> + + <P> + The second argument to both constructors is a valid <STRONG>ISO Country + Code.</STRONG> These codes are the upper-case two-letter codes + as defined by ISO-3166. + You can find a full list of these codes at a number of sites, such as: + <BR><a href="http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html"> + <code>http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html</code></a> + + <P> + The second constructor requires a third argument--the <STRONG>Variant.</STRONG> + The Variant codes are vendor and browser-specific. + For example, use WIN for Windows, MAC for Macintosh, and POSIX for POSIX. + Where there are two variants, separate them with an underscore, and + put the most important one first. For + example, a Traditional Spanish collation might be referenced, with + "ES", "ES", "Traditional_WIN". + + <P> + Because a <code>OLocale</code> object is just an identifier for a region, + no validity check is performed when you construct a <code>OLocale</code>. + If you want to see whether particular resources are available for the + <code>OLocale</code> you construct, you must query those resources. For + example, ask the <code>NumberFormat</code> for the locales it supports + using its <code>getAvailableLocales</code> method. + <BR><STRONG>Note:</STRONG> When you ask for a resource for a particular + locale, you get back the best available match, not necessarily + precisely what you asked for. For more information, look at + <a href="java.util.ResourceBundle.html"><code>ResourceBundle</code></a>. + + <P> + The <code>OLocale</code> class provides a number of convenient constants + that you can use to create <code>OLocale</code> objects for commonly used + locales. For example, the following creates a <code>OLocale</code> object + for the United States: + <blockquote> + <pre> + OLocale.US + </pre> + </blockquote> + + <P> + Once you've created a <code>OLocale</code> you can query it for information about + itself. Use <code>getCountry</code> to get the ISO Country Code and + <code>getLanguage</code> to get the ISO Language Code. You can + use <code>getDisplayCountry</code> to get the + name of the country suitable for displaying to the user. Similarly, + you can use <code>getDisplayLanguage</code> to get the name of + the language suitable for displaying to the user. Interestingly, + the <code>getDisplayXXX</code> methods are themselves locale-sensitive + and have two versions: one that uses the default locale and one + that uses the locale specified as an argument. + + <P> + The JDK provides a number of classes that perform locale-sensitive + operations. For example, the <code>NumberFormat</code> class formats + numbers, currency, or percentages in a locale-sensitive manner. Classes + such as <code>NumberFormat</code> have a number of convenience methods + for creating a default object of that type. For example, the + <code>NumberFormat</code> class provides these three convenience methods + for creating a default <code>NumberFormat</code> object: + <blockquote> + <pre> + NumberFormat.getInstance() + NumberFormat.getCurrencyInstance() + NumberFormat.getPercentInstance() + </pre> + </blockquote> + These methods have two variants; one with an explicit locale + and one without; the latter using the default locale. + <blockquote> + <pre> + NumberFormat.getInstance(myLocale) + NumberFormat.getCurrencyInstance(myLocale) + NumberFormat.getPercentInstance(myLocale) + </pre> + </blockquote> + A <code>OLocale</code> is the mechanism for identifying the kind of object + (<code>NumberFormat</code>) that you would like to get. The locale is + <STRONG>just</STRONG> a mechanism for identifying objects, + <STRONG>not</STRONG> a container for the objects themselves. + + <P> + Each class that performs locale-sensitive operations allows you + to get all the available objects of that type. You can sift + through these objects by language, country, or variant, + and use the display names to present a menu to the user. + For example, you can create a menu of all the collation objects + suitable for a given language. Such classes must implement these + three class methods: + <blockquote> + <pre> + public static OLocale[] getAvailableLocales() + public static String getDisplayName(OLocale objectLocale, + OLocale displayLocale) + public static final String getDisplayName(OLocale objectLocale) + // getDisplayName will throw MissingResourceException if the locale + // is not one of the available locales. + </pre> + </blockquote> + */ +class OLocale +{ +public: + OLocale( rtl_Locale * locale ) + : pData( locale ) {} + + OLocale( const OLocale & obj) + : pData(obj.pData) {} + + OLocale & operator = ( const OLocale & obj) + { + pData = obj.pData; + return *this; + } + + /** + Construct a locale from language, country, variant. + @param language lowercase two-letter ISO-639 code. + @param country uppercase two-letter ISO-3166 code. + @param variant vendor and browser specific code. See class description. + */ + static OLocale registerLocale( const OUString & language, const OUString & country, + const OUString & variant ) + { + return rtl_locale_register( language, country, variant ); + } + + /** + Construct a locale from language, country. + @param language lowercase two-letter ISO-639 code. + @param country uppercase two-letter ISO-3166 code. + */ + static OLocale registerLocale( const OUString & language, const OUString & country ) + { + return rtl_locale_register( language, country, NULL ); + } + + /** @deprecated + */ + static OLocale getDefault() { return rtl_locale_getDefault(); } + + /** @deprecated + */ + static void setDefault( const OUString & language, const OUString & country, + const OUString & variant ) + { rtl_locale_setDefault(language, country, variant); } + + /** + Getter for programmatic name of field, + an lowercased two-letter ISO-639 code. + */ + OUString getLanguage() const { return pData->Language; } + + /** + Getter for programmatic name of field, + an uppercased two-letter ISO-3166 code. + */ + OUString getCountry() const { return pData->Country; } + + /** + Getter for programmatic name of field. + */ + OUString getVariant() const { return pData->Variant; } + + + /** + Returns the hash code of the locale This. + */ + sal_Int32 hashCode() const { return pData->HashCode; } + + sal_Bool operator == (const OLocale & obj ) const + { + return pData == obj.pData; + } + + rtl_Locale * getData() const { return pData; } + +private: + /** + Must be the first member in this class. OUString access this member with + *(rtl_Locale **)&locale. + */ + rtl_Locale * pData; + + OLocale() + : pData(rtl_locale_getDefault()) {} +/* + OLocale( const OLocale & obj) + : pData(obj.pData) {} + + OLocale & operator = ( const OLocale & obj) + { pData = obj.pData; + return *this; + } +*/ +}; + +} + +#endif /* __cplusplus */ +#endif /* _RTL_LOCALE_HXX_ */ + + diff --git a/sal/inc/rtl/logfile.h b/sal/inc/rtl/logfile.h new file mode 100644 index 000000000000..dbb9e9c258cf --- /dev/null +++ b/sal/inc/rtl/logfile.h @@ -0,0 +1,134 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_LOGFILE_H_ +#define _RTL_LOGFILE_H_ + +#include <sal/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + + +/** This function allows to log arbitrary messages even in a product-environment. + + The logfile is created on first access and closed, when the sal-library gets unloaded. + The file is line buffered. A log file is not created if no log messages are + written. + + The first time, rtl_logfile_trace is called, it checks for the bootstrap variable + RTL_LOGFILE. If the variable is not empty, it creates a file with the name + $(RTL_LOGFILE)_$(PID).log, where $(PID) is the process id of the running process. + + @param pszformat A format string with fprintf-syntax + @param ... An arbitrary number of arguments for fprintf, matching the + format string. +*/ +void SAL_CALL rtl_logfile_trace( const sal_Char* pszFormat, ... ); + +/** Like rtl_logfile_trace, but prefixing every log entry with the current time + and thread ID. + + @param format + a format string with fprintf-like syntax + + @param ... + an arbitrary number of arguments for fprintf, matching the given format + string + + @since UDK 3.2.0 +*/ +void SAL_CALL rtl_logfile_longTrace(char const * format, ...); + +/** Return if a log file is written. + + @return true if a log file is written + + @since UDK 3.2.11 +*/ +sal_Bool SAL_CALL rtl_logfile_hasLogFile( void ); + +#ifdef __cplusplus +} +#endif + +#ifdef TIMELOG +#define RTL_LOGFILE_TRACE( string ) \ + rtl_logfile_longTrace( "| : %s\n", string ) +#define RTL_LOGFILE_TRACE1( frmt, arg1 ) \ + rtl_logfile_longTrace( "| : " ); \ + rtl_logfile_trace( frmt, arg1 ); \ + rtl_logfile_trace( "\n" ) + +#define RTL_LOGFILE_TRACE2( frmt, arg1 , arg2 ) \ + rtl_logfile_longTrace( "| : " ); \ + rtl_logfile_trace( frmt, arg1 , arg2 ); \ + rtl_logfile_trace( "\n" ) +#define RTL_LOGFILE_TRACE3( frmt, arg1 , arg2 , arg3 ) \ + rtl_logfile_longTrace( "| : " ); \ + rtl_logfile_trace( frmt, arg1 , arg2 , arg3 ); \ + rtl_logfile_trace( "\n" ) + +// Now the macros with project and author arguments. The strings +// are formatted in a way, so that the log file can be parsed by +// post processing scripts. +#define RTL_LOGFILE_TRACE_AUTHOR( project, author, string ) \ + rtl_logfile_longTrace( "| %s (%s) : %s\n", \ + project,\ + author,\ + string ) +#define RTL_LOGFILE_TRACE_AUTHOR1( project, author, frmt, arg1 ) \ + rtl_logfile_longTrace( "| %s (%s) : ", \ + project,\ + author );\ + rtl_logfile_trace( frmt, arg1 ); \ + rtl_logfile_trace( "\n" ) + +#define RTL_LOGFILE_TRACE_AUTHOR2( project, author, frmt, arg1 , arg2 ) \ + rtl_logfile_longTrace( "| %s (%s) : ", \ + project,\ + author ); \ + rtl_logfile_trace( frmt, arg1 , arg2 ); \ + rtl_logfile_trace( "\n" ) +#define RTL_LOGFILE_TRACE_AUTHOR3( project, author, frmt, arg1 , arg2 , arg3 ) \ + rtl_logfile_longTrace( "| %s (%s) : ", \ + project,\ + author ); \ + rtl_logfile_trace( frmt, arg1 , arg2 , arg3 ); \ + rtl_logfile_trace( "\n" ) +#else +#define RTL_LOGFILE_TRACE( string ) ((void)0) +#define RTL_LOGFILE_TRACE1( frmt, arg1 ) ((void)0) +#define RTL_LOGFILE_TRACE2( frmt, arg1 , arg2 ) ((void)0) +#define RTL_LOGFILE_TRACE3( frmt, arg1 , arg2 , arg3 ) ((void)0) + +#define RTL_LOGFILE_TRACE_AUTHOR( project, author, string ) ((void)0) +#define RTL_LOGFILE_TRACE_AUTHOR1( project, author, frmt, arg1 ) ((void)0) +#define RTL_LOGFILE_TRACE_AUTHOR2( project, author, frmt, arg1 , arg2 ) ((void)0) +#define RTL_LOGFILE_TRACE_AUTHOR3( project, author, frmt, arg1 , arg2 , arg3 ) ((void)0) +#endif // TIMELOG +#endif diff --git a/sal/inc/rtl/logfile.hxx b/sal/inc/rtl/logfile.hxx new file mode 100644 index 000000000000..685637d504b0 --- /dev/null +++ b/sal/inc/rtl/logfile.hxx @@ -0,0 +1,205 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_LOGFILE_HXX_ +#define _RTL_LOGFILE_HXX_ + +#include <rtl/logfile.h> +#include <rtl/string.hxx> + +namespace rtl +{ +/** +@descr The intended use for class Logfile is to write time stamp information + for profiling purposes. + + Profiling output should only be generated for a special product version of OpenOffice + which is compiled with a defined preprocessor symbol 'TIMELOG'. + Therefore we have provided a set of macros that uses the class Logfile only if + this symbol is defined. If the macros are not sufficient, i.e. you need more + then three arguments for a printf style message, then you have to insert an + #ifdef TIMELOG/#endif brace yourself. + + Additionally the environment variable RTL_LOGFILE has to be defined in order to generate + logging information. If the variable is not empty, it creates a file with the name + $(RTL_LOGFILE)_$(PID).log, where $(PID) is the process id of the running process. + It can be used as a run time switch for enabling or disabling the logging. + Note that this variable is evaluated only once at the first attempt to write a message. + + The class LogFile collects runtime data within its constructor and destructor. It can be + used for timing whole functions. + If you want to write timing data without context you can use the RTL_LOGFILE_TRACE-macros + which are defined inside <rtl/logfile.h>. + + The class LogFile should not be used directly, instead use the RTL_LOGFILE_CONTEXT/ + RTL_LOGFILE_TRACE-macros. + + Macro usage: + ------------ + RTL_LOGFILE_CONTEXT( instance, name ); + This macro creates an instance of class LogFile with the name "instance" and writes the current time, + thread id and "name" to the log file. + + Example: RTL_LOGFILE_CONTEXT( aLog, "Timing for foo-method" ); + + RTL_LOGFILE_CONTEXT_TRACE( instance, mesage ); + RTL_LOGFILE_CONTEXT_TRACEn( instance, frmt, arg1, .., arg3 ); + These macros can be used to log information in a "instance" context. The "instance" object + is used to log message informations. All macros with "frmt" uses printf notation to log timing infos. + + Example: RTL_LOGFILE_CONTEXT_TRACE( aLog, "Now we call an expensive function" ); + RTL_LOGFIlE_CONTEXT_TRACE1( aLog, "Config entries read: %u", (unsigned short)i ); + + RTL_LOGFILE_TRACE( string ); + RTL_LOGFILE_TRACEn( frmt, arg1, .., arg3 ); + These macros can be used to log information outside a context. The macro directly calls + rtl_logfile_trace to write the info to the log file. All macros with "frmt" uses printf + notation to log timing infos. + + Example: RTL_LOGFILE_TRACE( "Timing for loading a file" ); + RTL_LOGFILE_TRACE1( aLog, "Timing for loading file: %s", aFileName ); + + The lines written to the log file consist of the following space separated elements: + 1. The time relative to the start of the global timer in milliseconds. The times is + started typically for the first logged line. + 2. Thread id. It's absolut value is probably of less interest than providing a way to + distinguish different threads. + 3. a. An opening or closing curly brace indicating the start or end of a scope. + 4a. Function name or general scope identifier. + b. A vertical line indicating an arbitrary message. + 4b optional function name or general scope identifier. + 5b A colon followed by a space and a free form message terminated by a newline. + + There is a second version of creating a context. RTL_LOGFILE_CONTEXT_AUTHOR takes + two more arguments, the name of the project and the author's sign who is responsible + for the code in which the macro is used. +*/ + class Logfile + { + public: + inline Logfile( const sal_Char *name ); + /** @descr Create a log file context where the message field consists of a project + name, the author's shortcut, and the actual message. These three strings + are written in a format that is understood by script that later parses the + log file and that so can extract the three strings. + @param project Short name of the project, like sw for writer or sc for calc. + @param author The sign of the person responsible for the code. + @param name The actual message, typically a method name. + */ + inline Logfile( const sal_Char *project, const sal_Char *author, const sal_Char *name ); + inline ~Logfile(); + inline const sal_Char *getName(); + private: + ::rtl::OString m_sName; + }; + + inline Logfile::Logfile( const sal_Char *name ) + : m_sName( name ) + { + rtl_logfile_longTrace( "{ %s\n", name ); + } + + inline Logfile::Logfile( const sal_Char *project, const sal_Char *author, const sal_Char *name ) + : m_sName( project) + { + m_sName += " ("; + m_sName += author; + m_sName += ") "; + m_sName += name; + rtl_logfile_longTrace( "{ %s\n", m_sName.pData->buffer ); + } + + inline Logfile::~Logfile() + { + rtl_logfile_longTrace( "} %s\n", m_sName.pData->buffer ); + } + + inline const sal_Char * Logfile::getName() + { + return m_sName.getStr(); + } +} + +#ifdef TIMELOG +#define RTL_LOGFILE_CONTEXT( instance, name ) ::rtl::Logfile instance( name ) +#define RTL_LOGFILE_CONTEXT_AUTHOR( instance, project, author, name ) ::rtl::Logfile instance(project, author, name ) +#define RTL_LOGFILE_CONTEXT_TRACE( instance, message ) \ + rtl_logfile_longTrace( "| %s : %s\n", \ + instance.getName(), \ + message ) +#define RTL_LOGFILE_CONTEXT_TRACE1( instance , frmt, arg1 ) \ + rtl_logfile_longTrace( "| %s : ", \ + instance.getName() ); \ + rtl_logfile_trace( frmt , arg1 ); \ + rtl_logfile_trace( "\n" ) +#define RTL_LOGFILE_CONTEXT_TRACE2( instance , frmt, arg1 , arg2 ) \ + rtl_logfile_longTrace( "| %s : ", \ + instance.getName() ); \ + rtl_logfile_trace( frmt , arg1 , arg2 ); \ + rtl_logfile_trace( "\n" ) +#define RTL_LOGFILE_CONTEXT_TRACE3( instance , frmt, arg1 , arg2 , arg3 ) \ + rtl_logfile_longTrace( "| %s : ", \ + instance.getName() ); \ + rtl_logfile_trace( frmt , arg1 , arg2 , arg3 ); \ + rtl_logfile_trace( "\n" ) + +#else +#define RTL_LOGFILE_CONTEXT( instance, name ) ((void)0) +#define RTL_LOGFILE_CONTEXT_AUTHOR( instance, project, author, name ) ((void)0) +#define RTL_LOGFILE_CONTEXT_TRACE( instance, message ) ((void)0) +#define RTL_LOGFILE_CONTEXT_TRACE1( instance, frmt, arg1 ) ((void)0) +#define RTL_LOGFILE_CONTEXT_TRACE2( instance, frmt, arg1, arg2 ) ((void)0) +#define RTL_LOGFILE_CONTEXT_TRACE3( instance, frmt, arg1, arg2 , arg3 ) ((void)0) +#endif + +// Normal RTL_LOGFILE_* entries will not make it into release versions, +// TIMELOG is disabled a few versions prior relase build. +// +// We need some logs also in these builds, eg. for making performance regression tests. +// +// POLICY: Don't use RTL_LOGFILE_PRODUCT_* for your personal logging information. +// Be aware that these logs make it into the product shipped to customers. +// If you have good reasons for doing this, please contact product management. + +#define RTL_LOGFILE_PRODUCT_TRACE( string ) \ + rtl_logfile_longTrace( "| : %s\n", string ) +#define RTL_LOGFILE_PRODUCT_TRACE1( frmt, arg1 ) \ + rtl_logfile_longTrace( "| : " ); \ + rtl_logfile_trace( frmt, arg1 ); \ + rtl_logfile_trace( "\n" ) +#define RTL_LOGFILE_PRODUCT_CONTEXT( instance, name ) \ + ::rtl::Logfile instance( name ) +#define RTL_LOGFILE_PRODUCT_CONTEXT_TRACE1( instance, frmt, arg1 ) \ + rtl_logfile_longTrace( "| %s : ", \ + instance.getName() ); \ + rtl_logfile_trace( frmt, arg1 ); \ + rtl_logfile_trace( "\n" ) +#define RTL_LOGFILE_HASLOGFILE() \ + rtl_logfile_hasLogFile() + + +#endif + diff --git a/sal/inc/rtl/malformeduriexception.hxx b/sal/inc/rtl/malformeduriexception.hxx new file mode 100644 index 000000000000..731d762e23cb --- /dev/null +++ b/sal/inc/rtl/malformeduriexception.hxx @@ -0,0 +1,74 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_RTL_MALFORMEDURIEXCEPTION_HXX +#define INCLUDED_RTL_MALFORMEDURIEXCEPTION_HXX + +#include "rtl/ustring.hxx" + +namespace rtl { + +/** An exception indicating a malformed URI. + + <P>Used when parsing (part of) a URI fails for syntactical reasons.</P> + */ +class SAL_EXCEPTION_DLLPUBLIC_EXPORT MalformedUriException +{ +public: + /** Create a MalformedUriException. + + @param rMessage + A message containing any details about the exception. + */ + inline SAL_EXCEPTION_DLLPRIVATE MalformedUriException( + rtl::OUString const & rMessage): m_aMessage(rMessage) {} + + inline SAL_EXCEPTION_DLLPRIVATE MalformedUriException( + MalformedUriException const & other): m_aMessage(other.m_aMessage) {} + + inline SAL_EXCEPTION_DLLPRIVATE ~MalformedUriException() {} + + inline SAL_EXCEPTION_DLLPRIVATE MalformedUriException operator =( + MalformedUriException const & rOther) + { m_aMessage = rOther.m_aMessage; return *this; } + + /** Get the message. + + @return + A reference to the message. The reference is valid for the lifetime of + this MalformedUriException. + */ + inline SAL_EXCEPTION_DLLPRIVATE rtl::OUString const & getMessage() const + { return m_aMessage; } + +private: + rtl::OUString m_aMessage; +}; + +} + +#endif // INCLUDED_RTL_MALFORMEDURIEXCEPTION_HXX diff --git a/sal/inc/rtl/math.h b/sal/inc/rtl/math.h new file mode 100644 index 000000000000..fa81108df29f --- /dev/null +++ b/sal/inc/rtl/math.h @@ -0,0 +1,478 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#if !defined INCLUDED_RTL_MATH_H +#define INCLUDED_RTL_MATH_H + +#include "rtl/ustring.h" +#include "sal/types.h" + +#if defined __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** Formatting modes for rtl_math_doubleToString and rtl_math_doubleToUString + and rtl_math_doubleToUStringBuffer. + */ +enum rtl_math_StringFormat +{ + /** Like sprintf() %E. + */ + rtl_math_StringFormat_E, + + /** Like sprintf() %f. + */ + rtl_math_StringFormat_F, + + /** Like sprintf() %G, 'F' or 'E' format is used depending on which one is + more compact. + */ + rtl_math_StringFormat_G, + + /** Automatic, 'F' or 'E' format is used depending on the numeric value to + be formatted. + */ + rtl_math_StringFormat_Automatic, + + /** @internal + */ + rtl_math_StringFormat_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Status for rtl_math_stringToDouble and rtl_math_uStringToDouble. + */ +enum rtl_math_ConversionStatus +{ + /** Conversion was successful. + */ + rtl_math_ConversionStatus_Ok, + + /** Conversion caused overflow or underflow. + */ + rtl_math_ConversionStatus_OutOfRange, + + /** @internal + */ + rtl_math_ConversionStatus_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Rounding modes for rtl_math_round. + */ +enum rtl_math_RoundingMode +{ + /** Like HalfUp, but corrects roundoff errors, preferred. + */ + rtl_math_RoundingMode_Corrected, + + /** Floor of absolute value, signed return (commercial). + */ + rtl_math_RoundingMode_Down, + + /** Ceil of absolute value, signed return (commercial). + */ + rtl_math_RoundingMode_Up, + + /** Floor of signed value. + */ + rtl_math_RoundingMode_Floor, + + /** Ceil of signed value. + */ + rtl_math_RoundingMode_Ceiling, + + /** Frac <= 0.5 ? floor of abs : ceil of abs, signed return. + */ + rtl_math_RoundingMode_HalfDown, + + /** Frac < 0.5 ? floor of abs : ceil of abs, signed return (mathematical). + */ + rtl_math_RoundingMode_HalfUp, + + /** IEEE rounding mode (statistical). + */ + rtl_math_RoundingMode_HalfEven, + + /** @internal + */ + rtl_math_RoundingMode_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Special decimal places constants for rtl_math_doubleToString and + rtl_math_doubleToUString and rtl_math_doubleToUStringBuffer. + */ +enum rtl_math_DecimalPlaces +{ + /** Value to be used with rtl_math_StringFormat_Automatic. + */ + rtl_math_DecimalPlaces_Max = 0x7ffffff, + + /** Value to be used with rtl_math_StringFormat_G. + In fact the same value as rtl_math_DecimalPlaces_Max, just an alias for + better understanding. + */ + rtl_math_DecimalPlaces_DefaultSignificance = 0x7ffffff +}; + + +/** Conversions analogous to sprintf() using internal rounding. + + +/-HUGE_VAL are converted to "INF" and "-INF", NAN values are + converted to "NaN". + + @param pResult + Returns the resulting byte string. Must itself not be null, and must point + to either null or a valid string. + + @param pResultCapacity + If null, pResult is considered to point to immutable strings, and a new + string will be allocated in pResult. + If non-null, it points to the current capacity of pResult, which is + considered to point to a string buffer (pResult must not itself be null in + this case, and must point to a string that has room for the given capacity). + The string representation of the given double value is inserted into pResult + at position nResultOffset. If pResult's current capacity is too small, a + new string buffer will be allocated in pResult as necessary, and + pResultCapacity will contain the new capacity on return. + + @param nResultOffset + If pResult is used as a string buffer (i.e., pResultCapacity is non-null), + nResultOffset specifies the insertion offset within the buffer. Ignored + otherwise. + + @param fValue + The value to convert. + + @param eFormat + The format to use, one of rtl_math_StringFormat. + + @param nDecPlaces + The number of decimals to be generated. Effectively fValue is rounded at + this position, specifying nDecPlaces <= 0 accordingly rounds the value + before the decimal point and fills with zeros. + If eFormat == rtl_math_StringFormat_Automatic and nDecPlaces == + rtl_math_DecimalPlaces_Max, the highest number of significant decimals + possible is generated. + If eFormat == rtl_math_StringFormat_G, nDecPlaces specifies the number of + significant digits instead. If nDecPlaces == + rtl_math_DecimalPlaces_DefaultSignificance, the default number (currently 6 + as implemented by most libraries) of significant digits is generated. + According to the ANSI C90 standard the E style will be used only if the + exponent resulting from the conversion is less than -4 or greater than or + equal to the precision. However, as opposed to the ANSI standard, trailing + zeros are not necessarily removed from the fractional portion of the result + unless bEraseTrailingDecZeros == true was specified. + + @param cDecSeparator + The decimal separator. + + @param pGroups + Either null (no grouping is used), or a null-terminated list of group + lengths. Each group length must be strictly positive. If the number of + digits in a conversion exceeds the specified range, the last (highest) group + length is repeated as needed. Values are applied from right to left, for a + grouping of 1,00,00,000 you'd have to specify pGroups={3,2,0}. + + @param cGroupSeparator + The group separator. Ignored if pGroups is null. + + @param bEraseTrailingDecZeros + Trailing zeros in decimal places are erased. + */ +void SAL_CALL rtl_math_doubleToString(rtl_String ** pResult, + sal_Int32 * pResultCapacity, + sal_Int32 nResultOffset, double fValue, + enum rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Char cDecSeparator, + sal_Int32 const * pGroups, + sal_Char cGroupSeparator, + sal_Bool bEraseTrailingDecZeros) + SAL_THROW_EXTERN_C(); + +/** Conversions analogous to sprintf() using internal rounding. + + +/-HUGE_VAL are converted to "INF" and "-INF", NAN values are + converted to "NaN". + + @param pResult + Returns the resulting Unicode string. Must itself not be null, and must + point to either null or a valid string. + + @param pResultCapacity + If null, pResult is considered to point to immutable strings, and a new + string will be allocated in pResult. + If non-null, it points to the current capacity of pResult, which is + considered to point to a string buffer (pResult must not itself be null in + this case, and must point to a string that has room for the given capacity). + The string representation of the given double value is inserted into pResult + at position nResultOffset. If pResult's current capacity is too small, a + new string buffer will be allocated in pResult as necessary, and + pResultCapacity will contain the new capacity on return. + + @param nResultOffset + If pResult is used as a string buffer (i.e., pResultCapacity is non-null), + nResultOffset specifies the insertion offset within the buffer. Ignored + otherwise. + + @param fValue + The value to convert. + + @param eFormat + The format to use, one of rtl_math_StringFormat. + + @param nDecPlaces + The number of decimals to be generated. Effectively fValue is rounded at + this position, specifying nDecPlaces <= 0 accordingly rounds the value + before the decimal point and fills with zeros. + If eFormat == rtl_math_StringFormat_Automatic and nDecPlaces == + rtl_math_DecimalPlaces_Max, the highest number of significant decimals + possible is generated. + If eFormat == rtl_math_StringFormat_G, nDecPlaces specifies the number of + significant digits instead. If nDecPlaces == + rtl_math_DecimalPlaces_DefaultSignificance, the default number (currently 6 + as implemented by most libraries) of significant digits is generated. + According to the ANSI C90 standard the E style will be used only if the + exponent resulting from the conversion is less than -4 or greater than or + equal to the precision. However, as opposed to the ANSI standard, trailing + zeros are not necessarily removed from the fractional portion of the result + unless bEraseTrailingDecZeros == true was specified. + + @param cDecSeparator + The decimal separator. + + @param pGroups + Either null (no grouping is used), or a null-terminated list of group + lengths. Each group length must be strictly positive. If the number of + digits in a conversion exceeds the specified range, the last (highest) group + length is repeated as needed. Values are applied from right to left, for a + grouping of 1,00,00,000 you'd have to specify pGroups={3,2,0}. + + @param cGroupSeparator + The group separator. Ignored if pGroups is null. + + @param bEraseTrailingDecZeros + Trailing zeros in decimal places are erased. + */ +void SAL_CALL rtl_math_doubleToUString(rtl_uString ** pResult, + sal_Int32 * pResultCapacity, + sal_Int32 nResultOffset, double fValue, + enum rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Unicode cDecSeparator, + sal_Int32 const * pGroups, + sal_Unicode cGroupSeparator, + sal_Bool bEraseTrailingDecZeros) + SAL_THROW_EXTERN_C(); + +/** Conversion analogous to strtod(), convert a string representing a + decimal number into a double value. + + Leading tabs (0x09) and spaces (0x20) are eaten. Overflow returns + +/-HUGE_VAL, underflow 0. In both cases pStatus is set to + rtl_math_ConversionStatus_OutOfRange, otherwise to + rtl_math_ConversionStatus_Ok. "INF", "-INF" and "+/-1.#INF" are + recognized as +/-HUGE_VAL, pStatus is set to + rtl_math_ConversionStatus_OutOfRange. "NaN" and "+/-1.#NAN" are + recognized and the value is set to +/-NAN, pStatus is set to + rtl_math_ConversionStatus_Ok. + + @param pBegin + Points to the start of the byte string to convert. Must not be null. + + @param pEnd + Points one past the end of the byte string to convert. The condition + pEnd >= pBegin must hold. + + @param cDecSeparator + The decimal separator. + + @param cGroupSeparator + The group (aka thousands) separator. + + @param pStatus + If non-null, returns the status of the conversion. + + @param pParsedEnd + If non-null, returns one past the position of the last character parsed + away. Thus if [pBegin..pEnd) only contains the numerical string to be + parsed, *pParsedEnd == pEnd on return. If no numerical (sub-)string is + found, *pParsedEnd == pBegin on return, even if there was leading + whitespace. + */ +double SAL_CALL rtl_math_stringToDouble( + sal_Char const * pBegin, sal_Char const * pEnd, sal_Char cDecSeparator, + sal_Char cGroupSeparator, enum rtl_math_ConversionStatus * pStatus, + sal_Char const ** pParsedEnd) SAL_THROW_EXTERN_C(); + +/** Conversion analogous to strtod(), convert a string representing a + decimal number into a double value. + + Leading tabs (U+0009) and spaces (U+0020) are eaten. Overflow returns + +/-HUGE_VAL, underflow 0. In both cases pStatus is set to + rtl_math_ConversionStatus_OutOfRange, otherwise to + rtl_math_ConversionStatus_Ok. "INF", "-INF" and "+/-1.#INF" are + recognized as +/-HUGE_VAL, pStatus is set to + rtl_math_ConversionStatus_OutOfRange. "NaN" and "+/-1.#NAN" are + recognized and the value is set to +/-NAN, pStatus is set to + rtl_math_ConversionStatus_Ok. + + @param pBegin + Points to the start of the Unicode string to convert. Must not be null. + + @param pEnd + Points one past the end of the Unicode string to convert. The condition + pEnd >= pBegin must hold. + + @param cDecSeparator + The decimal separator. + + @param cGroupSeparator + The group (aka thousands) separator. + + @param pStatus + If non-null, returns the status of the conversion. + + @param pParsedEnd + If non-null, returns one past the position of the last character parsed + away. Thus if [pBegin..pEnd) only contains the numerical string to be + parsed, *pParsedEnd == pEnd on return. If no numerical (sub-)string is + found, *pParsedEnd == pBegin on return, even if there was leading + whitespace. + */ +double SAL_CALL rtl_math_uStringToDouble( + sal_Unicode const * pBegin, sal_Unicode const * pEnd, + sal_Unicode cDecSeparator, sal_Unicode cGroupSeparator, + enum rtl_math_ConversionStatus * pStatus, sal_Unicode const ** pParsedEnd) + SAL_THROW_EXTERN_C(); + +/** Rounds a double value. + + @param fValue + Specifies the value to be rounded. + + @param nDecPlaces + Specifies the decimal place where rounding occurs. Must be in the range + -20 to +20, inclusive. Negative if rounding occurs before the decimal + point. + + @param eMode + Specifies the rounding mode. + */ +double SAL_CALL rtl_math_round(double fValue, int nDecPlaces, + enum rtl_math_RoundingMode eMode) + SAL_THROW_EXTERN_C(); + +/** Scales fVal to a power of 10 without calling pow() or div() for nExp values + between -16 and +16, providing a faster method. + + @param fValue + The value to be raised. + + @param nExp + The exponent. + + @return + fVal * pow(10.0, nExp) + */ +double SAL_CALL rtl_math_pow10Exp(double fValue, int nExp) SAL_THROW_EXTERN_C(); + +/** Rounds value to 15 significant decimal digits. + + @param fValue + The value to be rounded. + */ +double SAL_CALL rtl_math_approxValue(double fValue) SAL_THROW_EXTERN_C(); + +/** Returns more accurate e^x-1 for x near 0 than calculating directly. + + expm1 is part of the C99 standard, but not provided by some compilers. + + @param fValue + The value x in the term e^x-1. + */ +double SAL_CALL rtl_math_expm1(double fValue) SAL_THROW_EXTERN_C(); + +/** Returns more accurate log(1+x) for x near 0 than calculating directly. + + log1p is part of the C99 standard, but not provided by some compilers. + + @param fValue + The value x in the term log(1+x). + */ +double SAL_CALL rtl_math_log1p(double fValue) SAL_THROW_EXTERN_C(); + +/** Returns more accurate atanh(x) for x near 0 than calculating + 0.5*log((1+x)/(1-x)). + + atanh is part of the C99 standard, but not provided by some compilers. + + @param fValue + The value x in the term atanh(x). + */ +double SAL_CALL rtl_math_atanh(double fValue) SAL_THROW_EXTERN_C(); + +/** Returns values of the Errorfunction erf. + + erf is part of the C99 standard, but not provided by some compilers. + + @param fValue + The value x in the term erf(x). + */ +double SAL_CALL rtl_math_erf(double fValue) SAL_THROW_EXTERN_C(); + +/** Returns values of the complement Errorfunction erfc. + + erfc is part of the C99 standard, but not provided by some compilers. + + @param fValue + The value x in the term erfc(x). + */ +double SAL_CALL rtl_math_erfc(double fValue) SAL_THROW_EXTERN_C(); + +/** Returns values of the inverse hyperbolic sine. + + asinh is part of the C99 standard, but not provided by some compilers. + + @param fValue + The value x in the term asinh(x). + */ +double SAL_CALL rtl_math_asinh(double fValue) SAL_THROW_EXTERN_C(); + +/** Returns values of the inverse hyperbolic cosine. + + acosh is part of the C99 standard, but not provided by some compilers. + + @param fValue + The value x in the term acosh(x). + */ +double SAL_CALL rtl_math_acosh(double fValue) SAL_THROW_EXTERN_C(); + +#if defined __cplusplus +} +#endif /* __cplusplus */ + +#endif /* INCLUDED_RTL_MATH_H */ diff --git a/sal/inc/rtl/math.hxx b/sal/inc/rtl/math.hxx new file mode 100644 index 000000000000..31308b561185 --- /dev/null +++ b/sal/inc/rtl/math.hxx @@ -0,0 +1,432 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#if !defined INCLUDED_RTL_MATH_HXX +#define INCLUDED_RTL_MATH_HXX + +#include "rtl/math.h" +#include "rtl/string.hxx" +#include "rtl/ustring.hxx" +#include "rtl/ustrbuf.hxx" +#include "sal/mathconf.h" +#include "sal/types.h" + +#include <math.h> + +namespace rtl { + +namespace math { + +/** A wrapper around rtl_math_doubleToString. + */ +inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Char cDecSeparator, + sal_Int32 const * pGroups, + sal_Char cGroupSeparator, + bool bEraseTrailingDecZeros = false) +{ + rtl::OString aResult; + rtl_math_doubleToString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces, + cDecSeparator, pGroups, cGroupSeparator, + bEraseTrailingDecZeros); + return aResult; +} + +/** A wrapper around rtl_math_doubleToString, with no grouping. + */ +inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Char cDecSeparator, + bool bEraseTrailingDecZeros = false) +{ + rtl::OString aResult; + rtl_math_doubleToString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces, + cDecSeparator, 0, 0, bEraseTrailingDecZeros); + return aResult; +} + +/** A wrapper around rtl_math_doubleToUString. + */ +inline rtl::OUString doubleToUString(double fValue, + rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Unicode cDecSeparator, + sal_Int32 const * pGroups, + sal_Unicode cGroupSeparator, + bool bEraseTrailingDecZeros = false) +{ + rtl::OUString aResult; + rtl_math_doubleToUString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces, + cDecSeparator, pGroups, cGroupSeparator, + bEraseTrailingDecZeros); + return aResult; +} + +/** A wrapper around rtl_math_doubleToUString, with no grouping. + */ +inline rtl::OUString doubleToUString(double fValue, + rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Unicode cDecSeparator, + bool bEraseTrailingDecZeros = false) +{ + rtl::OUString aResult; + rtl_math_doubleToUString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces, + cDecSeparator, 0, 0, bEraseTrailingDecZeros); + return aResult; +} + +/** A wrapper around rtl_math_doubleToUString that appends to an + rtl::OUStringBuffer. + */ +inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue, + rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Unicode cDecSeparator, + sal_Int32 const * pGroups, + sal_Unicode cGroupSeparator, + bool bEraseTrailingDecZeros = false) +{ + rtl_uString ** pData; + sal_Int32 * pCapacity; + rBuffer.accessInternals( &pData, &pCapacity ); + rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue, + eFormat, nDecPlaces, cDecSeparator, pGroups, + cGroupSeparator, bEraseTrailingDecZeros); +} + +/** A wrapper around rtl_math_doubleToUString that appends to an + rtl::OUStringBuffer, with no grouping. + */ +inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue, + rtl_math_StringFormat eFormat, + sal_Int32 nDecPlaces, + sal_Unicode cDecSeparator, + bool bEraseTrailingDecZeros = false) +{ + rtl_uString ** pData; + sal_Int32 * pCapacity; + rBuffer.accessInternals( &pData, &pCapacity ); + rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue, + eFormat, nDecPlaces, cDecSeparator, 0, 0, + bEraseTrailingDecZeros); +} + +/** A wrapper around rtl_math_stringToDouble. + */ +inline double stringToDouble(rtl::OString const & rString, + sal_Char cDecSeparator, sal_Char cGroupSeparator, + rtl_math_ConversionStatus * pStatus, + sal_Int32 * pParsedEnd) +{ + sal_Char const * pBegin = rString.getStr(); + sal_Char const * pEnd; + double fResult = rtl_math_stringToDouble(pBegin, + pBegin + rString.getLength(), + cDecSeparator, cGroupSeparator, + pStatus, &pEnd); + if (pParsedEnd != 0) + *pParsedEnd = (sal_Int32)(pEnd - pBegin); + return fResult; +} + +/** A wrapper around rtl_math_uStringToDouble. + */ +inline double stringToDouble(rtl::OUString const & rString, + sal_Unicode cDecSeparator, + sal_Unicode cGroupSeparator, + rtl_math_ConversionStatus * pStatus, + sal_Int32 * pParsedEnd) +{ + sal_Unicode const * pBegin = rString.getStr(); + sal_Unicode const * pEnd; + double fResult = rtl_math_uStringToDouble(pBegin, + pBegin + rString.getLength(), + cDecSeparator, cGroupSeparator, + pStatus, &pEnd); + if (pParsedEnd != 0) + *pParsedEnd = (sal_Int32)(pEnd - pBegin); + return fResult; +} + +/** A wrapper around rtl_math_round. + */ +inline double round( + double fValue, int nDecPlaces = 0, + rtl_math_RoundingMode eMode = rtl_math_RoundingMode_Corrected) +{ + return rtl_math_round(fValue, nDecPlaces, eMode); +} + +/** A wrapper around rtl_math_pow10Exp. + */ +inline double pow10Exp(double fValue, int nExp) +{ + return rtl_math_pow10Exp(fValue, nExp); +} + +/** A wrapper around rtl_math_approxValue. + */ +inline double approxValue(double fValue) +{ + return rtl_math_approxValue(fValue); +} + +/** A wrapper around rtl_math_expm1. + */ +inline double expm1(double fValue) +{ + return rtl_math_expm1(fValue); +} + +/** A wrapper around rtl_math_log1p. + */ +inline double log1p(double fValue) +{ + return rtl_math_log1p(fValue); +} + +/** A wrapper around rtl_math_atanh. + */ +inline double atanh(double fValue) +{ + return rtl_math_atanh(fValue); +} + +/** A wrapper around rtl_math_erf. + */ +inline double erf(double fValue) +{ + return rtl_math_erf(fValue); +} + +/** A wrapper around rtl_math_erfc. + */ +inline double erfc(double fValue) +{ + return rtl_math_erfc(fValue); +} + +/** A wrapper around rtl_math_asinh. + */ +inline double asinh(double fValue) +{ + return rtl_math_asinh(fValue); +} + +/** A wrapper around rtl_math_acosh. + */ +inline double acosh(double fValue) +{ + return rtl_math_acosh(fValue); +} + + +/** Test equality of two values with an accuracy of the magnitude of the + given values scaled by 2^-48 (4 bits roundoff stripped). + + @ATTENTION + approxEqual( value!=0.0, 0.0 ) _never_ yields true. + */ +inline bool approxEqual(double a, double b) +{ + if ( a == b ) + return true; + double x = a - b; + return (x < 0.0 ? -x : x) + < ((a < 0.0 ? -a : a) * (1.0 / (16777216.0 * 16777216.0))); +} + +/** Add two values. + + If signs differ and the absolute values are equal according to approxEqual() + the method returns 0.0 instead of calculating the sum. + + If you wanted to sum up multiple values it would be convenient not to call + approxAdd() for each value but instead remember the first value not equal to + 0.0, add all other values using normal + operator, and with the result and + the remembered value call approxAdd(). + */ +inline double approxAdd(double a, double b) +{ + if ( ((a < 0.0 && b > 0.0) || (b < 0.0 && a > 0.0)) + && approxEqual( a, -b ) ) + return 0.0; + return a + b; +} + +/** Substract two values (a-b). + + If signs are identical and the values are equal according to approxEqual() + the method returns 0.0 instead of calculating the substraction. + */ +inline double approxSub(double a, double b) +{ + if ( ((a < 0.0 && b < 0.0) || (a > 0.0 && b > 0.0)) && approxEqual( a, b ) ) + return 0.0; + return a - b; +} + +/** floor() method taking approxValue() into account. + + Use for expected integer values being calculated by double functions. + */ +inline double approxFloor(double a) +{ + return floor( approxValue( a )); +} + +/** ceil() method taking approxValue() into account. + + Use for expected integer values being calculated by double functions. + */ +inline double approxCeil(double a) +{ + return ceil( approxValue( a )); +} + +/** Tests whether a value is neither INF nor NAN. + */ +inline bool isFinite(double d) +{ + return SAL_MATH_FINITE(d) != 0; +} + +/** If a value represents +INF or -INF. + + The sign bit may be queried with isSignBitSet(). + + If isFinite(d)==false and isInf(d)==false then NAN. + */ +inline bool isInf(double d) +{ + // exponent==0x7ff fraction==0 + return (SAL_MATH_FINITE(d) == 0) && + (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi == 0) + && (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo + == 0); +} + +/** Test on any QNAN or SNAN. + */ +inline bool isNan(double d) +{ + // exponent==0x7ff fraction!=0 + return (SAL_MATH_FINITE(d) == 0) && ( + (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi != 0) + || (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo + != 0) ); +} + +/** If the sign bit is set. + */ +inline bool isSignBitSet(double d) +{ + return reinterpret_cast< sal_math_Double * >(&d)->inf_parts.sign != 0; +} + +/** Set to +INF if bNegative==false or -INF if bNegative==true. + */ +inline void setInf(double * pd, bool bNegative) +{ + union + { + double sd; + sal_math_Double md; + }; + md.w32_parts.msw = bNegative ? 0xFFF00000 : 0x7FF00000; + md.w32_parts.lsw = 0; + *pd = sd; +} + +/** Set a QNAN. + */ +inline void setNan(double * pd) +{ + union + { + double sd; + sal_math_Double md; + }; + md.w32_parts.msw = 0x7FFFFFFF; + md.w32_parts.lsw = 0xFFFFFFFF; + *pd = sd; +} + +/** If a value is a valid argument for sin(), cos(), tan(). + + IEEE 754 specifies that absolute values up to 2^64 (=1.844e19) for the + radian must be supported by trigonometric functions. Unfortunately, at + least on x86 architectures, the FPU doesn't generate an error pattern for + values >2^64 but produces erroneous results instead and sets only the + "invalid operation" (IM) flag in the status word :-( Thus the application + has to handle it itself. + */ +inline bool isValidArcArg(double d) +{ + return fabs(d) + <= (static_cast< double >(static_cast< unsigned long >(0x80000000)) + * static_cast< double >(static_cast< unsigned long >(0x80000000)) + * 2); +} + +/** Safe sin(), returns NAN if not valid. + */ +inline double sin(double d) +{ + if ( isValidArcArg( d ) ) + return ::sin( d ); + setNan( &d ); + return d; +} + +/** Safe cos(), returns NAN if not valid. + */ +inline double cos(double d) +{ + if ( isValidArcArg( d ) ) + return ::cos( d ); + setNan( &d ); + return d; +} + +/** Safe tan(), returns NAN if not valid. + */ +inline double tan(double d) +{ + if ( isValidArcArg( d ) ) + return ::tan( d ); + setNan( &d ); + return d; +} + +} + +} + +#endif // INCLUDED_RTL_MATH_HXX diff --git a/sal/inc/rtl/memory.h b/sal/inc/rtl/memory.h new file mode 100644 index 000000000000..11e50e9dc963 --- /dev/null +++ b/sal/inc/rtl/memory.h @@ -0,0 +1,51 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + + +#ifndef _RTL_MEMORY_H_ +#define _RTL_MEMORY_H_ + +# include <sal/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +void SAL_CALL rtl_zeroMemory(void *Ptr, sal_Size Bytes); +void SAL_CALL rtl_fillMemory(void *Ptr, sal_Size Bytes, sal_uInt8 Fill); +void SAL_CALL rtl_copyMemory(void *Dst, const void *Src, sal_Size Bytes); +void SAL_CALL rtl_moveMemory(void *Dst, const void *Src, sal_Size Bytes); +sal_Int32 SAL_CALL rtl_compareMemory(const void *MemA, const void *MemB, sal_Size Bytes); +void* SAL_CALL rtl_findInMemory(const void *MemA, sal_uInt8 ch, sal_Size Bytes); + +#ifdef __cplusplus +} +#endif + + +#endif /*_RTL_MEMORY_H_ */ + diff --git a/sal/inc/rtl/process.h b/sal/inc/rtl/process.h new file mode 100644 index 000000000000..b2e471f2def6 --- /dev/null +++ b/sal/inc/rtl/process.h @@ -0,0 +1,82 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_PROCESS_H_ +#define _RTL_PROCESS_H_ + +#include <sal/types.h> +#include <osl/process.h> + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + gets a 16-byte fixed size identifier which is guaranteed not to change + during the current process. + + The current implementation creates a 16-byte uuid without using + the ethernet address of system. Thus the + identifier is different from identifiers created + in other processes with a very probability. + + @param pTargetUUID 16 byte of memory + @see rtl_createUiid() + */ +void SAL_CALL rtl_getGlobalProcessId( sal_uInt8 *pTargetUUID ); + +/** Get the nArg-th command-line argument passed to the main-function of this process. + + This functions differs from osl_getCommandArg() in filtering any bootstrap values + given by command args, that means that all arguments starting with "-env:" will be + ignored by this function. + + @param nArg [in] The number of the argument to return. + @param strCommandArg [out] The string receives the nArg-th command-line argument. + @return osl_Process_E_None or does not return. + @see osl_getCommandArg() + @see rtl_getCommandArgCount() +*/ +oslProcessError SAL_CALL rtl_getAppCommandArg(sal_uInt32 nArg, rtl_uString **strCommandArg); + +/** Returns the number of command line arguments at process start. + + This functions differs from osl_getCommandArg() in filtering any bootstrap values + given by command args, that means that all arguments starting with "-env:" will be + ignored by this function. + + @return the number of commandline arguments passed to the main-function of this process. + @see osl_getCommandArgCount() + @see rtl_getCommandArg() +*/ +sal_uInt32 SAL_CALL rtl_getAppCommandArgCount(); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/sal/inc/rtl/random.h b/sal/inc/rtl/random.h new file mode 100644 index 000000000000..52e2d56968b9 --- /dev/null +++ b/sal/inc/rtl/random.h @@ -0,0 +1,114 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_RANDOM_H_ +#define _RTL_RANDOM_H_ "$Revision: 1.7 $" + +#include <sal/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/*======================================================================== + * + * rtlRandom interface. + * + *======================================================================*/ +/** Random Pool opaque type. + */ +typedef void* rtlRandomPool; + + +/** Error Code enumeration. + */ +enum __rtl_RandomError +{ + rtl_Random_E_None, + rtl_Random_E_Argument, + rtl_Random_E_Memory, + rtl_Random_E_Unknown, + rtl_Random_E_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +/** Error Code type. + */ +typedef enum __rtl_RandomError rtlRandomError; + + +/** Create a Random Pool. + @return initialized Random Pool, or NULL upon failure. + */ +rtlRandomPool SAL_CALL rtl_random_createPool (void) SAL_THROW_EXTERN_C(); + + +/** Destroy a Random Pool. + @param Pool [in] a Random Pool. + @return none. Pool is invalid. + */ +void SAL_CALL rtl_random_destroyPool ( + rtlRandomPool Pool +) SAL_THROW_EXTERN_C(); + + +/** Add bytes to a Random Pool. + @param Pool [in] a Random Pool. + @param pBuffer [in] a buffer containing the bytes to add. + @param nBufLen [in] the number of bytes to read from the buffer. + @return rtl_Random_E_None upon success. + */ +rtlRandomError SAL_CALL rtl_random_addBytes ( + rtlRandomPool Pool, + const void *Buffer, + sal_Size Bytes +) SAL_THROW_EXTERN_C(); + + +/** Retrieve bytes from a Random Pool. + @param Pool [in] a Random Pool. + @param pBuffer [inout] a buffer to receive the random bytes. + @param nBufLen [in] the number of bytes to write to the buffer. + @return rtl_Random_E_None upon success. + */ +rtlRandomError SAL_CALL rtl_random_getBytes ( + rtlRandomPool Pool, + void *Buffer, + sal_Size Bytes +) SAL_THROW_EXTERN_C(); + +/*======================================================================== + * + * The End. + * + *======================================================================*/ + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_RANDOM_H_ */ + diff --git a/sal/inc/rtl/ref.hxx b/sal/inc/rtl/ref.hxx new file mode 100644 index 000000000000..66e621cc29a5 --- /dev/null +++ b/sal/inc/rtl/ref.hxx @@ -0,0 +1,242 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_REF_HXX_ +#define _RTL_REF_HXX_ + +#include <sal/types.h> +#include <osl/diagnose.h> +#include <osl/interlck.h> + +namespace rtl +{ + +/** Interface for a reference type. +*/ +class IReference +{ +public: + /** @see osl_incrementInterlockedCount. + */ + virtual oslInterlockedCount SAL_CALL acquire() = 0; + + /** @see osl_decrementInterlockedCount. + */ + virtual oslInterlockedCount SAL_CALL release() = 0; +}; + + +/** Template reference class for reference type derived from IReference. +*/ +template <class reference_type> +class Reference +{ + /** The <b>reference_type</b> body pointer. + */ + reference_type * m_pBody; + + +public: + /** Constructor... + */ + inline Reference() + : m_pBody (0) + {} + + + /** Constructor... + */ + inline Reference (reference_type * pBody) + : m_pBody (pBody) + { + if (m_pBody) + m_pBody->acquire(); + } + + + /** Copy constructor... + */ + inline Reference (const Reference<reference_type> & handle) + : m_pBody (handle.m_pBody) + { + if (m_pBody) + m_pBody->acquire(); + } + + + /** Destructor... + */ + inline ~Reference() + { + if (m_pBody) + m_pBody->release(); + } + + /** Set... + Similar to assignment. + */ + inline Reference<reference_type> & + SAL_CALL set (reference_type * pBody) + { + if (pBody) + pBody->acquire(); + reference_type * const pOld = m_pBody; + m_pBody = pBody; + if (pOld) + pOld->release(); + return *this; + } + + /** Assignment. + Unbinds this instance from its body (if bound) and + bind it to the body represented by the handle. + */ + inline Reference<reference_type> & + SAL_CALL operator= (const Reference<reference_type> & handle) + { + return set( handle.m_pBody ); + } + + /** Assignment... + */ + inline Reference<reference_type> & + SAL_CALL operator= (reference_type * pBody) + { + return set( pBody ); + } + + /** Unbind the body from this handle. + Note that for a handle representing a large body, + "handle.clear().set(new body());" _might_ + perform a little bit better than "handle.set(new body());", + since in the second case two large objects exist in memory + (the old body and the new body). + */ + inline Reference<reference_type> & SAL_CALL clear() + { + if (m_pBody) + { + reference_type * const pOld = m_pBody; + m_pBody = 0; + pOld->release(); + } + return *this; + } + + + /** Get the body. Can be used instead of operator->(). + I.e. handle->someBodyOp() and handle.get()->someBodyOp() + are the same. + */ + inline reference_type * SAL_CALL get() const + { + return m_pBody; + } + + + /** Probably most common used: handle->someBodyOp(). + */ + inline reference_type * SAL_CALL operator->() const + { + OSL_PRECOND(m_pBody, "Reference::operator->() : null body"); + return m_pBody; + } + + + /** Allows (*handle).someBodyOp(). + */ + inline reference_type & SAL_CALL operator*() const + { + OSL_PRECOND(m_pBody, "Reference::operator*() : null body"); + return *m_pBody; + } + + + /** Returns True if the handle does point to a valid body. + */ + inline sal_Bool SAL_CALL is() const + { + return (m_pBody != 0); + } + + + /** Returns True if this points to pBody. + */ + inline sal_Bool SAL_CALL operator== (const reference_type * pBody) const + { + return (m_pBody == pBody); + } + + + /** Returns True if handle points to the same body. + */ + inline sal_Bool + SAL_CALL operator== (const Reference<reference_type> & handle) const + { + return (m_pBody == handle.m_pBody); + } + + + /** Needed to place References into STL collection. + */ + inline sal_Bool + SAL_CALL operator!= (const Reference<reference_type> & handle) const + { + return (m_pBody != handle.m_pBody); + } + + + /** Needed to place References into STL collection. + */ + inline sal_Bool + SAL_CALL operator< (const Reference<reference_type> & handle) const + { + return (m_pBody < handle.m_pBody); + } + + + /** Needed to place References into STL collection. + */ + inline sal_Bool + SAL_CALL operator> (const Reference<reference_type> & handle) const + { + return (m_pBody > handle.m_pBody); + } +}; + +/** @internal + Enables boost::mem_fn and boost::bind to recognize Reference. +*/ +template <typename T> +inline T * get_pointer( Reference<T> const& r ) +{ + return r.get(); +} + +} // namespace rtl + +#endif /* !_RTL_REF_HXX_ */ diff --git a/sal/inc/rtl/strbuf.h b/sal/inc/rtl/strbuf.h new file mode 100644 index 000000000000..b471cf8f5f83 --- /dev/null +++ b/sal/inc/rtl/strbuf.h @@ -0,0 +1,119 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_STRBUF_H_ +#define _RTL_STRBUF_H_ + +#include <rtl/string.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** @HTML + Allocates a new <code>String</code> that contains characters from + the character array argument. + + The <code>count</code> argument specifies + the length of the array. The initial capacity of the string buffer is + <code>16</code> plus the length of the string argument. + + @param newStr out parameter, contains the new string. The reference count is 1. + @param value the initial value of the string. + @param count the length of value. + */ +void SAL_CALL rtl_stringbuffer_newFromStr_WithLength( rtl_String ** newStr, + const sal_Char * value, + sal_Int32 count); + +/** + Allocates a new <code>String</code> that contains the same sequence of + characters as the string argument. + + The initial capacity is the larger of: + <ul> + <li> The <code>bufferLen</code> argument. + <li> The <code>length</code> of the string argument. + </ul> + + @param newStr out parameter, contains the new string. The reference count is 1. + @param capacity the initial len of the string buffer. + @param oldStr the initial value of the string. + @return the new capacity of the string buffer + */ +sal_Int32 SAL_CALL rtl_stringbuffer_newFromStringBuffer( rtl_String ** newStr, + sal_Int32 capacity, + rtl_String * olsStr ); + +/** + Ensures that the capacity of the buffer is at least equal to the + specified minimum. + + If the current capacity of this string buffer is less than the + argument, then a new internal buffer is allocated with greater + capacity. The new capacity is the larger of: + <ul> + <li>The <code>minimumCapacity</code> argument. + <li>Twice the old capacity, plus <code>2</code>. + </ul> + If the <code>minimumCapacity</code> argument is nonpositive, this + method takes no action and simply returns. + + @param capacity in: old capicity, out: new capacity. + @param minimumCapacity the minimum desired capacity. + */ +void SAL_CALL rtl_stringbuffer_ensureCapacity( /*inout*/rtl_String ** This, + /*inout*/sal_Int32* capacity, + sal_Int32 minimumCapacity); + + +/** + Inserts the string representation of the <code>char</code> array + argument into this string buffer. + + The characters of the array argument are inserted into the + contents of this string buffer at the position indicated by + <code>offset</code>. The length of this string buffer increases by + the length of the argument. + + @param capacity the capacity of the string buffer + @param offset the offset. + @param ch a character array. + @param len the number of characters to append. + @return this string buffer. + */ +void SAL_CALL rtl_stringbuffer_insert( /*inout*/rtl_String ** This, + /*inout*/sal_Int32 * capacity, + sal_Int32 offset, + const sal_Char * str, + sal_Int32 len); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_STRBUF_H_ */ diff --git a/sal/inc/rtl/strbuf.hxx b/sal/inc/rtl/strbuf.hxx new file mode 100644 index 000000000000..b6920049f2fb --- /dev/null +++ b/sal/inc/rtl/strbuf.hxx @@ -0,0 +1,665 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_STRBUF_HXX_ +#define _RTL_STRBUF_HXX_ + +#include "osl/diagnose.h" +#include <rtl/strbuf.h> +#include <rtl/string.hxx> + +#ifdef __cplusplus + +namespace rtl +{ + +/** @HTML + + A string buffer implements a mutable sequence of characters. + <p> + String buffers are safe for use by multiple threads. The methods + are synchronized where necessary so that all the operations on any + particular instance behave as if they occur in some serial order. + <p> + String buffers are used by the compiler to implement the binary + string concatenation operator <code>+</code>. For example, the code: + <p><blockquote><pre> + x = "a" + 4 + "c" + </pre></blockquote><p> + is compiled to the equivalent of: + <p><blockquote><pre> + x = new OStringBuffer().append("a").append(4).append("c") + .toString() + </pre></blockquote><p> + The principal operations on a <code>OStringBuffer</code> are the + <code>append</code> and <code>insert</code> methods, which are + overloaded so as to accept data of any type. Each effectively + converts a given datum to a string and then appends or inserts the + characters of that string to the string buffer. The + <code>append</code> method always adds these characters at the end + of the buffer; the <code>insert</code> method adds the characters at + a specified point. + <p> + For example, if <code>z</code> refers to a string buffer object + whose current contents are "<code>start</code>", then + the method call <code>z.append("le")</code> would cause the string + buffer to contain "<code>startle</code>", whereas + <code>z.insert(4, "le")</code> would alter the string buffer to + contain "<code>starlet</code>". + <p> + Every string buffer has a capacity. As long as the length of the + character sequence contained in the string buffer does not exceed + the capacity, it is not necessary to allocate a new internal + buffer array. If the internal buffer overflows, it is + automatically made larger. + */ +class OStringBuffer +{ +public: + /** + Constructs a string buffer with no characters in it and an + initial capacity of 16 characters. + */ + OStringBuffer() + : pData(NULL) + , nCapacity( 16 ) + { + rtl_string_new_WithLength( &pData, nCapacity ); + } + + /** + Allocates a new string buffer that contains the same sequence of + characters as the string buffer argument. + + @param value a <code>OStringBuffer</code>. + */ + OStringBuffer( const OStringBuffer & value ) + : pData(NULL) + , nCapacity( value.nCapacity ) + { + rtl_stringbuffer_newFromStringBuffer( &pData, value.nCapacity, value.pData ); + } + + /** + Constructs a string buffer with no characters in it and an + initial capacity specified by the <code>length</code> argument. + + @param length the initial capacity. + */ + OStringBuffer(sal_Int32 length) + : pData(NULL) + , nCapacity( length ) + { + rtl_string_new_WithLength( &pData, length ); + } + + /** + Constructs a string buffer so that it represents the same + sequence of characters as the string argument. + + The initial + capacity of the string buffer is <code>16</code> plus the length + of the string argument. + + @param value the initial string value. + */ + OStringBuffer(OString value) + : pData(NULL) + , nCapacity( value.getLength() + 16 ) + { + rtl_stringbuffer_newFromStr_WithLength( &pData, value.getStr(), value.getLength() ); + } + + /** Assign to this a copy of value. + */ + OStringBuffer& operator = ( const OStringBuffer& value ) + { + if (this != &value) + { + rtl_stringbuffer_newFromStringBuffer(&pData, + value.nCapacity, + value.pData); + nCapacity = value.nCapacity; + } + return *this; + } + + /** + Release the string data. + */ + ~OStringBuffer() + { + rtl_string_release( pData ); + } + + /** + Fill the string data in the new string and clear the buffer. + + This method is more efficient than the contructor of the string. It does + not copy the buffer. + + @return the string previously contained in the buffer. + */ + OString makeStringAndClear() + { + OString aRet( pData ); + rtl_string_new(&pData); + nCapacity = 0; + return aRet; + } + + /** + Returns the length (character count) of this string buffer. + + @return the number of characters in this string buffer. + */ + sal_Int32 getLength() const + { + return pData->length; + } + + /** + Returns the current capacity of the String buffer. + + The capacity + is the amount of storage available for newly inserted + characters. The real buffer size is 2 bytes longer, because + all strings are 0 terminated. + + @return the current capacity of this string buffer. + */ + sal_Int32 getCapacity() const + { + return nCapacity; + } + + /** + Ensures that the capacity of the buffer is at least equal to the + specified minimum. + + The new capacity will be at least as large as the maximum of the current + length (so that no contents of the buffer is destroyed) and the given + minimumCapacity. If the given minimumCapacity is negative, nothing is + changed. + + @param minimumCapacity the minimum desired capacity. + */ + void ensureCapacity(sal_Int32 minimumCapacity) + { + rtl_stringbuffer_ensureCapacity( &pData, &nCapacity, minimumCapacity ); + } + + /** + Sets the length of this String buffer. + + If the <code>newLength</code> argument is less than the current + length of the string buffer, the string buffer is truncated to + contain exactly the number of characters given by the + <code>newLength</code> argument. + <p> + If the <code>newLength</code> argument is greater than or equal + to the current length, sufficient null characters + (<code>'\u0000'</code>) are appended to the string buffer so that + length becomes the <code>newLength</code> argument. + <p> + The <code>newLength</code> argument must be greater than or equal + to <code>0</code>. + + @param newLength the new length of the buffer. + */ + void setLength(sal_Int32 newLength) + { + OSL_ASSERT(newLength >= 0); + // Avoid modifications if pData points to const empty string: + if( newLength != pData->length ) + { + if( newLength > nCapacity ) + rtl_stringbuffer_ensureCapacity(&pData, &nCapacity, newLength); + else + pData->buffer[newLength] = '\0'; + pData->length = newLength; + } + } + + /** + Returns the character at a specific index in this string buffer. + + The first character of a string buffer is at index + <code>0</code>, the next at index <code>1</code>, and so on, for + array indexing. + <p> + The index argument must be greater than or equal to + <code>0</code>, and less than the length of this string buffer. + + @param index the index of the desired character. + @return the character at the specified index of this string buffer. + */ + sal_Char charAt( sal_Int32 index ) + { + OSL_ASSERT(index >= 0 && index < pData->length); + return pData->buffer[ index ]; + } + + /** + Return a null terminated character array. + */ + operator const sal_Char *() const { return pData->buffer; } + + /** + Return a null terminated character array. + */ + const sal_Char* getStr() const { return pData->buffer; } + + + /** + The character at the specified index of this string buffer is set + to <code>ch</code>. + + The index argument must be greater than or equal to + <code>0</code>, and less than the length of this string buffer. + + @param index the index of the character to modify. + @param ch the new character. + */ + OStringBuffer & setCharAt(sal_Int32 index, sal_Char ch) + { + OSL_ASSERT(index >= 0 && index < pData->length); + pData->buffer[ index ] = ch; + return *this; + } + + /** + Appends the string to this string buffer. + + The characters of the <code>String</code> argument are appended, in + order, to the contents of this string buffer, increasing the + length of this string buffer by the length of the argument. + + @param str a string. + @return this string buffer. + */ + OStringBuffer & append(const OString &str) + { + return append( str.getStr(), str.getLength() ); + } + + /** + Appends the string representation of the <code>char</code> array + argument to this string buffer. + + The characters of the array argument are appended, in order, to + the contents of this string buffer. The length of this string + buffer increases by the length of the argument. + + @param str the characters to be appended. + @return this string buffer. + */ + OStringBuffer & append( const sal_Char * str ) + { + return append( str, rtl_str_getLength( str ) ); + } + + /** + Appends the string representation of the <code>char</code> array + argument to this string buffer. + + Characters of the character array <code>str</code> are appended, + in order, to the contents of this string buffer. The length of this + string buffer increases by the value of <code>len</code>. + + @param str the characters to be appended; must be non-null, and must + point to at least len characters + @param len the number of characters to append; must be non-negative + @return this string buffer. + */ + OStringBuffer & append( const sal_Char * str, sal_Int32 len) + { + // insert behind the last character + rtl_stringbuffer_insert( &pData, &nCapacity, getLength(), str, len ); + return *this; + } + + /** + Appends the string representation of the <code>sal_Bool</code> + argument to the string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param b a <code>sal_Bool</code>. + @return this string buffer. + */ + OStringBuffer & append(sal_Bool b) + { + sal_Char sz[RTL_STR_MAX_VALUEOFBOOLEAN]; + return append( sz, rtl_str_valueOfBoolean( sz, b ) ); + } + + /** + Appends the string representation of the <code>char</code> + argument to this string buffer. + + The argument is appended to the contents of this string buffer. + The length of this string buffer increases by <code>1</code>. + + @param ch a <code>char</code>. + @return this string buffer. + */ + OStringBuffer & append(sal_Char c) + { + return append( &c, 1 ); + } + + /** + Appends the string representation of the <code>sal_Int32</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param i an <code>sal_Int32</code>. + @return this string buffer. + */ + OStringBuffer & append(sal_Int32 i, sal_Int16 radix = 10 ) + { + sal_Char sz[RTL_STR_MAX_VALUEOFINT32]; + return append( sz, rtl_str_valueOfInt32( sz, i, radix ) ); + } + + /** + Appends the string representation of the <code>long</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param l a <code>long</code>. + @return this string buffer. + */ + OStringBuffer & append(sal_Int64 l, sal_Int16 radix = 10 ) + { + sal_Char sz[RTL_STR_MAX_VALUEOFINT64]; + return append( sz, rtl_str_valueOfInt64( sz, l, radix ) ); + } + + /** + Appends the string representation of the <code>float</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param f a <code>float</code>. + @return this string buffer. + */ + OStringBuffer & append(float f) + { + sal_Char sz[RTL_STR_MAX_VALUEOFFLOAT]; + return append( sz, rtl_str_valueOfFloat( sz, f ) ); + } + + /** + Appends the string representation of the <code>double</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param d a <code>double</code>. + @return this string buffer. + */ + OStringBuffer & append(double d) + { + sal_Char sz[RTL_STR_MAX_VALUEOFDOUBLE]; + return append( sz, rtl_str_valueOfDouble( sz, d ) ); + } + + /** + Inserts the string into this string buffer. + + The characters of the <code>String</code> argument are inserted, in + order, into this string buffer at the indicated offset. The length + of this string buffer is increased by the length of the argument. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param str a string. + @return this string buffer. + */ + OStringBuffer & insert(sal_Int32 offset, const OString & str) + { + return insert( offset, str.getStr(), str.getLength() ); + } + + /** + Inserts the string representation of the <code>char</code> array + argument into this string buffer. + + The characters of the array argument are inserted into the + contents of this string buffer at the position indicated by + <code>offset</code>. The length of this string buffer increases by + the length of the argument. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param ch a character array. + @return this string buffer. + */ + OStringBuffer & insert( sal_Int32 offset, const sal_Char * str ) + { + return insert( offset, str, rtl_str_getLength( str ) ); + } + + /** + Inserts the string representation of the <code>char</code> array + argument into this string buffer. + + The characters of the array argument are inserted into the + contents of this string buffer at the position indicated by + <code>offset</code>. The length of this string buffer increases by + the length of the argument. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param ch a character array. + @param len the number of characters to append. + @return this string buffer. + */ + OStringBuffer & insert( sal_Int32 offset, const sal_Char * str, sal_Int32 len) + { + // insert behind the last character + rtl_stringbuffer_insert( &pData, &nCapacity, offset, str, len ); + return *this; + } + + /** + Inserts the string representation of the <code>sal_Bool</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>sal_Bool</code>. + @return this string buffer. + */ + OStringBuffer & insert(sal_Int32 offset, sal_Bool b) + { + sal_Char sz[RTL_STR_MAX_VALUEOFBOOLEAN]; + return insert( offset, sz, rtl_str_valueOfBoolean( sz, b ) ); + } + + /** + Inserts the string representation of the <code>char</code> + argument into this string buffer. + + The second argument is inserted into the contents of this string + buffer at the position indicated by <code>offset</code>. The length + of this string buffer increases by one. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param ch a <code>char</code>. + @return this string buffer. + */ + OStringBuffer & insert(sal_Int32 offset, sal_Char c) + { + return insert( offset, &c, 1 ); + } + + /** + Inserts the string representation of the second <code>sal_Int32</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b an <code>sal_Int32</code>. + @return this string buffer. + */ + OStringBuffer & insert(sal_Int32 offset, sal_Int32 i, sal_Int16 radix = 10 ) + { + sal_Char sz[RTL_STR_MAX_VALUEOFINT32]; + return insert( offset, sz, rtl_str_valueOfInt32( sz, i, radix ) ); + } + + /** + Inserts the string representation of the <code>long</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>long</code>. + @return this string buffer. + */ + OStringBuffer & insert(sal_Int32 offset, sal_Int64 l, sal_Int16 radix = 10 ) + { + sal_Char sz[RTL_STR_MAX_VALUEOFINT64]; + return insert( offset, sz, rtl_str_valueOfInt64( sz, l, radix ) ); + } + + /** + Inserts the string representation of the <code>float</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>float</code>. + @return this string buffer. + */ + OStringBuffer insert(sal_Int32 offset, float f) + { + sal_Char sz[RTL_STR_MAX_VALUEOFFLOAT]; + return insert( offset, sz, rtl_str_valueOfFloat( sz, f ) ); + } + + /** + Inserts the string representation of the <code>double</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>double</code>. + @return this string buffer. + */ + OStringBuffer & insert(sal_Int32 offset, double d) + { + sal_Char sz[RTL_STR_MAX_VALUEOFDOUBLE]; + return insert( offset, sz, rtl_str_valueOfDouble( sz, d ) ); + } +private: + /** + A pointer to the data structur which contains the data. + */ + rtl_String * pData; + + /** + The len of the pData->buffer. + */ + sal_Int32 nCapacity; +}; + +} + +#endif /* __cplusplus */ +#endif /* _RTL_STRBUF_HXX_ */ + + diff --git a/sal/inc/rtl/string.h b/sal/inc/rtl/string.h new file mode 100644 index 000000000000..fe8548078227 --- /dev/null +++ b/sal/inc/rtl/string.h @@ -0,0 +1,1193 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_STRING_H_ +#define _RTL_STRING_H_ + +#include <sal/types.h> +#include <osl/interlck.h> +#include <rtl/textcvt.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* ======================================================================= */ + +/** Return the length of a string. + + The length is equal to the number of 8-bit characters in the string, + without the terminating NUL character. + + @param str + a null-terminated string. + + @return + the length of the sequence of characters represented by this string, + excluding the terminating NUL character. + */ +sal_Int32 SAL_CALL rtl_str_getLength( const sal_Char * str ) SAL_THROW_EXTERN_C(); + +/** Compare two strings. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. Both strings must be + null-terminated. + + @param first + the first null-terminated string to be compared. + + @param second + the second null-terminated string which is compared with the first one. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_str_compare( const sal_Char * first, const sal_Char * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_str_compare_WithLength( const sal_Char * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 secondLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings with a maximum count of characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @param shortenedLen + the maximum number of characters to compare. This length can be greater + or smaller than the lengths of the two strings. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_str_shortenedCompare_WithLength( const sal_Char * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 secondLen, sal_Int32 shortenedLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings from back to front. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string + compares less than the second string, and a value greater than 0 if the + first string compares greater than the second string. + */ +sal_Int32 SAL_CALL rtl_str_reverseCompare_WithLength( const sal_Char * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 secondLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings, ignoring the case of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. Both strings must be null-terminated. + + @param first + the first null-terminated string to be compared. + + @param second + the second null-terminated string which is compared with the first one. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_str_compareIgnoreAsciiCase( const sal_Char * first, const sal_Char * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings, ignoring the case of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_str_compareIgnoreAsciiCase_WithLength( const sal_Char * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 secondLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings with a maximum count of characters, ignoring the case + of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @param shortenedLen + the maximum number of characters to compare. This length can be greater + or smaller than the lengths of the two strings. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( const sal_Char * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 secondLen, sal_Int32 shortenedLen ) SAL_THROW_EXTERN_C(); + +/** Return a hash code for a string. + + It is not allowed to store the hash code persistently, because later + versions could return other hash codes. The string must be + null-terminated. + + @param str + a null-terminated string. + + @return + a hash code for the given string. + */ +sal_Int32 SAL_CALL rtl_str_hashCode( const sal_Char * str ) SAL_THROW_EXTERN_C(); + +/** Return a hash code for a string. + + It is not allowed to store the hash code persistently, because later + versions could return other hash codes. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @return + a hash code for the given string. + */ +sal_Int32 SAL_CALL rtl_str_hashCode_WithLength( const sal_Char * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a character within a string. + + The string must be null-terminated. + + @param str + a null-terminated string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the first occurrence of the character in the + string, or -1 if the character does not occur. + */ +sal_Int32 SAL_CALL rtl_str_indexOfChar( const sal_Char * str, sal_Char ch ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a character within a string. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the first occurrence of the character in the + string, or -1 if the character does not occur. + */ +sal_Int32 SAL_CALL rtl_str_indexOfChar_WithLength( const sal_Char * str, sal_Int32 len, sal_Char ch ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a character within a string. + + The string must be null-terminated. + + @param str + a null-terminated string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the last occurrence of the character in the + string, or -1 if the character does not occur. The returned value is + always smaller than the string length. + */ +sal_Int32 SAL_CALL rtl_str_lastIndexOfChar( const sal_Char * str, sal_Char ch ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a character within a string. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the last occurrence of the character in the + string, or -1 if the character does not occur. The returned value is + always smaller than the string length. + */ +sal_Int32 SAL_CALL rtl_str_lastIndexOfChar_WithLength( const sal_Char * str, sal_Int32 len, sal_Char ch ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + Both strings must be null-terminated. + + @param str + a null-terminated string. + + @param subStr + the null-terminated substring to be searched for. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_str_indexOfStr( const sal_Char * str, const sal_Char * subStr ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param subStr + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified subLen. + + @param subLen + the length of the substring. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_str_indexOfStr_WithLength( const sal_Char * str, sal_Int32 len, const sal_Char * subStr, sal_Int32 subLen ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + Both strings must be null-terminated. + + @param str + a null-terminated string. + + @param subStr + the null-terminated substring to be searched for. + + @return + the index (starting at 0) of the first character of the last occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_str_lastIndexOfStr( const sal_Char * str, const sal_Char * subStr ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param subStr + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified subLen. + + @param subLen + the length of the substring. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_str_lastIndexOfStr_WithLength( const sal_Char * str, sal_Int32 len, const sal_Char * subStr, sal_Int32 subLen ) SAL_THROW_EXTERN_C(); + +/** Replace all occurrences of a single character within a string. + + If oldChar does not occur within str, then the string is not modified. + The string must be null-terminated. + + @param str + a null-terminated string. + + @param oldChar + the old character. + + @param newChar + the new character. + */ +void SAL_CALL rtl_str_replaceChar( sal_Char * str, sal_Char oldChar, sal_Char newChar ) SAL_THROW_EXTERN_C(); + +/** Replace all occurrences of a single character within a string. + + If oldChar does not occur within str, then the string is not modified. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param oldChar + the old character. + + @param newChar + the new character. + */ +void SAL_CALL rtl_str_replaceChar_WithLength( sal_Char * str, sal_Int32 len, sal_Char oldChar, sal_Char newChar ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII uppercase letters to lowercase within a string. + + The characters with values between 65 and 90 (ASCII A--Z) are replaced + with values between 97 and 122 (ASCII a--z). The string must be + null-terminated. + + @param str + a null-terminated string. + */ +void SAL_CALL rtl_str_toAsciiLowerCase( sal_Char * str ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII uppercase letters to lowercase within a string. + + The characters with values between 65 and 90 (ASCII A--Z) are replaced + with values between 97 and 122 (ASCII a--z). + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + */ +void SAL_CALL rtl_str_toAsciiLowerCase_WithLength( sal_Char * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII lowercase letters to uppercase within a string. + + The characters with values between 97 and 122 (ASCII a--z) are replaced + with values between 65 and 90 (ASCII A--Z). The string must be + null-terminated. + + @param str + a null-terminated string. + */ +void SAL_CALL rtl_str_toAsciiUpperCase( sal_Char * str ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII lowercase letters to uppercase within a string. + + The characters with values between 97 and 122 (ASCII a--z) are replaced + with values between 65 and 90 (ASCII A--Z). + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + */ +void SAL_CALL rtl_str_toAsciiUpperCase_WithLength( sal_Char * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Remove white space from both ends of a string. + + All characters with values less than or equal to 32 (the space character) + are considered to be white space. This function cannot be used for + language-specific operations. The string must be null-terminated. + + @param str + a null-terminated string. + + @return + the new length of the string. + */ +sal_Int32 SAL_CALL rtl_str_trim( sal_Char * str ) SAL_THROW_EXTERN_C(); + +/** Remove white space from both ends of the string. + + All characters with values less than or equal to 32 (the space character) + are considered to be white space. This function cannot be used for + language-specific operations. The string must be null-terminated. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the original length of the string. + + @return + the new length of the string. + */ +sal_Int32 SAL_CALL rtl_str_trim_WithLength( sal_Char * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Create the string representation of a boolean. + + If b is true, the buffer is filled with the string "true" and 5 is + returned. If b is false, the buffer is filled with the string "false" and + 6 is returned. This function cannot be used for language-specific + operations. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_STR_MAX_VALUEOFBOOLEAN define to create + a buffer that is big enough. + + @param b + a boolean value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_str_valueOfBoolean( sal_Char * str, sal_Bool b ) SAL_THROW_EXTERN_C(); +#define RTL_STR_MAX_VALUEOFBOOLEAN 6 + +/** Create the string representation of a character. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_STR_MAX_VALUEOFCHAR define to create a + buffer that is big enough. + + @param ch + a character value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_str_valueOfChar( sal_Char * str, sal_Char ch ) SAL_THROW_EXTERN_C(); +#define RTL_STR_MAX_VALUEOFCHAR 2 + +/** Create the string representation of an integer. + + This function cannot be used for language-specific operations. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_STR_MAX_VALUEOFINT32 define to create a + buffer that is big enough. + + @param i + an integer value. + + @param radix + the radix. Must be between RTL_STR_MIN_RADIX (2) and RTL_STR_MAX_RADIX + (36), inclusive. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_str_valueOfInt32( sal_Char * str, sal_Int32 i, sal_Int16 radix ) SAL_THROW_EXTERN_C(); +#define RTL_STR_MIN_RADIX 2 +#define RTL_STR_MAX_RADIX 36 +#define RTL_STR_MAX_VALUEOFINT32 33 + +/** Create the string representation of a long integer. + + This function cannot be used for language-specific operations. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_STR_MAX_VALUEOFINT64 define to create a + buffer that is big enough. + + @param l + a long integer value. + + @param radix + the radix. Must be between RTL_STR_MIN_RADIX (2) and RTL_STR_MAX_RADIX + (36), inclusive. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_str_valueOfInt64( sal_Char * str, sal_Int64 l, sal_Int16 radix ) SAL_THROW_EXTERN_C(); +#define RTL_STR_MAX_VALUEOFINT64 65 + +/** Create the string representation of a float. + + This function cannot be used for language-specific conversion. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_STR_MAX_VALUEOFFLOAT define to create a + buffer that is big enough. + + @param f + a float value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_str_valueOfFloat( sal_Char * str, float f ) SAL_THROW_EXTERN_C(); +#define RTL_STR_MAX_VALUEOFFLOAT 15 + +/** Create the string representation of a double. + + This function cannot be used for language-specific conversion. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_STR_MAX_VALUEOFDOUBLE define to create + a buffer that is big enough. + + @param d + a double value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_str_valueOfDouble( sal_Char * str, double d ) SAL_THROW_EXTERN_C(); +#define RTL_STR_MAX_VALUEOFDOUBLE 25 + +/** Interpret a string as a boolean. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @return + true if the string is "1" or "true" in any ASCII case, false otherwise. + */ +sal_Bool SAL_CALL rtl_str_toBoolean( const sal_Char * str ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as an integer. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @param radix + the radix. Must be between RTL_STR_MIN_RADIX (2) and RTL_STR_MAX_RADIX + (36), inclusive. + + @return + the integer value represented by the string, or 0 if the string does not + represent an integer. + */ +sal_Int32 SAL_CALL rtl_str_toInt32( const sal_Char * str, sal_Int16 radix ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as a long integer. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @param radix + the radix. Must be between RTL_STR_MIN_RADIX (2) and RTL_STR_MAX_RADIX + (36), inclusive. + + @return + the long integer value represented by the string, or 0 if the string does + not represent a long integer. + */ +sal_Int64 SAL_CALL rtl_str_toInt64( const sal_Char * str, sal_Int16 radix ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as a float. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @return + the float value represented by the string, or 0.0 if the string does not + represent a float. + */ +float SAL_CALL rtl_str_toFloat( const sal_Char * str ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as a double. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @return + the float value represented by the string, or 0.0 if the string does not + represent a double. + */ +double SAL_CALL rtl_str_toDouble( const sal_Char * str ) SAL_THROW_EXTERN_C(); + +/* ======================================================================= */ + +#ifdef SAL_W32 +# pragma pack(push, 8) +#elif defined(SAL_OS2) +# pragma pack(push, 4) +#endif + +/** The implementation of a byte string. + + @internal + */ +typedef struct _rtl_String +{ + oslInterlockedCount refCount; /* opaque */ + sal_Int32 length; + sal_Char buffer[1]; +} rtl_String; + +#if defined( SAL_W32) || defined(SAL_OS2) +#pragma pack(pop) +#endif + +/* ----------------------------------------------------------------------- */ + +/** Increment the reference count of a string. + + @param str + a string. + */ +void SAL_CALL rtl_string_acquire( rtl_String * str ) SAL_THROW_EXTERN_C(); + +/** Decrement the reference count of a string. + + If the count goes to zero than the string data is deleted. + + @param str + a string. + */ +void SAL_CALL rtl_string_release( rtl_String * str ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string containing no characters. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + */ +void SAL_CALL rtl_string_new( rtl_String ** newStr ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string containing space for a given number of characters. + + If len is greater than zero, the reference count of the new string will be + 1. The values of all characters are set to 0 and the length of the string + is 0. This function does not handle out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param len + the number of characters. + */ +void SAL_CALL rtl_string_new_WithLength( rtl_String ** newStr, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string that contains a copy of another string. + + If the length of value is greater than zero, the reference count of the + new string will be 1. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param value + a valid string. + */ +void SAL_CALL rtl_string_newFromString( rtl_String ** newStr, const rtl_String * value ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string that contains a copy of a character array. + + If the length of value is greater than zero, the reference count of the + new string will be 1. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param value + a null-terminated character array. + */ +void SAL_CALL rtl_string_newFromStr( rtl_String ** newStr, const sal_Char * value ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string that contains a copy of a character array. + + If the length of value is greater than zero, the reference count of the + new string will be 1. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param value + a character array. Need not be null-terminated, but must be at least as + long as the specified len. + + @param len + the length of the character array. + */ +void SAL_CALL rtl_string_newFromStr_WithLength( rtl_String ** newStr, const sal_Char * value, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Assign a new value to a string. + + First releases any value str might currently hold, then acquires + rightValue. + + @param str + pointer to the string. The pointed-to data must be null or a valid + string. + + @param rightValue + a valid string. + */ +void SAL_CALL rtl_string_assign( rtl_String ** str, rtl_String * rightValue ) SAL_THROW_EXTERN_C(); + +/** Return the length of a string. + + The length is equal to the number of characters in the string. + + @param str + a valid string. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_string_getLength( const rtl_String * str ) SAL_THROW_EXTERN_C(); + +/** Return a pointer to the underlying character array of a string. + + @param str + a valid string. + + @return + a pointer to the null-terminated character array. + */ +sal_Char * SAL_CALL rtl_string_getStr( rtl_String * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string that is the concatenation of two other strings. + + The new string does not necessarily have a reference count of 1 (in cases + where one of the two other strings is empty), so it must not be modified + without checking the reference count. This function does not handle + out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param left + a valid string. + + @param right + a valid string. + */ +void SAL_CALL rtl_string_newConcat( rtl_String ** newStr, rtl_String * left, rtl_String * right ) SAL_THROW_EXTERN_C(); + +/** Create a new string by replacing a substring of another string. + + The new string results from replacing a number of characters (count), + starting at the specified position (index) in the original string (str), + with some new substring (subStr). If subStr is null, than only a number + of characters is deleted. + + The new string does not necessarily have a reference count of 1, so it + must not be modified without checking the reference count. This function + does not handle out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + + @param index + the index into str at which to start replacement. Must be between 0 and + the length of str, inclusive. + + @param count + the number of charcters to remove. Must not be negative, and the sum of + index and count must not exceed the length of str. + + @param subStr + either null or a valid string to be inserted. + */ +void SAL_CALL rtl_string_newReplaceStrAt( rtl_String ** newStr, rtl_String * str, sal_Int32 idx, sal_Int32 count, rtl_String * subStr ) SAL_THROW_EXTERN_C(); + +/** Create a new string by replacing all occurrences of a single character + within another string. + + The new string results from replacing all occurrences of oldChar in str + with newChar. + + The new string does not necessarily have a reference count of 1 (in cases + where oldChar does not occur in str), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + + @param oldChar + the old character. + + @param newChar + the new character. + */ +void SAL_CALL rtl_string_newReplace( rtl_String ** newStr, rtl_String * str, sal_Char oldChar, sal_Char newChar ) SAL_THROW_EXTERN_C(); + +/** Create a new string by converting all ASCII uppercase letters to lowercase + within another string. + + The new string results from replacing all characters with values between + 65 and 90 (ASCII A--Z) by values between 97 and 122 (ASCII a--z). + + This function cannot be used for language-specific conversion. The new + string does not necessarily have a reference count of 1 (in cases where + no characters need to be converted), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + */ +void SAL_CALL rtl_string_newToAsciiLowerCase( rtl_String ** newStr, rtl_String * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string by converting all ASCII lowercase letters to uppercase + within another string. + + The new string results from replacing all characters with values between + 97 and 122 (ASCII a--z) by values between 65 and 90 (ASCII A--Z). + + This function cannot be used for language-specific conversion. The new + string does not necessarily have a reference count of 1 (in cases where + no characters need to be converted), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + */ +void SAL_CALL rtl_string_newToAsciiUpperCase( rtl_String ** newStr, rtl_String * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string by removing white space from both ends of another + string. + + The new string results from removing all characters with values less than + or equal to 32 (the space character) form both ends of str. + + This function cannot be used for language-specific conversion. The new + string does not necessarily have a reference count of 1 (in cases where + no characters need to be removed), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + */ +void SAL_CALL rtl_string_newTrim( rtl_String ** newStr, rtl_String * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string by extracting a single token from another string. + + Starting at index, the token's next token is searched for. If there is no + such token, the result is an empty string. Otherwise, all characters from + the start of that token and up to, but not including the next occurrence + of cTok make up the resulting token. The return value is the position of + the next token, or -1 if no more tokens follow. + + Example code could look like + rtl_String * pToken = NULL; + sal_Int32 nIndex = 0; + do + { + ... + nIndex = rtl_string_getToken(&pToken, pStr, 0, ';', nIndex); + ... + } + while (nIndex >= 0); + + The new string does not necessarily have a reference count of 1, so it + must not be modified without checking the reference count. This function + does not handle out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. If either token or index is negative, an empty token is stored in + newStr (and -1 is returned). + + @param str + a valid string. + + @param token + the number of the token to return, starting at index. + + @param cTok + the character that seperates the tokens. + + @param index + the position at which searching for the token starts. Must not be greater + than the length of str. + + @return + the index of the next token, or -1 if no more tokens follow. + */ +sal_Int32 SAL_CALL rtl_string_getToken( rtl_String ** newStr , rtl_String * str, sal_Int32 token, sal_Char cTok, sal_Int32 idx ) SAL_THROW_EXTERN_C(); + +/* ======================================================================= */ + +/** Supply an ASCII string literal together with its length. + + This macro can be used to compute (some of) the arguments in function calls + like rtl::OString(RTL_CONSTASCII_STRINGPARAM("foo")) or + rtl::OUString::equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("foo")). + + @param constAsciiStr + must be an expression of type "(possibly cv-qualified reference to) array of + (possibly cv-qualified) char." Each element of the referenced array must + represent an ASCII value in the range 0x00--0x7F. The last element of the + referenced array is not considered part of the represented ASCII string, and + its value should be 0x00. Depending on where this macro is used, the nature + of the supplied expression might be further restricted. +*/ +#define RTL_CONSTASCII_STRINGPARAM( constAsciiStr ) constAsciiStr, ((sal_Int32)sizeof(constAsciiStr)-1) + +/** Supply the length of an ASCII string literal. + + This macro can be used to compute arguments in function calls like + rtl::OUString::match(other, RTL_CONSTASCII_LENGTH("prefix")). + + @param constAsciiStr + must be an expression of type "(possibly cv-qualified reference to) array of + (possibly cv-qualified) char." Each element of the referenced array must + represent an ASCII value in the range 0x00--0x7F. The last element of the + referenced array is not considered part of the represented ASCII string, and + its value should be 0x00. Depending on where this macro is used, the nature + of the supplied expression might be further restricted. +*/ +#define RTL_CONSTASCII_LENGTH( constAsciiStr ) ((sal_Int32)(sizeof(constAsciiStr)-1)) + +/* ======================================================================= */ + +/* predefined constants for String-Conversion */ +#define OUSTRING_TO_OSTRING_CVTFLAGS (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |\ + RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT |\ + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE |\ + RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 |\ + RTL_UNICODETOTEXT_FLAGS_NOCOMPOSITE) + +/* ----------------------------------------------------------------------- */ + +/** Create a new byte string by converting a Unicode string, using a specific + text encoding. + + The lengths of the byte string and the Unicode string may differ (e.g., + for double-byte encodings, UTF-7, UTF-8). + + If the length of the Unicode string is greater than zero, the reference + count of the new string will be 1. + + If an out-of-memory condition occurs, newStr will point to a null pointer + upon return. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a Unicode character array. Need not be null-terminated, but must be at + least as long as the specified len. + + @param len + the length of the Unicode character array. + + @param encoding + the text encoding to use for conversion. + + @param convertFlags + flags which control the conversion. Either use + OUSTRING_TO_OSTRING_CVTFLAGS, or see + <http://udk.openoffice.org/cpp/man/spec/textconversion.html> for more + details. + */ +void SAL_CALL rtl_uString2String( rtl_String ** newStr, const sal_Unicode * str, sal_Int32 len, rtl_TextEncoding encoding, sal_uInt32 convertFlags ) SAL_THROW_EXTERN_C(); + +/** + Converts a Unicode string to a byte string, signalling failure. + + @param pTarget + An out parameter receiving the converted string. Must not be null itself, and + must contain either null or a pointer to a valid rtl_String; the contents are + not modified if conversion fails (rtl_convertUStringToString returns false). + + @param pSource + The Unicode string. May only be null if nLength is zero. + + @param nLength + The length of the Unicode string. Must be non-negative. + + @param nEncoding + The text encoding to convert into. Must be an octet encoding (i.e., + rtl_isOctetTextEncoding(nEncoding) must return true). + + @param nFlags + A combination of RTL_UNICODETOTEXT_FLAGS that detail how to do the conversion + (see rtl_convertUnicodeToText). RTL_UNICODETOTEXT_FLAGS_FLUSH need not be + included, it is implicitly assumed. Typical uses are either + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR | + RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR (fail if a Unicode character cannot be + converted to the target nEncoding) or OUSTRING_TO_OSTRING_CVTFLAGS (make a + best efforts conversion). + + @return + True if the conversion succeeded, false otherwise. + */ +sal_Bool SAL_CALL rtl_convertUStringToString(rtl_String ** pTarget, + sal_Unicode const * pSource, + sal_Int32 nLength, + rtl_TextEncoding nEncoding, + sal_uInt32 nFlags) + SAL_THROW_EXTERN_C(); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_STRING_H_ */ diff --git a/sal/inc/rtl/string.hxx b/sal/inc/rtl/string.hxx new file mode 100644 index 000000000000..c85da92c177b --- /dev/null +++ b/sal/inc/rtl/string.hxx @@ -0,0 +1,941 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_STRING_HXX_ +#define _RTL_STRING_HXX_ + +#ifdef __cplusplus + +#ifndef _RTL_DIAGNOSE_H_ +#include <osl/diagnose.h> +#endif +#include <rtl/memory.h> +#include <rtl/textenc.h> +#include <rtl/string.h> + +#if !defined EXCEPTIONS_OFF +#include <new> +#endif + +namespace rtl +{ + +/* ======================================================================= */ + +/** + This String class provide base functionality for C++ like 8-Bit + character array handling. The advantage of this class is, that it + handle all the memory managament for you - and it do it + more efficient. If you assign a string to another string, the + data of both strings are shared (without any copy operation or + memory allocation) as long as you do not change the string. This class + stores also the length of the string, so that many operations are + faster as the C-str-functions. + + This class provide only readonly string handling. So you could create + a string and you could only query the content from this string. + It provide also functionality to change the string, but this results + in every case in a new string instance (in the most cases with an + memory allocation). You don't have functionality to change the + content of the string. If you want change the string content, than + you should us the OStringBuffer class, which provide these + functionality and avoid to much memory allocation. + + The design of this class is similar to the string classes in Java + and so more people should have fewer understanding problems when they + use this class. +*/ + +class OString +{ +public: + /** @internal */ + rtl_String * pData; + +private: + /** @internal */ + class DO_NOT_ACQUIRE; + + /** @internal */ + OString( rtl_String * value, DO_NOT_ACQUIRE * ) + { + pData = value; + } + +public: + /** + New string containing no characters. + */ + OString() SAL_THROW(()) + { + pData = 0; + rtl_string_new( &pData ); + } + + /** + New string from OString. + + @param str a OString. + */ + OString( const OString & str ) SAL_THROW(()) + { + pData = str.pData; + rtl_string_acquire( pData ); + } + + /** + New string from OString data. + + @param str a OString data. + */ + OString( rtl_String * str ) SAL_THROW(()) + { + pData = str; + rtl_string_acquire( pData ); + } + + /** + New string from a single character. + + @param value a character. + */ + explicit OString( sal_Char value ) SAL_THROW(()) + : pData (0) + { + rtl_string_newFromStr_WithLength( &pData, &value, 1 ); + } + + /** + New string from a character buffer array. + + @param value a NULL-terminated character array. + */ + OString( const sal_Char * value ) SAL_THROW(()) + { + pData = 0; + rtl_string_newFromStr( &pData, value ); + } + + /** + New string from a character buffer array. + + @param value a character array. + @param length the number of character which should be copied. + The character array length must be greater or + equal than this value. + */ + OString( const sal_Char * value, sal_Int32 length ) SAL_THROW(()) + { + pData = 0; + rtl_string_newFromStr_WithLength( &pData, value, length ); + } + + /** + New string from a Unicode character buffer array. + + @param value a Unicode character array. + @param length the number of character which should be converted. + The Unicode character array length must be + greater or equal than this value. + @param encoding the text encoding in which the Unicode character + sequence should be converted. + @param convertFlags flags which controls the conversion. + see RTL_UNICODETOTEXT_FLAGS_... + + @exception std::bad_alloc is thrown if an out-of-memory condition occurs + */ + OString( const sal_Unicode * value, sal_Int32 length, + rtl_TextEncoding encoding, + sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS ) + { + pData = 0; + rtl_uString2String( &pData, value, length, encoding, convertFlags ); +#if defined EXCEPTIONS_OFF + OSL_ASSERT(pData != NULL); +#else + if (pData == 0) { + throw std::bad_alloc(); + } +#endif + } + + /** + Release the string data. + */ + ~OString() SAL_THROW(()) + { + rtl_string_release( pData ); + } + + /** + Assign a new string. + + @param str a OString. + */ + OString & operator=( const OString & str ) SAL_THROW(()) + { + rtl_string_assign( &pData, str.pData ); + return *this; + } + + /** + Append a string to this string. + + @param str a OString. + */ + OString & operator+=( const OString & str ) SAL_THROW(()) + { + rtl_string_newConcat( &pData, pData, str.pData ); + return *this; + } + + /** + Returns the length of this string. + + The length is equal to the number of characters in this string. + + @return the length of the sequence of characters represented by this + object. + */ + sal_Int32 getLength() const SAL_THROW(()) { return pData->length; } + + /** + Returns a pointer to the characters of this string. + + <p>The returned pointer is not guaranteed to point to a null-terminated + byte string. Note that this string object may contain embedded null + characters, which will thus also be embedded in the returned byte + string.</p> + + @return a pointer to a (not necessarily null-terminated) byte string + representing the characters of this string object. + */ + operator const sal_Char *() const SAL_THROW(()) { return pData->buffer; } + + /** + Returns a pointer to the characters of this string. + + <p>The returned pointer is guaranteed to point to a null-terminated byte + string. But note that this string object may contain embedded null + characters, which will thus also be embedded in the returned + null-terminated byte string.</p> + + @return a pointer to a null-terminated byte string representing the + characters of this string object. + */ + const sal_Char * getStr() const SAL_THROW(()) { return pData->buffer; } + + /** + Compares two strings. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + This function can't be used for language specific sorting. + + @param str the object to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 compareTo( const OString & str ) const SAL_THROW(()) + { + return rtl_str_compare_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ); + } + + /** + Compares two strings with an maximum count of characters. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + This function can't be used for language specific sorting. + + @param str the object to be compared. + @param maxLength the maximum count of characters to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 compareTo( const OString & rObj, sal_Int32 maxLength ) const SAL_THROW(()) + { + return rtl_str_shortenedCompare_WithLength( pData->buffer, pData->length, + rObj.pData->buffer, rObj.pData->length, maxLength ); + } + + /** + Compares two strings in reverse order. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + This function can't be used for language specific sorting. + + @param str the object to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 reverseCompareTo( const OString & str ) const SAL_THROW(()) + { + return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ); + } + + /** + Perform a comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string. + This function can't be used for language specific comparison. + + @param str the object to be compared. + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equals( const OString & str ) const SAL_THROW(()) + { + if ( pData->length != str.pData->length ) + return sal_False; + if ( pData == str.pData ) + return sal_True; + return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ) == 0; + } + + /** + Perform a ASCII lowercase comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string, + ignoring the case. + Character values between 65 and 90 (ASCII A-Z) are interpreted as + values between 97 and 122 (ASCII a-z). + This function can't be used for language specific comparison. + + @param str the object to be compared. + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equalsIgnoreAsciiCase( const OString & str ) const SAL_THROW(()) + { + if ( pData->length != str.pData->length ) + return sal_False; + if ( pData == str.pData ) + return sal_True; + return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ) == 0; + } + + /** + Match against a substring appearing in this string. + + The result is true if and only if the second string appears as a substring + of this string, at the given position. + This function can't be used for language specific comparison. + + @param str the object (substring) to be compared. + @param fromIndex the index to start the comparion from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return sal_True if str match with the characters in the string + at the given position; + sal_False, otherwise. + */ + sal_Bool match( const OString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + return rtl_str_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + str.pData->buffer, str.pData->length, str.pData->length ) == 0; + } + + /** + Match against a substring appearing in this string, ignoring the case of + ASCII letters. + + The result is true if and only if the second string appears as a substring + of this string, at the given position. + Character values between 65 and 90 (ASCII A-Z) are interpreted as + values between 97 and 122 (ASCII a-z). + This function can't be used for language specific comparison. + + @param str the object (substring) to be compared. + @param fromIndex the index to start the comparion from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return sal_True if str match with the characters in the string + at the given position; + sal_False, otherwise. + */ + sal_Bool matchIgnoreAsciiCase( const OString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + return rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + str.pData->buffer, str.pData->length, + str.pData->length ) == 0; + } + + friend sal_Bool operator == ( const OString& rStr1, const OString& rStr2 ) SAL_THROW(()) + { return rStr1.getLength() == rStr2.getLength() && rStr1.compareTo( rStr2 ) == 0; } + friend sal_Bool operator == ( const OString& rStr1, const sal_Char * pStr2 ) SAL_THROW(()) + { return rStr1.compareTo( pStr2 ) == 0; } + friend sal_Bool operator == ( const sal_Char * pStr1, const OString& rStr2 ) SAL_THROW(()) + { return OString( pStr1 ).compareTo( rStr2 ) == 0; } + + friend sal_Bool operator != ( const OString& rStr1, const OString& rStr2 ) SAL_THROW(()) + { return !(operator == ( rStr1, rStr2 )); } + friend sal_Bool operator != ( const OString& rStr1, const sal_Char * pStr2 ) SAL_THROW(()) + { return !(operator == ( rStr1, pStr2 )); } + friend sal_Bool operator != ( const sal_Char * pStr1, const OString& rStr2 ) SAL_THROW(()) + { return !(operator == ( pStr1, rStr2 )); } + + friend sal_Bool operator < ( const OString& rStr1, const OString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) < 0; } + friend sal_Bool operator > ( const OString& rStr1, const OString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) > 0; } + friend sal_Bool operator <= ( const OString& rStr1, const OString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) <= 0; } + friend sal_Bool operator >= ( const OString& rStr1, const OString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) >= 0; } + + /** + Returns a hashcode for this string. + + @return a hash code value for this object. + + @see rtl::OStringHash for convenient use of STLPort's hash_map + */ + sal_Int32 hashCode() const SAL_THROW(()) + { + return rtl_str_hashCode_WithLength( pData->buffer, pData->length ); + } + + /** + Returns the index within this string of the first occurrence of the + specified character, starting the search at the specified index. + + @param ch character to be located. + @param fromIndex the index to start the search from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return the index of the first occurrence of the character in the + character sequence represented by this string that is + greater than or equal to fromIndex, or + -1 if the character does not occur. + */ + sal_Int32 indexOf( sal_Char ch, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + sal_Int32 ret = rtl_str_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch ); + return (ret < 0 ? ret : ret+fromIndex); + } + + /** + Returns the index within this string of the last occurrence of the + specified character, searching backward starting at the end. + + @param ch character to be located. + @return the index of the last occurrence of the character in the + character sequence represented by this string, or + -1 if the character does not occur. + */ + sal_Int32 lastIndexOf( sal_Char ch ) const SAL_THROW(()) + { + return rtl_str_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch ); + } + + /** + Returns the index within this string of the last occurrence of the + specified character, searching backward starting before the specified + index. + + @param ch character to be located. + @param fromIndex the index before which to start the search. + @return the index of the last occurrence of the character in the + character sequence represented by this string that + is less than fromIndex, or -1 + if the character does not occur before that point. + */ + sal_Int32 lastIndexOf( sal_Char ch, sal_Int32 fromIndex ) const SAL_THROW(()) + { + return rtl_str_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch ); + } + + /** + Returns the index within this string of the first occurrence of the + specified substring, starting at the specified index. + + If str doesn't include any character, always -1 is + returned. This is also the case, if both strings are empty. + + @param str the substring to search for. + @param fromIndex the index to start the search from. + @return If the string argument occurs one or more times as a substring + within this string at the starting index, then the index + of the first character of the first such substring is + returned. If it does not occur as a substring starting + at fromIndex or beyond, -1 is returned. + */ + sal_Int32 indexOf( const OString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + sal_Int32 ret = rtl_str_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + str.pData->buffer, str.pData->length ); + return (ret < 0 ? ret : ret+fromIndex); + } + + /** + Returns the index within this string of the last occurrence of + the specified substring, searching backward starting at the end. + + The returned index indicates the starting index of the substring + in this string. + If str doesn't include any character, always -1 is + returned. This is also the case, if both strings are empty. + + @param str the substring to search for. + @return If the string argument occurs one or more times as a substring + within this string, then the index of the first character of + the last such substring is returned. If it does not occur as + a substring, -1 is returned. + */ + sal_Int32 lastIndexOf( const OString & str ) const SAL_THROW(()) + { + return rtl_str_lastIndexOfStr_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ); + } + + /** + Returns the index within this string of the last occurrence of + the specified substring, searching backward starting before the specified + index. + + The returned index indicates the starting index of the substring + in this string. + If str doesn't include any character, always -1 is + returned. This is also the case, if both strings are empty. + + @param str the substring to search for. + @param fromIndex the index before which to start the search. + @return If the string argument occurs one or more times as a substring + within this string before the starting index, then the index + of the first character of the last such substring is + returned. Otherwise, -1 is returned. + */ + sal_Int32 lastIndexOf( const OString & str, sal_Int32 fromIndex ) const SAL_THROW(()) + { + return rtl_str_lastIndexOfStr_WithLength( pData->buffer, fromIndex, + str.pData->buffer, str.pData->length ); + } + + /** + Returns a new string that is a substring of this string. + + The substring begins at the specified beginIndex. It is an error for + beginIndex to be negative or to be greater than the length of this string. + + @param beginIndex the beginning index, inclusive. + @return the specified substring. + */ + OString copy( sal_Int32 beginIndex ) const SAL_THROW(()) + { + OSL_ASSERT(beginIndex >= 0 && beginIndex <= getLength()); + if ( beginIndex == 0 ) + return *this; + else + { + rtl_String* pNew = 0; + rtl_string_newFromStr_WithLength( &pNew, pData->buffer+beginIndex, getLength()-beginIndex ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + } + + /** + Returns a new string that is a substring of this string. + + The substring begins at the specified beginIndex and contains count + characters. It is an error for either beginIndex or count to be negative, + or for beginIndex + count to be greater than the length of this string. + + @param beginIndex the beginning index, inclusive. + @param count the number of characters. + @return the specified substring. + */ + OString copy( sal_Int32 beginIndex, sal_Int32 count ) const SAL_THROW(()) + { + OSL_ASSERT(beginIndex >= 0 && beginIndex <= getLength() + && count >= 0 && count <= getLength() - beginIndex); + if ( (beginIndex == 0) && (count == getLength()) ) + return *this; + else + { + rtl_String* pNew = 0; + rtl_string_newFromStr_WithLength( &pNew, pData->buffer+beginIndex, count ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + } + + /** + Concatenates the specified string to the end of this string. + + @param str the string that is concatenated to the end + of this string. + @return a string that represents the concatenation of this string + followed by the string argument. + */ + OString concat( const OString & str ) const SAL_THROW(()) + { + rtl_String* pNew = 0; + rtl_string_newConcat( &pNew, pData, str.pData ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + friend OString operator+( const OString & str1, const OString & str2 ) SAL_THROW(()) + { + return str1.concat( str2 ); + } + + /** + Returns a new string resulting from replacing n = count characters + from position index in this string with newStr. + + @param index the replacing index in str. + The index must be greater or equal as 0 and + less or equal as the length of the string. + @param count the count of charcters that will replaced + The count must be greater or equal as 0 and + less or equal as the length of the string minus index. + @param newStr the new substring. + @return the new string. + */ + OString replaceAt( sal_Int32 index, sal_Int32 count, const OString& newStr ) const SAL_THROW(()) + { + rtl_String* pNew = 0; + rtl_string_newReplaceStrAt( &pNew, pData, index, count, newStr.pData ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns a new string resulting from replacing all occurrences of + oldChar in this string with newChar. + + If the character oldChar does not occur in the character sequence + represented by this object, then the string is assigned with + str. + + @param oldChar the old character. + @param newChar the new character. + @return a string derived from this string by replacing every + occurrence of oldChar with newChar. + */ + OString replace( sal_Char oldChar, sal_Char newChar ) const SAL_THROW(()) + { + rtl_String* pNew = 0; + rtl_string_newReplace( &pNew, pData, oldChar, newChar ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Converts from this string all ASCII uppercase characters (65-90) + to ASCII lowercase characters (97-122). + + This function can't be used for language specific conversion. + If the string doesn't contain characters which must be converted, + then the new string is assigned with str. + + @return the string, converted to ASCII lowercase. + */ + OString toAsciiLowerCase() const SAL_THROW(()) + { + rtl_String* pNew = 0; + rtl_string_newToAsciiLowerCase( &pNew, pData ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Converts from this string all ASCII lowercase characters (97-122) + to ASCII uppercase characters (65-90). + + This function can't be used for language specific conversion. + If the string doesn't contain characters which must be converted, + then the new string is assigned with str. + + @return the string, converted to ASCII uppercase. + */ + OString toAsciiUpperCase() const SAL_THROW(()) + { + rtl_String* pNew = 0; + rtl_string_newToAsciiUpperCase( &pNew, pData ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns a new string resulting from removing white space from both ends + of the string. + + All characters that have codes less than or equal to + 32 (the space character) are considered to be white space. + If the string doesn't contain white spaces at both ends, + then the new string is assigned with str. + + @return the string, with white space removed from the front and end. + */ + OString trim() const SAL_THROW(()) + { + rtl_String* pNew = 0; + rtl_string_newTrim( &pNew, pData ); + return OString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns a token in the string. + + Example: + sal_Int32 nIndex = 0; + do + { + ... + OString aToken = aStr.getToken( 0, ';', nIndex ); + ... + } + while ( nIndex >= 0 ); + + @param token the number of the token to return. + @param cTok the character which seperate the tokens. + @param index the position at which the token is searched in the + string. + The index must not be greater thanthe length of the + string. + This param is set to the position of the + next token or to -1, if it is the last token. + @return the token; if either token or index is negative, an empty token + is returned (and index is set to -1) + */ + OString getToken( sal_Int32 token, sal_Char cTok, sal_Int32& index ) const SAL_THROW(()) + { + rtl_String * pNew = 0; + index = rtl_string_getToken( &pNew, pData, token, cTok, index ); + return OString( pNew, (DO_NOT_ACQUIRE *)0 ); + } + + /** + Returns the Boolean value from this string. + + This function can't be used for language specific conversion. + + @return sal_True, if the string is 1 or "True" in any ASCII case. + sal_False in any other case. + */ + sal_Bool toBoolean() const SAL_THROW(()) + { + return rtl_str_toBoolean( pData->buffer ); + } + + /** + Returns the first character from this string. + + @return the first character from this string or 0, if this string + is emptry. + */ + sal_Char toChar() const SAL_THROW(()) + { + return pData->buffer[0]; + } + + /** + Returns the int32 value from this string. + + This function can't be used for language specific conversion. + + @param radix the radix (between 2 and 36) + @return the int32 represented from this string. + 0 if this string represents no number. + */ + sal_Int32 toInt32( sal_Int16 radix = 10 ) const SAL_THROW(()) + { + return rtl_str_toInt32( pData->buffer, radix ); + } + + /** + Returns the int64 value from this string. + + This function can't be used for language specific conversion. + + @param radix the radix (between 2 and 36) + @return the int64 represented from this string. + 0 if this string represents no number. + */ + sal_Int64 toInt64( sal_Int16 radix = 10 ) const SAL_THROW(()) + { + return rtl_str_toInt64( pData->buffer, radix ); + } + + /** + Returns the float value from this string. + + This function can't be used for language specific conversion. + + @return the float represented from this string. + 0.0 if this string represents no number. + */ + float toFloat() const SAL_THROW(()) + { + return rtl_str_toFloat( pData->buffer ); + } + + /** + Returns the double value from this string. + + This function can't be used for language specific conversion. + + @return the double represented from this string. + 0.0 if this string represents no number. + */ + double toDouble() const SAL_THROW(()) + { + return rtl_str_toDouble( pData->buffer ); + } + + /** + Returns the string representation of the sal_Bool argument. + + If the sal_Bool is true, the string "true" is returned. + If the sal_Bool is false, the string "false" is returned. + This function can't be used for language specific conversion. + + @param b a sal_Bool. + @return a string with the string representation of the argument. + */ + static OString valueOf( sal_Bool b ) SAL_THROW(()) + { + sal_Char aBuf[RTL_STR_MAX_VALUEOFBOOLEAN]; + rtl_String* pNewData = 0; + rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfBoolean( aBuf, b ) ); + return OString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the char argument. + + @param c a character. + @return a string with the string representation of the argument. + */ + static OString valueOf( sal_Char c ) SAL_THROW(()) + { + return OString( &c, 1 ); + } + + /** + Returns the string representation of the int argument. + + This function can't be used for language specific conversion. + + @param i a int32. + @param radix the radix (between 2 and 36) + @return a string with the string representation of the argument. + */ + static OString valueOf( sal_Int32 i, sal_Int16 radix = 10 ) SAL_THROW(()) + { + sal_Char aBuf[RTL_STR_MAX_VALUEOFINT32]; + rtl_String* pNewData = 0; + rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfInt32( aBuf, i, radix ) ); + return OString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the long argument. + + This function can't be used for language specific conversion. + + @param ll a int64. + @param radix the radix (between 2 and 36) + @return a string with the string representation of the argument. + */ + static OString valueOf( sal_Int64 ll, sal_Int16 radix = 10 ) SAL_THROW(()) + { + sal_Char aBuf[RTL_STR_MAX_VALUEOFINT64]; + rtl_String* pNewData = 0; + rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfInt64( aBuf, ll, radix ) ); + return OString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the float argument. + + This function can't be used for language specific conversion. + + @param f a float. + @return a string with the string representation of the argument. + */ + static OString valueOf( float f ) SAL_THROW(()) + { + sal_Char aBuf[RTL_STR_MAX_VALUEOFFLOAT]; + rtl_String* pNewData = 0; + rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfFloat( aBuf, f ) ); + return OString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the double argument. + + This function can't be used for language specific conversion. + + @param d a double. + @return a string with the string representation of the argument. + */ + static OString valueOf( double d ) SAL_THROW(()) + { + sal_Char aBuf[RTL_STR_MAX_VALUEOFDOUBLE]; + rtl_String* pNewData = 0; + rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfDouble( aBuf, d ) ); + return OString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } +}; + +/* ======================================================================= */ + +/** A helper to use OStrings with hash maps. + + Instances of this class are unary function objects that can be used as + hash function arguments to STLPort's hash_map and similar constructs. + */ +struct OStringHash +{ + /** Compute a hash code for a string. + + @param rString + a string. + + @return + a hash code for the string. This hash code should not be stored + persistently, as its computation may change in later revisions. + */ + size_t operator()( const rtl::OString& rString ) const + { return (size_t)rString.hashCode(); } +}; + +/* ======================================================================= */ + +} /* Namespace */ + +#endif /* __cplusplus */ + +#endif /* _RTL_STRING_HXX_ */ diff --git a/sal/inc/rtl/tencinfo.h b/sal/inc/rtl/tencinfo.h new file mode 100644 index 000000000000..49c010ebd374 --- /dev/null +++ b/sal/inc/rtl/tencinfo.h @@ -0,0 +1,276 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_TENCINFO_H +#define _RTL_TENCINFO_H + +#ifndef _SAL_TYPES_H +#include <sal/types.h> +#endif +#include <rtl/textenc.h> + +#ifdef __cplusplus +extern "C" { +#endif + +// See rtl_TextEncodingInfo.Flags below for documentation on these values: +#define RTL_TEXTENCODING_INFO_CONTEXT ((sal_uInt32)0x00000001) +#define RTL_TEXTENCODING_INFO_ASCII ((sal_uInt32)0x00000002) +#define RTL_TEXTENCODING_INFO_UNICODE ((sal_uInt32)0x00000004) +#define RTL_TEXTENCODING_INFO_MULTIBYTE ((sal_uInt32)0x00000008) +#define RTL_TEXTENCODING_INFO_R2L ((sal_uInt32)0x00000010) +#define RTL_TEXTENCODING_INFO_7BIT ((sal_uInt32)0x00000020) +#define RTL_TEXTENCODING_INFO_SYMBOL ((sal_uInt32)0x00000040) +#define RTL_TEXTENCODING_INFO_MIME ((sal_uInt32)0x00000080) + +/** Information about a text encoding. + */ +typedef struct _rtl_TextEncodingInfo +{ + /** The size (in bytes) of this structure. Should be 12. + */ + sal_uInt32 StructSize; + + /** The minimum number of bytes needed to encode any character in the + given encoding. + + Can be rather meaningless for encodings that encode global state along + with the characters (e.g., ISO-2022 encodings). + */ + sal_uInt8 MinimumCharSize; + + /** The maximum number of bytes needed to encode any character in the + given encoding. + + Can be rather meaningless for encodings that encode global state along + with the characters (e.g., ISO-2022 encodings). + */ + sal_uInt8 MaximumCharSize; + + /** The average number of bytes needed to encode a character in the given + encoding. + */ + sal_uInt8 AverageCharSize; + + /** An unused byte, for padding. + */ + sal_uInt8 Reserved; + + /** Any combination of the RTL_TEXTENCODING_INFO flags. + + RTL_TEXTENCODING_INFO_CONTEXT: The encoding uses some mechanism (like + state-changing byte sequences) to switch between different modes (e.g., + to encode multiple character repertoires within the same byte ranges). + + Even if an encoding does not have the CONTEXT property, interpretation + of certain byte values within that encoding can depend on context (e.g., + a certain byte value could be either a single-byte character or a + subsequent byte of a multi-byte character). Likewise, the single shift + characters (SS2 and SS3) used by some of the EUC encodings (to denote + that the following bytes constitute a character from another character + repertoire) do not imply that encodings making use of these characters + have the CONTEXT property. Examples of encodings that do have the + CONTEXT property are the ISO-2022 encodings and UTF-7. + + RTL_TEXTENCODING_INFO_ASCII: The encoding is a superset of ASCII. More + specifically, any appearance of a byte in the range 0x20--7F denotes the + corresponding ASCII character (from SPACE to DELETE); in particular, + such a byte cannot be part of a multi-byte character. Note that the + ASCII control codes 0x00--1F are not included here, as they are used for + special purposes in some encodings. + + If an encoding has this property, it is easy to search for occurences of + ASCII characters within strings of this encoding---you do not need to + keep track whether a byte in the range 0x20--7F really represents an + ASCII character or rather is part of some multi-byte character. + + The guarantees when mapping between Unicode and a given encoding with + the ASCII property are as follows: When mapping from Unicode to the + given encoding, U+0020--007F map to 0x20--7F (but there can also be + other Unicode characters mapping into the range 0x20--7F), and when + mapping from the given encoding to Unicode, 0x20--7F map to U+0020--007F + (again, there can also be other characters mapping into the range + U+0020--007F). In particular, this ensures round-trip conversion for + the ASCII range. + + In principle, the ASCII property is orthogonal to the CONTEXT property. + In practice, however, an encoding that has the ASCII property will most + likely not also have the CONTEXT property. + + RTL_TEXTENCODING_INFO_UNICODE: The encoding is based on the Unicode + character repertoire. + + RTL_TEXTENCODING_INFO_MULTIBYTE: A multi-byte encoding. + + RTL_TEXTENCODING_INFO_R2L: An encoding used mainly or exclusively for + languages written from right to left. + + RTL_TEXTENCODING_INFO_7BIT: A 7-bit instead of an 8-bit encoding. + + RTL_TEXTENCODING_INFO_SYMBOL: A (generic) encoding for symbol character + sets. + + RTL_TEXTENCODING_INFO_MIME: The encoding is registered as a MIME + charset. + */ + sal_uInt32 Flags; +} rtl_TextEncodingInfo; + +/** Determine whether a text encoding uses single octets as basic units of + information (and can thus be used with the conversion routines in + rtl/textcvt.h). + + @param nEncoding + Any rtl_TextEncoding value. + + @return + True if the given encoding uses single octets as basic units of + information, false otherwise. + */ +sal_Bool SAL_CALL rtl_isOctetTextEncoding(rtl_TextEncoding nEncoding); + +/** Return information about a text encoding. + + @param eTextEncoding + Any rtl_TextEncoding value. + + @param pEncInfo + Returns information about the given encoding. Must not be null, and the + StructSize member must be set correctly. + + @return + True if information about the given encoding is available, false + otherwise. + */ +sal_Bool SAL_CALL rtl_getTextEncodingInfo( rtl_TextEncoding eTextEncoding, rtl_TextEncodingInfo* pEncInfo ); + +/** Map from a numeric Windows charset to a text encoding. + + @param nWinCharset + Any numeric Windows charset. + + @return + The corresponding rtl_TextEncoding value, or RTL_TEXTENCODING_DONTKNOW if + no mapping is applicable. + */ +rtl_TextEncoding SAL_CALL rtl_getTextEncodingFromWindowsCharset( sal_uInt8 nWinCharset ); + +/** Map from a MIME charset to a text encoding. + + @param pMimeCharset + Any MIME charset string. Must not be null. + + @return + The corresponding rtl_TextEncoding value, or RTL_TEXTENCODING_DONTKNOW if + no mapping is applicable. + */ +rtl_TextEncoding SAL_CALL rtl_getTextEncodingFromMimeCharset( const sal_Char* pMimeCharset ); + +/** Map from a Unix charset to a text encoding. + + @param pMimeCharset + Any Unix charset string. Must not be null. + + @return + The corresponding rtl_TextEncoding value, or RTL_TEXTENCODING_DONTKNOW if + no mapping is applicable. + */ +rtl_TextEncoding SAL_CALL rtl_getTextEncodingFromUnixCharset( const sal_Char* pUnixCharset ); + +/** Map from a text encoding to the best matching numeric Windows charset. + + @param eTextEncoding + Any rtl_TextEncoding value. + + @return + The best matching numeric Windows charset, or 1 if none matches. + */ +sal_uInt8 SAL_CALL rtl_getBestWindowsCharsetFromTextEncoding( rtl_TextEncoding eTextEncoding ); + +/** Map from a text encoding to a corresponding MIME charset name, if + available (see <http://www.iana.org/assignments/character-sets>). + + @param nEncoding + Any rtl_TextEncoding value. + + @return + The (preferred) MIME charset name corresponding to the given encoding, or + NULL if none is available. + */ +char const * SAL_CALL rtl_getMimeCharsetFromTextEncoding(rtl_TextEncoding + nEncoding); + +/** Map from a text encoding to the best matching MIME charset. + + @param eTextEncoding + Any rtl_TextEncoding value. + + @return + The best matching MIME charset string, or null if none matches. + */ +const sal_Char* SAL_CALL rtl_getBestMimeCharsetFromTextEncoding( rtl_TextEncoding eTextEncoding ); + +/** Map from a text encoding to the best matching Unix charset. + + @param eTextEncoding + Any rtl_TextEncoding value. + + @return + The best matching Unix charset string, or null if none matches. + */ +const sal_Char* SAL_CALL rtl_getBestUnixCharsetFromTextEncoding( rtl_TextEncoding eTextEncoding ); + +/** Map from a Windows code page to a text encoding. + + @param nCodePage + Any Windows code page number. + + @return + The corresponding rtl_TextEncoding value (which will be an octet text + encoding, see rtl_isOctetTextEncoding), or RTL_TEXTENCODING_DONTKNOW if no + mapping is applicable. + */ +rtl_TextEncoding SAL_CALL +rtl_getTextEncodingFromWindowsCodePage(sal_uInt32 nCodePage); + +/** Map from a text encoding to a Windows code page. + + @param nEncoding + Any rtl_TextEncoding value. + + @return + The corresponding Windows code page number, or 0 if no mapping is + applicable. + */ +sal_uInt32 SAL_CALL +rtl_getWindowsCodePageFromTextEncoding(rtl_TextEncoding nEncoding); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_TENCINFO_H */ diff --git a/sal/inc/rtl/textcvt.h b/sal/inc/rtl/textcvt.h new file mode 100644 index 000000000000..b22813daf754 --- /dev/null +++ b/sal/inc/rtl/textcvt.h @@ -0,0 +1,180 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_TEXTCVT_H +#define _RTL_TEXTCVT_H + +#ifndef _SAL_TYPES_H +#include <sal/types.h> +#endif +#include <rtl/textenc.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* Documentation about this file can be found at + <http://udk.openoffice.org/cpp/man/spec/textconversion.html>. */ + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +typedef void* rtl_TextToUnicodeConverter; + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +typedef void* rtl_TextToUnicodeContext; + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +rtl_TextToUnicodeConverter SAL_CALL rtl_createTextToUnicodeConverter( rtl_TextEncoding eTextEncoding ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +void SAL_CALL rtl_destroyTextToUnicodeConverter( rtl_TextToUnicodeConverter hConverter ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +rtl_TextToUnicodeContext SAL_CALL rtl_createTextToUnicodeContext( rtl_TextToUnicodeConverter hConverter ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +void SAL_CALL rtl_destroyTextToUnicodeContext( rtl_TextToUnicodeConverter hConverter, rtl_TextToUnicodeContext hContext ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +void SAL_CALL rtl_resetTextToUnicodeContext( rtl_TextToUnicodeConverter hConverter, rtl_TextToUnicodeContext hContext ); + +#define RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR ((sal_uInt32)0x0001) +#define RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_IGNORE ((sal_uInt32)0x0002) +#define RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE ((sal_uInt32)0x0003) +#define RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT ((sal_uInt32)0x0004) +#define RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR ((sal_uInt32)0x0010) +#define RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_IGNORE ((sal_uInt32)0x0020) +#define RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT ((sal_uInt32)0x0030) +#define RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR ((sal_uInt32)0x0100) +#define RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE ((sal_uInt32)0x0200) +#define RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT ((sal_uInt32)0x0300) +#define RTL_TEXTTOUNICODE_FLAGS_FLUSH ((sal_uInt32)0x8000) +#define RTL_TEXTTOUNICODE_FLAGS_GLOBAL_SIGNATURE 0x10000 + /* Accept any global document signatures (for example, in UTF-8, a leading + EF BB BF encoding the Byte Order Mark U+FEFF) */ + +#define RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MASK ((sal_uInt32)0x000F) +#define RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_MASK ((sal_uInt32)0x00F0) +#define RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK ((sal_uInt32)0x0F00) + +#define RTL_TEXTTOUNICODE_INFO_ERROR ((sal_uInt32)0x0001) +#define RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL ((sal_uInt32)0x0002) +#define RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL ((sal_uInt32)0x0004) +#define RTL_TEXTTOUNICODE_INFO_UNDEFINED ((sal_uInt32)0x0008) +#define RTL_TEXTTOUNICODE_INFO_MBUNDEFINED ((sal_uInt32)0x0010) +#define RTL_TEXTTOUNICODE_INFO_INVALID ((sal_uInt32)0x0020) + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +sal_Size SAL_CALL rtl_convertTextToUnicode( rtl_TextToUnicodeConverter hConverter, + rtl_TextToUnicodeContext hContext, + const sal_Char* pSrcBuf, sal_Size nSrcBytes, + sal_Unicode* pDestBuf, sal_Size nDestChars, + sal_uInt32 nFlags, sal_uInt32* pInfo, + sal_Size* pSrcCvtBytes ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +typedef void* rtl_UnicodeToTextConverter; + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +typedef void* rtl_UnicodeToTextContext; + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +rtl_UnicodeToTextConverter SAL_CALL rtl_createUnicodeToTextConverter( rtl_TextEncoding eTextEncoding ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +void SAL_CALL rtl_destroyUnicodeToTextConverter( rtl_UnicodeToTextConverter hConverter ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +rtl_UnicodeToTextContext SAL_CALL rtl_createUnicodeToTextContext( rtl_UnicodeToTextConverter hConverter ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +void SAL_CALL rtl_destroyUnicodeToTextContext( rtl_UnicodeToTextConverter hConverter, rtl_UnicodeToTextContext hContext ); + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +void SAL_CALL rtl_resetUnicodeToTextContext( rtl_UnicodeToTextConverter hConverter, rtl_UnicodeToTextContext hContext ); + +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR ((sal_uInt32)0x0001) +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_IGNORE ((sal_uInt32)0x0002) +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_0 ((sal_uInt32)0x0003) +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_QUESTIONMARK ((sal_uInt32)0x0004) +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_UNDERLINE ((sal_uInt32)0x0005) +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT ((sal_uInt32)0x0006) +#define RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR ((sal_uInt32)0x0010) +#define RTL_UNICODETOTEXT_FLAGS_INVALID_IGNORE ((sal_uInt32)0x0020) +#define RTL_UNICODETOTEXT_FLAGS_INVALID_0 ((sal_uInt32)0x0030) +#define RTL_UNICODETOTEXT_FLAGS_INVALID_QUESTIONMARK ((sal_uInt32)0x0040) +#define RTL_UNICODETOTEXT_FLAGS_INVALID_UNDERLINE ((sal_uInt32)0x0050) +#define RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT ((sal_uInt32)0x0060) +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE ((sal_uInt32)0x0100) +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR ((sal_uInt32)0x0200) +#define RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 ((sal_uInt32)0x0400) +#define RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE ((sal_uInt32)0x0800) +#define RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE ((sal_uInt32)0x1000) +#define RTL_UNICODETOTEXT_FLAGS_PRIVATE_IGNORE ((sal_uInt32)0x2000) +#define RTL_UNICODETOTEXT_FLAGS_NOCOMPOSITE ((sal_uInt32)0x4000) +#define RTL_UNICODETOTEXT_FLAGS_FLUSH ((sal_uInt32)0x8000) +#define RTL_UNICODETOTEXT_FLAGS_GLOBAL_SIGNATURE 0x10000 + /* Write any global document signatures (for example, in UTF-8, a leading + EF BB BF encoding the Byte Order Mark U+FEFF) */ + +#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_MASK ((sal_uInt32)0x000F) +#define RTL_UNICODETOTEXT_FLAGS_INVALID_MASK ((sal_uInt32)0x00F0) + +#define RTL_UNICODETOTEXT_INFO_ERROR ((sal_uInt32)0x0001) +#define RTL_UNICODETOTEXT_INFO_SRCBUFFERTOSMALL ((sal_uInt32)0x0002) +#define RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL ((sal_uInt32)0x0004) +#define RTL_UNICODETOTEXT_INFO_UNDEFINED ((sal_uInt32)0x0008) +#define RTL_UNICODETOTEXT_INFO_INVALID ((sal_uInt32)0x0010) + +/** see http://udk.openoffice.org/cpp/man/spec/textconversion.html + */ +sal_Size SAL_CALL rtl_convertUnicodeToText( rtl_UnicodeToTextConverter hConverter, + rtl_UnicodeToTextContext hContext, + const sal_Unicode* pSrcBuf, sal_Size nSrcChars, + sal_Char* pDestBuf, sal_Size nDestBytes, + sal_uInt32 nFlags, sal_uInt32* pInfo, + sal_Size* pSrcCvtChars ); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_TEXTCVT_H */ diff --git a/sal/inc/rtl/textenc.h b/sal/inc/rtl/textenc.h new file mode 100644 index 000000000000..6b0b67e3c8ab --- /dev/null +++ b/sal/inc/rtl/textenc.h @@ -0,0 +1,279 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_TEXTENC_H +#define _RTL_TEXTENC_H + +#ifdef _SOLAR_RSC_INVOKED +/* Enable resources to use these values, rsc can't handle casts */ +#define RTL_TEXTENC_CAST( val ) (val) + +#else /* !_SOLAR_RSC_INVOKED */ + +#ifndef _SAL_TYPES_H +#include <sal/types.h> +#endif + +/** The various supported text encodings. + + Possible values include a wide range of single- and multi-byte encodings + (ranging from RTL_TEXTENCODING_MS_1252 to RTL_TEXTENCODING_GB_18030), + the ISO 10646 (Unicode) specific encodings RTL_TEXTENCODING_UCS4 and + RTL_TEXTENCODING_UCS2 (aka RTL_TEXTENCODING_UNICODE), and + RTL_TEXTENCODING_DONTKNOW to indicate an unknown or missing encoding. + */ +typedef sal_uInt16 rtl_TextEncoding; + +#define RTL_TEXTENC_CAST( val ) ((rtl_TextEncoding) val) + +#endif /* _SOLAR_RSC_INVOKED */ + +#define RTL_TEXTENCODING_DONTKNOW (RTL_TEXTENC_CAST( 0 )) +#define RTL_TEXTENCODING_MS_1252 (RTL_TEXTENC_CAST( 1 )) +#define RTL_TEXTENCODING_APPLE_ROMAN (RTL_TEXTENC_CAST( 2 )) +#define RTL_TEXTENCODING_IBM_437 (RTL_TEXTENC_CAST( 3 )) +#define RTL_TEXTENCODING_IBM_850 (RTL_TEXTENC_CAST( 4 )) +#define RTL_TEXTENCODING_IBM_860 (RTL_TEXTENC_CAST( 5 )) +#define RTL_TEXTENCODING_IBM_861 (RTL_TEXTENC_CAST( 6 )) +#define RTL_TEXTENCODING_IBM_863 (RTL_TEXTENC_CAST( 7 )) +#define RTL_TEXTENCODING_IBM_865 (RTL_TEXTENC_CAST( 8 )) +/* Reserved: RTL_TEXTENCODING_SYSTEM (RTL_TEXTENC_CAST( 9 )) */ +#define RTL_TEXTENCODING_SYMBOL (RTL_TEXTENC_CAST( 10 )) +#define RTL_TEXTENCODING_ASCII_US (RTL_TEXTENC_CAST( 11 )) +#define RTL_TEXTENCODING_ISO_8859_1 (RTL_TEXTENC_CAST( 12 )) +#define RTL_TEXTENCODING_ISO_8859_2 (RTL_TEXTENC_CAST( 13 )) +#define RTL_TEXTENCODING_ISO_8859_3 (RTL_TEXTENC_CAST( 14 )) +#define RTL_TEXTENCODING_ISO_8859_4 (RTL_TEXTENC_CAST( 15 )) +#define RTL_TEXTENCODING_ISO_8859_5 (RTL_TEXTENC_CAST( 16 )) +#define RTL_TEXTENCODING_ISO_8859_6 (RTL_TEXTENC_CAST( 17 )) +#define RTL_TEXTENCODING_ISO_8859_7 (RTL_TEXTENC_CAST( 18 )) +#define RTL_TEXTENCODING_ISO_8859_8 (RTL_TEXTENC_CAST( 19 )) +#define RTL_TEXTENCODING_ISO_8859_9 (RTL_TEXTENC_CAST( 20 )) +#define RTL_TEXTENCODING_ISO_8859_14 (RTL_TEXTENC_CAST( 21 )) +#define RTL_TEXTENCODING_ISO_8859_15 (RTL_TEXTENC_CAST( 22 )) +#define RTL_TEXTENCODING_IBM_737 (RTL_TEXTENC_CAST( 23 )) +#define RTL_TEXTENCODING_IBM_775 (RTL_TEXTENC_CAST( 24 )) +#define RTL_TEXTENCODING_IBM_852 (RTL_TEXTENC_CAST( 25 )) +#define RTL_TEXTENCODING_IBM_855 (RTL_TEXTENC_CAST( 26 )) +#define RTL_TEXTENCODING_IBM_857 (RTL_TEXTENC_CAST( 27 )) +#define RTL_TEXTENCODING_IBM_862 (RTL_TEXTENC_CAST( 28 )) +#define RTL_TEXTENCODING_IBM_864 (RTL_TEXTENC_CAST( 29 )) +#define RTL_TEXTENCODING_IBM_866 (RTL_TEXTENC_CAST( 30 )) +#define RTL_TEXTENCODING_IBM_869 (RTL_TEXTENC_CAST( 31 )) +#define RTL_TEXTENCODING_MS_874 (RTL_TEXTENC_CAST( 32 )) +#define RTL_TEXTENCODING_MS_1250 (RTL_TEXTENC_CAST( 33 )) +#define RTL_TEXTENCODING_MS_1251 (RTL_TEXTENC_CAST( 34 )) +#define RTL_TEXTENCODING_MS_1253 (RTL_TEXTENC_CAST( 35 )) +#define RTL_TEXTENCODING_MS_1254 (RTL_TEXTENC_CAST( 36 )) +#define RTL_TEXTENCODING_MS_1255 (RTL_TEXTENC_CAST( 37 )) +#define RTL_TEXTENCODING_MS_1256 (RTL_TEXTENC_CAST( 38 )) +#define RTL_TEXTENCODING_MS_1257 (RTL_TEXTENC_CAST( 39 )) +#define RTL_TEXTENCODING_MS_1258 (RTL_TEXTENC_CAST( 40 )) +#define RTL_TEXTENCODING_APPLE_ARABIC (RTL_TEXTENC_CAST( 41 )) +#define RTL_TEXTENCODING_APPLE_CENTEURO (RTL_TEXTENC_CAST( 42 )) +#define RTL_TEXTENCODING_APPLE_CROATIAN (RTL_TEXTENC_CAST( 43 )) +#define RTL_TEXTENCODING_APPLE_CYRILLIC (RTL_TEXTENC_CAST( 44 )) +#define RTL_TEXTENCODING_APPLE_DEVANAGARI (RTL_TEXTENC_CAST( 45 )) +#define RTL_TEXTENCODING_APPLE_FARSI (RTL_TEXTENC_CAST( 46 )) +#define RTL_TEXTENCODING_APPLE_GREEK (RTL_TEXTENC_CAST( 47 )) +#define RTL_TEXTENCODING_APPLE_GUJARATI (RTL_TEXTENC_CAST( 48 )) +#define RTL_TEXTENCODING_APPLE_GURMUKHI (RTL_TEXTENC_CAST( 49 )) +#define RTL_TEXTENCODING_APPLE_HEBREW (RTL_TEXTENC_CAST( 50 )) +#define RTL_TEXTENCODING_APPLE_ICELAND (RTL_TEXTENC_CAST( 51 )) +#define RTL_TEXTENCODING_APPLE_ROMANIAN (RTL_TEXTENC_CAST( 52 )) +#define RTL_TEXTENCODING_APPLE_THAI (RTL_TEXTENC_CAST( 53 )) +#define RTL_TEXTENCODING_APPLE_TURKISH (RTL_TEXTENC_CAST( 54 )) +#define RTL_TEXTENCODING_APPLE_UKRAINIAN (RTL_TEXTENC_CAST( 55 )) +#define RTL_TEXTENCODING_APPLE_CHINSIMP (RTL_TEXTENC_CAST( 56 )) +#define RTL_TEXTENCODING_APPLE_CHINTRAD (RTL_TEXTENC_CAST( 57 )) +#define RTL_TEXTENCODING_APPLE_JAPANESE (RTL_TEXTENC_CAST( 58 )) +#define RTL_TEXTENCODING_APPLE_KOREAN (RTL_TEXTENC_CAST( 59 )) +#define RTL_TEXTENCODING_MS_932 (RTL_TEXTENC_CAST( 60 )) +#define RTL_TEXTENCODING_MS_936 (RTL_TEXTENC_CAST( 61 )) +#define RTL_TEXTENCODING_MS_949 (RTL_TEXTENC_CAST( 62 )) +#define RTL_TEXTENCODING_MS_950 (RTL_TEXTENC_CAST( 63 )) +#define RTL_TEXTENCODING_SHIFT_JIS (RTL_TEXTENC_CAST( 64 )) +#define RTL_TEXTENCODING_GB_2312 (RTL_TEXTENC_CAST( 65 )) +#define RTL_TEXTENCODING_GBT_12345 (RTL_TEXTENC_CAST( 66 )) +#define RTL_TEXTENCODING_GBK (RTL_TEXTENC_CAST( 67 )) +#define RTL_TEXTENCODING_BIG5 (RTL_TEXTENC_CAST( 68 )) +#define RTL_TEXTENCODING_EUC_JP (RTL_TEXTENC_CAST( 69 )) +#define RTL_TEXTENCODING_EUC_CN (RTL_TEXTENC_CAST( 70 )) +#define RTL_TEXTENCODING_EUC_TW (RTL_TEXTENC_CAST( 71 )) +#define RTL_TEXTENCODING_ISO_2022_JP (RTL_TEXTENC_CAST( 72 )) +#define RTL_TEXTENCODING_ISO_2022_CN (RTL_TEXTENC_CAST( 73 )) +#define RTL_TEXTENCODING_KOI8_R (RTL_TEXTENC_CAST( 74 )) +#define RTL_TEXTENCODING_UTF7 (RTL_TEXTENC_CAST( 75 )) +#define RTL_TEXTENCODING_UTF8 (RTL_TEXTENC_CAST( 76 )) +#define RTL_TEXTENCODING_ISO_8859_10 (RTL_TEXTENC_CAST( 77 )) +#define RTL_TEXTENCODING_ISO_8859_13 (RTL_TEXTENC_CAST( 78 )) +#define RTL_TEXTENCODING_EUC_KR (RTL_TEXTENC_CAST( 79 )) +#define RTL_TEXTENCODING_ISO_2022_KR (RTL_TEXTENC_CAST( 80 )) +#define RTL_TEXTENCODING_JIS_X_0201 (RTL_TEXTENC_CAST( 81 )) +#define RTL_TEXTENCODING_JIS_X_0208 (RTL_TEXTENC_CAST( 82 )) +#define RTL_TEXTENCODING_JIS_X_0212 (RTL_TEXTENC_CAST( 83 )) +#define RTL_TEXTENCODING_MS_1361 (RTL_TEXTENC_CAST( 84 )) +#define RTL_TEXTENCODING_GB_18030 (RTL_TEXTENC_CAST( 85 )) +#define RTL_TEXTENCODING_BIG5_HKSCS (RTL_TEXTENC_CAST( 86 )) +#define RTL_TEXTENCODING_TIS_620 (RTL_TEXTENC_CAST( 87 )) +#define RTL_TEXTENCODING_KOI8_U (RTL_TEXTENC_CAST( 88 )) +#define RTL_TEXTENCODING_ISCII_DEVANAGARI (RTL_TEXTENC_CAST( 89 )) +#define RTL_TEXTENCODING_JAVA_UTF8 (RTL_TEXTENC_CAST( 90 )) +#define RTL_TEXTENCODING_ADOBE_STANDARD (RTL_TEXTENC_CAST( 91 )) +#define RTL_TEXTENCODING_ADOBE_SYMBOL (RTL_TEXTENC_CAST( 92 )) +#define RTL_TEXTENCODING_PT154 (RTL_TEXTENC_CAST( 93 )) +#define RTL_TEXTENCODING_ADOBE_DINGBATS (RTL_TEXTENC_CAST( 94 )) +/* ATTENTION! Whenever some encoding is added here, make sure to update + * rtl_isOctetTextEncoding in tencinfo.c. + */ + +#define RTL_TEXTENCODING_USER_START (RTL_TEXTENC_CAST( 0x8000 )) +#define RTL_TEXTENCODING_USER_END (RTL_TEXTENC_CAST( 0xEFFF )) + +#define RTL_TEXTENCODING_UCS4 (RTL_TEXTENC_CAST( 0xFFFE )) +#define RTL_TEXTENCODING_UCS2 (RTL_TEXTENC_CAST( 0xFFFF )) +#define RTL_TEXTENCODING_UNICODE RTL_TEXTENCODING_UCS2 + +/****** Overview over the TextEncodings ***** +# Arabic (Apple Macintosh) RTL_TEXTENCODING_APPLE_ARABIC +Arabic (DOS/OS2-864) RTL_TEXTENCODING_IBM_864 +Arabic (ISO-8859-6) RTL_TEXTENCODING_ISO_8859_6 +Arabic (Windows-1256) RTL_TEXTENCODING_MS_1256 + +Baltic (DOS/OS2-775) RTL_TEXTENCODING_IBM_775 +Baltic (ISO-8859-4) RTL_TEXTENCODING_ISO_8859_4 +Baltic (Windows-1257) RTL_TEXTENCODING_MS_1257 + +Central European (Apple Macintosh) RTL_TEXTENCODING_APPLE_CENTEURO +Central European (Apple Macintosh/Croatian) RTL_TEXTENCODING_APPLE_CROATIAN +Central European (Apple Macintosh/Romanian) RTL_TEXTENCODING_APPLE_ROMANIAN +Central European (DOS/OS2-852) RTL_TEXTENCODING_IBM_852 +Central European (ISO-8859-2) RTL_TEXTENCODING_ISO_8859_2 +Central European (ISO-8859-10) RTL_TEXTENCODING_ISO_8859_10 +Central European (ISO-8859-13) RTL_TEXTENCODING_ISO_8859_13 +Central European (Windows-1250/WinLatin 2) RTL_TEXTENCODING_MS_1250 + +Chinese Simplified (Apple Macintosh) RTL_TEXTENCODING_APPLE_CHINSIMP +Chinese Simplified (EUC-CN) RTL_TEXTENCODING_EUC_CN +Chinese Simplified (GB-2312) RTL_TEXTENCODING_GB_2312 +Chinese Simplified (GBK/GB-2312-80) RTL_TEXTENCODING_GBK +# Chinese Simplified (ISO-2022-CN) RTL_TEXTENCODING_ISO_2022_CN +Chinese Simplified (Windows-936) RTL_TEXTENCODING_MS_936 +# Chinese Simplified (GB-18030) RTL_TEXTENCODING_GB_18030 + +Chinese Traditional (Apple Macintosh) RTL_TEXTENCODING_APPLE_CHINTRAD +Chinese Traditional (BIG5) RTL_TEXTENCODING_BIG5 +# Chinese Traditional (EUC-TW) RTL_TEXTENCODING_EUC_TW +Chinese Traditional (GBT-12345) RTL_TEXTENCODING_GBT_12345 +Chinese Traditional (Windows-950) RTL_TEXTENCODING_MS_950 +Chinese Traditional (BIG5-HKSCS) RTL_TEXTENCODING_BIG5_HKSCS + +Cyrillic (Apple Macintosh) RTL_TEXTENCODING_APPLE_CYRILLIC +Cyrillic (Apple Macintosh/Ukrainian) RTL_TEXTENCODING_APPLE_UKRAINIAN +Cyrillic (DOS/OS2-855) RTL_TEXTENCODING_IBM_855 +Cyrillic (DOS/OS2-866/Russian) RTL_TEXTENCODING_IBM_866 +Cyrillic (ISO-8859-5) RTL_TEXTENCODING_ISO_8859_5 +Cyrillic (KOI8-R) RTL_TEXTENCODING_KOI8_R +Cyrillic (KOI8-U) RTL_TEXTENCODING_KOI8_U +Cyrillic (Windows-1251) RTL_TEXTENCODING_MS_1251 + +Greek (Apple Macintosh) RTL_TEXTENCODING_APPLE_GREEK +Greek (DOS/OS2-737) RTL_TEXTENCODING_IBM_737 +Greek (DOS/OS2-869/Modern) RTL_TEXTENCODING_IBM_869 +Greek (ISO-8859-7) RTL_TEXTENCODING_ISO_8859_7 +Greek (Windows-1253) RTL_TEXTENCODING_MS_1253 + +# Hebrew (Apple Macintosh) RTL_TEXTENCODING_APPLE_HEBREW +Hebrew (DOS/OS2-862) RTL_TEXTENCODING_IBM_862 +Hebrew (ISO-8859-8) RTL_TEXTENCODING_ISO_8859_8 +Hebrew (Windows-1255) RTL_TEXTENCODING_MS_1255 + +Korean (Apple Macintosh) RTL_TEXTENCODING_APPLE_KOREAN +Korean (EUC-KR) RTL_TEXTENCODING_EUC_KR +# Korean (ISO-2022-KR) RTL_TEXTENCODING_ISO_2022_KR +Korean (Windows-Wansung-949) RTL_TEXTENCODING_MS_949 +Korean (Windows-Johab-1361) RTL_TEXTENCODING_MS_1361 + +Latin 3 (ISO-8859-3) RTL_TEXTENCODING_ISO_8859_3 + +Indian (ISCII Devanagari) RTL_TEXTENCODING_ISCII_DEVANAGARI + +Japanese (Apple Macintosh) RTL_TEXTENCODING_APPLE_JAPANESE +Japanese (EUC-JP) RTL_TEXTENCODING_EUC_JP +# Japanese (ISO-2022-JP) RTL_TEXTENCODING_ISO_2022_JP +Japanese (Shift-JIS) RTL_TEXTENCODING_SHIFT_JIS +Japanese (Windows-932) RTL_TEXTENCODING_MS_932 + +Symbol RTL_TEXTENCODING_SYMBOL + +# Thai (Apple Macintosh) RTL_TEXTENCODING_APPLE_THAI +Thai (Dos/Windows-874) RTL_TEXTENCODING_MS_874 +Thai (TIS 620) RTL_TEXTENCODING_TIS_620 + +Turkish (Apple Macintosh) RTL_TEXTENCODING_APPLE_TURKISH +Turkish (DOS/OS2-857) RTL_TEXTENCODING_IBM_857 +Turkish (ISO-8859-9) RTL_TEXTENCODING_ISO_8859_9 +Turkish (Windows-1254) RTL_TEXTENCODING_MS_1254 + +Unicode (UTF-7) RTL_TEXTENCODING_UTF7 +Unicode (UTF-8) RTL_TEXTENCODING_UTF8 +Unicode (Java's modified UTF-8) RTL_TEXTENCODING_JAVA_UTF8 + +Vietnamese (Windows-1258) RTL_TEXTENCODING_MS_1258 + +Western (Apple Macintosh) RTL_TEXTENCODING_APPLE_ROMAN +Western (Apple Macintosh/Icelandic) RTL_TEXTENCODING_APPLE_ICELAND +Western (ASCII/US) RTL_TEXTENCODING_ASCII_US +Western (DOS/OS2-437/US) RTL_TEXTENCODING_IBM_437 +Western (DOS/OS2-850/International) RTL_TEXTENCODING_IBM_850 +Western (DOS/OS2-860/Portugese) RTL_TEXTENCODING_IBM_860 +Western (DOS/OS2-861/Icelandic) RTL_TEXTENCODING_IBM_861 +Western (DOS/OS2-863/Canadian-French) RTL_TEXTENCODING_IBM_863 +Western (DOS/OS2-865/Nordic) RTL_TEXTENCODING_IBM_865 +Western (ISO-8859-1) RTL_TEXTENCODING_ISO_8859_1 +Western (ISO-8859-14) RTL_TEXTENCODING_ISO_8859_14 +Western (ISO-8859-15/EURO) RTL_TEXTENCODING_ISO_8859_15 +Western (Window-1252/WinLatin 1) RTL_TEXTENCODING_MS_1252 + +Not known and currently not supported +# RTL_TEXTENCODING_APPLE_DEVANAGARI +# RTL_TEXTENCODING_APPLE_FARSI +# RTL_TEXTENCODING_APPLE_GUJARATI +# RTL_TEXTENCODING_APPLE_GURMUKHI + +Only for internal implementations and not useful for user interface. +These encodings are not used for text encodings, only used for +font-/textoutput encodings. +Japanese (JIS 0201) RTL_TEXTENCODING_JISX_0201 +Japanese (JIS 0208) RTL_TEXTENCODING_JISX_0208 +Japanese (JIS 0212) RTL_TEXTENCODING_JISX_0212 + +# Currently not implemented +*/ + +#endif /* _RTL_TEXTENC_H */ + diff --git a/sal/inc/rtl/tres.h b/sal/inc/rtl/tres.h new file mode 100644 index 000000000000..9535d0b2adc2 --- /dev/null +++ b/sal/inc/rtl/tres.h @@ -0,0 +1,106 @@ +#ifndef _RTL_TRES_H_ +#define _RTL_TRES_H_ + +#include <osl/diagnose.h> +#include <rtl/string.h> + +#ifdef __cplusplus +extern "C" { +#endif + + /* comandline flags */ +#define rtl_tres_Flag_BOOM 0x00000001 +#define rtl_tres_Flag_VERBOSE 0x00000002 +#define rtl_tres_Flag_SKIP 0x00000004 +#define rtl_tres_Flag_LOG 0x00000010 +#define rtl_tres_Flag_HIS 0x00000100 +#define rtl_tres_Flag_TIME 0x00000200 +#define rtl_tres_Flag_MSG 0x00000400 +#define rtl_tres_Flag_QUIET 0x00000800 + + /* state flags */ +#define rtl_tres_Flag_SUB 0x01000000 +#define rtl_tres_Flag_PASSED 0x10000000 +#define rtl_tres_Flag_OK 0x20000000 + + + + /* forward declaration and type definition */ +struct _rtl_TestResult; +typedef struct _rtl_TestResult rtl_TestResult; + + +typedef void* rtl_funcstate; +typedef void* rtl_cmpstate; + + /* type definitions of function pointers wich can be overloaded */ +typedef sal_Bool (SAL_CALL *rtl_tres_state_ptr)( + rtl_TestResult*, + sal_Bool, + const sal_Char*, + const sal_Char*, + sal_Bool + ); + +typedef void (SAL_CALL *rtl_tres_end_ptr)( rtl_TestResult*, const sal_Char* ); +typedef sal_Bool (SAL_CALL *rtl_tres_ispassed_ptr)( rtl_TestResult* ); +typedef sal_Bool (SAL_CALL *rtl_tres_isok_ptr)( rtl_TestResult* ); +typedef rtl_funcstate (SAL_CALL *rtl_tres_funcstate_ptr)( rtl_TestResult* ); +typedef sal_Bool (SAL_CALL *rtl_tres_isbit_ptr)( rtl_TestResult*, + sal_uInt32 ); + +typedef rtl_funcstate (SAL_CALL *rtl_tres_getnextfuncstate_ptr) + ( rtl_funcstate ); +typedef rtl_funcstate (SAL_CALL *rtl_tres_getprevfuncstate_ptr) + ( rtl_funcstate ); +typedef sal_uInt32 (SAL_CALL *rtl_tres_getflags_ptr)( rtl_funcstate ); +typedef rtl_String* (SAL_CALL *rtl_tres_getname_ptr)( rtl_funcstate ); +typedef sal_uInt32 (SAL_CALL *rtl_tres_getstart_ptr)( rtl_funcstate ); +typedef sal_uInt32 (SAL_CALL *rtl_tres_getstop_ptr)( rtl_funcstate ); +typedef rtl_cmpstate (SAL_CALL *rtl_tres_getcmpstate_ptr)( rtl_funcstate ); + +typedef sal_Bool (SAL_CALL *rtl_tres_getstat_ptr)( rtl_cmpstate ); +typedef rtl_String* (SAL_CALL *rtl_tres_getmsg_ptr)( rtl_cmpstate ); +typedef rtl_cmpstate (SAL_CALL *rtl_tres_getnextcmpstate_ptr)( rtl_cmpstate ); + + /* type definition of vtable structure for testresult */ +typedef struct _rtl_TestResult_vtable +{ + sal_uInt32 vtablesize; + rtl_tres_state_ptr state_; + rtl_tres_end_ptr end_; + rtl_tres_ispassed_ptr ispassed; + rtl_tres_isok_ptr isok; + rtl_tres_funcstate_ptr funcstate; + rtl_tres_isbit_ptr isbit; + rtl_tres_getnextfuncstate_ptr nextfuncstate; + rtl_tres_getprevfuncstate_ptr prevfuncstate; + rtl_tres_getflags_ptr flags; + rtl_tres_getname_ptr name; + rtl_tres_getstart_ptr start; + rtl_tres_getstop_ptr stop; + rtl_tres_getcmpstate_ptr cmpstate; + rtl_tres_getstat_ptr stat; + rtl_tres_getmsg_ptr msg; + rtl_tres_getnextcmpstate_ptr nextcmpstate; + +} rtl_TestResult_vtable; + + /* type definition of testresult structure */ +struct _rtl_TestResult +{ + rtl_TestResult_vtable * pFuncs; + void * pExternalData; + +}; + + + /* exports */ +rtl_TestResult* SAL_CALL rtl_tres_create( const sal_Char* meth, sal_uInt32 flags ); +void SAL_CALL rtl_tres_destroy( rtl_TestResult* res ); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_TRES_H_ */ diff --git a/sal/inc/rtl/tres.hxx b/sal/inc/rtl/tres.hxx new file mode 100644 index 000000000000..6fcd5b7c61e7 --- /dev/null +++ b/sal/inc/rtl/tres.hxx @@ -0,0 +1,112 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_TRES_HXX_ +#define _RTL_TRES_HXX_ + + +#include <rtl/tres.h> + +//#include <stdarg.h> + +// <namespace_rtl> +namespace rtl +{ +/*==========================================================================*/ + +// <class_TestResult> +class TestResult +{ + // pointer to testresult structure + rtl_TestResult* pData; + + // <private_ctors> + TestResult(); + TestResult( const TestResult& oRes ); + // </private_ctors> + +public: + + + // <public_ctors> + TestResult( const sal_Char* meth, sal_uInt32 flags = 0 ) + { + pData = rtl_tres_create( meth, flags ); + } // </public_ctors> + + // <dtor> + ~TestResult() + { + rtl_tres_destroy( pData ); + } + // </dtor> + + // <public_methods> + rtl_TestResult* getData() + { + return pData; + } + // <method_state> + sal_Bool state( + sal_Bool tst_state, + const sal_Char* msg = 0, + const sal_Char* sub = 0, + sal_Bool verbose = sal_False + ) + { + return pData->pFuncs->state_( pData, tst_state, msg, sub, verbose ); + } // </method_state> + + void end( sal_Char* msg = 0 ) + { + pData->pFuncs->end_( pData, msg ); + } // </method_state> +}; // </class_TestResult> + +} // </namespace_rtl> +#endif + + + + + + + + + + + + + + + + + + + + + diff --git a/sal/inc/rtl/unload.h b/sal/inc/rtl/unload.h new file mode 100644 index 000000000000..30a8ddbe4a8f --- /dev/null +++ b/sal/inc/rtl/unload.h @@ -0,0 +1,315 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_UNLOAD_H_ +#define _RTL_UNLOAD_H_ + +#include <sal/types.h> +#include <osl/time.h> +#include <osl/interlck.h> +#include <osl/module.h> + +///@HTML +/** @file +The API enables an effective way of unloading libraries in a centralized way. +The mechanism ensures that used libraries are not unloaded. This prevents +crashes if library code is being used after unloading the library. +The unloading mechanism currently only works with libraries which contain +UNO services. A library cannot be unloaded if one of the following conditions +apply + +<ul> +<li>An instance is still referenced </li> +<li>A module has been loaded without registering it </li> +<li>The service manager has created a one instance service </li> +<li>A service instance has been added to an UNO context </li> +</ul> + +<b>Notification Mechanism</b> +The API provides a notification mechanism. Clients can use it to do clean up, +such as releasing cached references, in order to allow modules to be unloaded. +As long as someone holds a reference to an object whose housing module +supports unloading the module cannot be unloaded.<p> + +Because of the inherent danger of crashing the application by using this API +all instances which control threads should be registered listeners. On +notification they have to ensure that their threads assume a safe state, that +is, they run outside of modules which could be unloaded and do not jump +back into module code as a result of a finished function call. In other words, +there must not be an address of the module on the thread's stack. +<p> +Since current operating systems lack APIs in respect to controlling the +position of threads within libraries, it would be a major effort to comply with +that recommendation. The best and most efficient way of handling the unloading +scenario is to let all threads, except for the main thread, die in case of a +notification. +<p> +Use this API with great care because it might crash the application. See the +respective documentation (Library Unloading) on the udk.openoffice.org web site. +*/ + + +/** +A library which supports unloading has to implement and export a function +called <code>component_canUnload</code>. <p> +If the function returns <code>sal_True</code> then the module can be safely unloaded. +That is the case when there are no external references to code within the +library. In case a module houses UNO components then the function must return +<code>sal_False</code> after the first factory has been handed out. The function then +continues to return <code>sal_False</code> as long as there is at least one object (factory +or service instance) which originated from the module.<p> + +Libraries which not only contain UNO components (or none at all) have to +provide a means to control whether they can be unloaded or not, e.g. However, +there is no concept yet. <p> + +The argument <code>pTime</code> is an optional out-parameter. If the return value is +<code>sal_True</code> then <code>pTime</code> reflects a point in time since +when the module could have +been unloaded. Since that time the function would have continually returned +<code>sal_True</code> up to the present. The value of <code>pTime</code> is +important for the decision +as to a module will be unloaded. When someone initiates the unloading of +modules by calling <code>rtl_unloadUnusedModules</code> then the caller can specify a time +span with the effect that only those modules are unloaded which are unused at +least for that amount of time. If <code>component_canUnload</code> does not +fill in <code>pTime</code> +then the module is unloaded immediately.<p> + +<code>component_canUnload</code> is implicitly called by <code>rtl_unloadUnusedModules +</code>. There is no need to call the function directly. +*/ +#define COMPONENT_CANUNLOAD "component_canUnload" +typedef sal_Bool (SAL_CALL * component_canUnloadFunc)( TimeValue* pTime); + + +/** C-interface for a module reference counting + */ +#ifdef __cplusplus +extern "C" +{ +#endif + +/** +By registering a module, one declares that a module supports the +unloading mechanism. One registers a module by calling this function.<p> + +A module can only be unloaded from memory when it has been registered +as many times as it has been loaded. The reason is that a library can +be "loaded" several times by <code>osl_loadModule</code> +within the same process. The +function will then return the same module handle because the library will +effectively only be loaded once. To remove the library from memory it is +necessary to call <code>osl_unloadModule</code> as often as <code> +osl_loadModule</code> was called. The +function <code>rtl_unloadUnusedModules</code> calls <code>osl_unloadModule</code> +for a module as many +times as it was registered. If, for example, a module has been registered one +time less then <code>osl_loadModule</code> has been called and the module can be unloaded +then it needs a call to <code>rtl_unloadUnusedModules</code> and an explicit call to +<code>osl_unloadModule</code> to remove the module from memory. <p> + +A module must be registered every time it has been loaded otherwise the +unloading mechanism is not effective.<p> + +Before a module is registered, one has to make sure that the module is in a +state that prevents it from being unloaded. In other words, +<code>component_canUnload</code> must return <code>sal_False</code>. Assuming that +<code>component_canUnload</code> +returns <code>sal_True</code> and it is registered regardless, then a call to +<code>rtl_unloadUnusedModules</code> causes the module to be unloaded. This unloading can +be set off by a different thread and the thread which registered the module is +"unaware" of this. Then when the first thread tries to obtain a factory or +calls another function in the module, the application will crash, because the +module has been unloaded before. Therefore one has to ensure that the module +cannot be unloaded before it is registered. This is simply done by obtaining a +factory from the module. As long as a factory or some other object, which has +been created by the factory, is alive, the <code>component_canUnload</code> function will +return <code>sal_False</code>.<p> +Loading and registering have to be in this order:<br> +<ul> +<li>load a library (<code>osl_loadModule</code>)</li> +<li>get the <code>component_getFactory</code> function and get a factory</li> +<li>register the module (rtl_registerModuleForUnloading</li> +</ul> +Usually the service manager is used to obtain an instance of a service. +The service manager registers all modules which support the unloading mechanism. +When the service manager is used to get service instances than one does not +have to bother about registering. + +@param module a module handle as is obtained by osl_loadModule +@return sal_True - the module could be registered for unloading, sal_False otherwise +*/ +sal_Bool SAL_CALL rtl_registerModuleForUnloading( oslModule module); + +/** +The function revokes the registration of a module. By calling the function for +a previously registered module one prevents the module from being unloaded by +this unloading mechanism. However, in order to completely unregister the module +it is necessary to call the function as often as the module has been registered. +<p> +<code>rtl_unloadUnusedModules</code> unregisters the modules which it unloads. Therefore +there is no need to call this function unless one means to prevent the unloading of a module. + +@param module a module handle as is obtained by osl_loadModule +*/ +void SAL_CALL rtl_unregisterModuleForUnloading( oslModule module); +/** +This function sets off the unloading mechanism. At first it notifies the +unloading listeners in order to give them a chance to do cleanup and get +their threads in a safe state. Then all registered modules are asked if they +can be unloaded. That is, the function calls component_canUnload on every +registered module. If <code>sal_True</code> is returned then <code>osl_unloadModule</code> +is called for the belonging module as often as it is registered. +<p> +A call to <code>osl_unloadModule</code> does not guarantee that the module is unloaded even +if its <code>component_canUnload</code> function returns <code>sal_True</code>. +<p> +The optional in-parameter <code>libUnused</code> specifies a period of time which a library +must be unused in order to qualify for being unloaded. By using this argument +one can counter the multithreading problem as described further above. It is in +the responsibility of the user of this function to provide a timespan big enough +to ensure that all threads are out of modules (see <code>component_canUnload</code>). +<p> +The service managers which have been created by functions such as +<code>createRegistryServiceFactory</code> (declared in cppuhelper/servicefactory.hxx) are +registered listeners and release the references to factories on notification. + + +@param libUnused span of time that a module must be unused to be unloaded. the +argument is optional. +*/ +void SAL_CALL rtl_unloadUnusedModules( TimeValue* libUnused); + +/** +rtl_addUnloadingListener takes an argument of this type. + +@param id - The value that has been passed as second argument to rtl_addUnloadingListener +*/ +typedef void (SAL_CALL *rtl_unloadingListenerFunc)(void* id); +/** +The function registered an unloading listener. The callback argument is a +function which is called when the unloading procedure has been initiated by a call to +<code>rtl_unloadUnusedLibraries</code>. The second argument is used to distinguish between different +listener instances and may be <code>NULL</code>. It will be passed as argument when the callback +function is being called. The return value identifies the registered listener and will +be used for removing the listener later on. If the same listener is added more then +once then every registration is treated as if made for a different listener. That is, +a different cookie is returned and the callback function will be called as many times +as it has been registered. +@param callback - a function that is called to notify listeners. +@param this - a value to distinguish different listener instances +@return identifier which is used in rtl_removeUnloadingListener +*/ +sal_Int32 SAL_CALL rtl_addUnloadingListener( rtl_unloadingListenerFunc callback, void* _this); + +/** +Listeners (the callback functions) must be unregistered before the listener code +becomes invalid. That is, if a module contains listener code, namely callback +functions of type <code>rtl_unloadingListenerFunc</code>, then those functions must not be +registered when <code>component_canUnload</code> returns <code>sal_True</code>. + +@param cookie is an identifier as returned by <code>rtl_addUnloadingListener</code> function. +*/ +void SAL_CALL rtl_removeUnloadingListener( sal_Int32 cookie ); + + +/** +Pointers to <code>rtl_ModuleCount</code> are passed as arguments to the default factory creator +functions: <code>createSingleComponentFactory</code>, <code>createSingleFactory</code>, +<code>createOneInstanceFactory</code>. +The factory implementation is calling <code>rtl_ModuleCount.acquire</code> when it is being +constructed and it is calling <code>rtl_ModuleCount.release</code>. The implementations of +<code>acquire</code> +and <code>release</code> should influence the return value of <code>component_canUnload</code> +in a way that it +returns <code>sal_False</code> after <code>acquire</code> has been called. That is the module will not be unloaded +once a default factory has been created. A call to <code>release</code> may cause +<code>component_canUnload</code> to return <code>sal_False</code>, but only if there are +no object alive which +originated from the module. These objects are factory instances and the service instances +which have been created by these factories. +<p> +It is not necessary to synchronize <code>acquire</code> and <code>release</code> as a whole. +Simply sychronize the +access to a counter variable, e.g. the <code>rtl_moduleCount_release</code> implementation: +<pre> +extern "C" void rtl_moduleCount_acquire(rtl_ModuleCount * that ) +{ + rtl_StandardModuleCount* pMod= (rtl_StandardModuleCount*)that; + osl_incrementInterlockedCount( &pMod->counter); +} +</pre> +The SAL library offers functions that can be used for <code>acquire</code> and <code>release</code>. See struct +<code>_rtl_StandardModuleCount</code>. +*/ +typedef struct _rtl_ModuleCount +{ + void ( SAL_CALL * acquire ) ( struct _rtl_ModuleCount * that ); + void ( SAL_CALL * release ) ( struct _rtl_ModuleCount * that ); +}rtl_ModuleCount; + + +#define MODULE_COUNT_INIT \ +{ {rtl_moduleCount_acquire,rtl_moduleCount_release}, rtl_moduleCount_canUnload, 0, {0, 0}} + +/** +This struct can be used to implement the unloading mechanism. To make a UNO library +unloadable create one global instance of this struct in the module. To initialize it one +uses the MODULE_COUNT_INIT macro. + +<pre>rtl_StandardModuleCount globalModuleCount= MODULE_COUNT_INIT</pre>; +*/ +typedef struct _rtl_StandardModuleCount +{ + rtl_ModuleCount modCnt; + sal_Bool ( *canUnload ) ( struct _rtl_StandardModuleCount* a, TimeValue* libUnused); + oslInterlockedCount counter; + TimeValue unusedSince; +} rtl_StandardModuleCount; + +/** Default implementation for <code>rtl_ModuleCount.acquire</code>. Use this function along with +<code>rtl_StandardModuleCount</code>. +*/ +void rtl_moduleCount_acquire(rtl_ModuleCount * that ); +/** Default implementation for <code>rtl_ModuleCount.release</code>. +Use this function along with +<code>rtl_StandardModuleCount</code>. +*/ +void rtl_moduleCount_release( rtl_ModuleCount * that ); + +/** Default implementation for <code>component_canUnload</code>. Use this function along with +<code>rtl_StandardModuleCount</code>. +*/ +sal_Bool rtl_moduleCount_canUnload( rtl_StandardModuleCount * that, TimeValue* libUnused); + + +#ifdef __cplusplus +} +#endif + + +#endif diff --git a/sal/inc/rtl/uri.h b/sal/inc/rtl/uri.h new file mode 100644 index 000000000000..aace6e934d27 --- /dev/null +++ b/sal/inc/rtl/uri.h @@ -0,0 +1,354 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_URI_H_ +#define _RTL_URI_H_ + +#include "rtl/textenc.h" +#include "rtl/ustring.h" +#include "sal/types.h" + +#if defined __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** Various predefined URI 'char classes.' + + @descr + A 'char class' defines which (ASCII) characters can be written 'as they + are' in a part of a Uri, and which characters have to be written using + escape sequences ('%' followed by two hex digits). Characters outside + the ASCII range are always written using escape sequences. + + @descr + If there are other frequently used char classes, they can be added to + this enumeration; the function rtl_getUriCharClass() has to be adapted + then, too. + */ +typedef enum +{ + /** The empty char class. + + @descr + All characters are written using escape sequences. + */ + rtl_UriCharClassNone, + + /** The RFC 2732 <uric> char class. + + @descr + The 'valid' characters are !$&'()*+,-./:;=?@[]_~ plus digits and + letters. + */ + rtl_UriCharClassUric, + + /** The RFC 2396 <uric_no_slash> char class. + + @descr + The 'valid' characters are !$&'()*+,-.:;=?@_~ plus digits and letters. + */ + rtl_UriCharClassUricNoSlash, + + /** The RFC 2396 <rel_segment> char class. + + @descr + The 'valid' characters are !$&'()*+,-.;=@_~ plus digits and letters. + */ + rtl_UriCharClassRelSegment, + + /** The RFC 2396 <reg_name> char class. + + @descr + The 'valid' characters are !$&'()*+,-.:;=@_~ plus digits and letters. + */ + rtl_UriCharClassRegName, + + /** The RFC 2396 <userinfo> char class. + + @descr + The 'valid' characters are !$&'()*+,-.:;=_~ plus digits and letters. + */ + rtl_UriCharClassUserinfo, + + /** The RFC 2396 <pchar> char class. + + @descr + The 'valid' characters are !$&'()*+,-.:=@_~ plus digits and letters. + */ + rtl_UriCharClassPchar, + + /** The char class for the values of uno URL parameters. + + @descr + The 'valid' characters are !$&'()*+-./:?@_~ plus digits and letters. + */ + rtl_UriCharClassUnoParamValue, + + rtl_UriCharClass_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +} +rtl_UriCharClass; + +/** The mechanism describing how escape sequences in the input of + rtl_uriEncode() are handled. + */ +typedef enum +{ + /** The special meaning of '%' is ignored (i.e., there are by definition + no escape sequences in the input). + + @descr + This mechanism is useful to encode user input as part of a URI (e.g., + the user-supplied password in an ftp URL---'%20abcde' is a valid + password, so do not assume that the '%20' is an escaped space). + */ + rtl_UriEncodeIgnoreEscapes, + + /** All escape sequences ('%' followed by two hex digits) are kept intact, + even if they represent characters that need not be escaped or if they + do not even map to characters in the given charset. + + @descr + This mechanism is useful when passing on complete URIs more or less + unmodified (e.g., within an HTTP proxy): missing escape sequences are + added, but existing escape sequences are not touched (except that any + lower case hex digits are replaced by upper case hex digits). + */ + rtl_UriEncodeKeepEscapes, + + /** All escape sequences ('%' followed by two hex digits) are resolved in + a first step; only those that represent characters that need to be + escaped are kept intact. + + @descr + This mechanism is useful to properly encode complete URIs entered by + the user: the URI is brought into a 'canonic form,' but care is taken + not to damage (valid) escape sequences the (careful) user already + entered as such. + */ + rtl_UriEncodeCheckEscapes, + + /** Like rtl_UriEncodeIgnoreEscapes, but indicating failure when converting + unmappable characters. + + @since UDK 3.2.0 + */ + rtl_UriEncodeStrict, + + /** Like rtl_UriEncodeKeepEscapes, but indicating failure when converting + unmappable characters. + + @since UDK 3.2.7 + */ + rtl_UriEncodeStrictKeepEscapes, + + rtl_UriEncode_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +} +rtl_UriEncodeMechanism; + +/** The mechanism describing how rtl_uriDecode() translates (part of) a URI + into a Unicode string. + */ +typedef enum +{ + /** The text is returned completely unmodified. + */ + rtl_UriDecodeNone, + + /** The text is returned in the form of an IURI (cf. + draft-masinter-url-i18n-05.txt). + + @descr + All escape sequences representing ASCII characters (%00--%7F) are + kept, all other escape sequences are interpreted as UTF-8 characters + and translated to Unicode, if possible. + */ + rtl_UriDecodeToIuri, + + /** The text is decoded. + + @descr + All escape sequences representing characters from the given charset + are decoded and translated to Unicode, if possible. + */ + rtl_UriDecodeWithCharset, + + /** Like rtl_UriDecodeWithCharset, but indicating failure when converting + unmappable characters. + + @since UDK 3.2.0 + */ + rtl_UriDecodeStrict, + + rtl_UriDecode_FORCE_EQUAL_SIZE = SAL_MAX_ENUM +} +rtl_UriDecodeMechanism; + +/** Map a predefined rtl_UriCharClass to a form usable by rtl_uriEncode(). + + @descr + The function rtl_uriEncode() expects an array of 128 booleans, and this + function maps rtl_UriCharClass enumeration members to such arrays. + + @param eCharClass + Any valid member of rtl_UriCharClass. + + @return + An array of 128 booleans, to be used in calls to rtl_uriEncode(). + */ +sal_Bool const * SAL_CALL rtl_getUriCharClass(rtl_UriCharClass eCharClass) + SAL_THROW_EXTERN_C(); + +/** Encode a text as (part of) a URI. + + @param pText + Any Unicode string. Must not be null. + + @param pCharClass + A char class, represented as an array of 128 booleans (true means keep the + corresponding ASCII character unencoded, false means encode it). Must not + be null, and the boolean corresponding to the percent sign (0x25) must be + false. (See rtl_getUriCharClass() for a function mapping from + rtl_UriCharClass to such arrays.) + + @param eMechanism + The mechanism describing how escape sequences in the input text are + handled. + + @param eCharset + When Unicode characters from the input text have to be written using + escape sequences (because they are either outside the ASCII range or do + not belong to the given char class), they are first translated into this + charset before being encoded using escape sequences. + + Also, if the encode mechanism is rtl_UriEncodeCheckEscapes, all escape + sequences already present in the input text are interpreted as characters + from this charset. + + @param pResult + Returns an encoded representation of the input text. Must itself not be + null, and must point to either null or a valid string. + + If the encode mechanism is rtl_UriEncodeStrict, and pText cannot be + converted to eCharset because it contains unmappable characters (which + implies that pText is not empty), then an empty string is returned. + */ +void SAL_CALL rtl_uriEncode(rtl_uString * pText, + sal_Bool const * pCharClass, + rtl_UriEncodeMechanism eMechanism, + rtl_TextEncoding eCharset, + rtl_uString ** pResult) + SAL_THROW_EXTERN_C(); + +/** Decode (a part of) a URI. + + @param pText + Any Unicode string. Must not be null. (If the input is indeed part of a + valid URI, this string will only contain a subset of the ASCII characters, + but this function also handles other Unicode characters properly.) + + @param eMechanism + The mechanism describing how the input text is translated into a Unicode + string. + + @param eCharset + When the decode mechanism is rtl_UriDecodeWithCharset, all escape + sequences in the input text are interpreted as characters from this + charset. Those characters are translated to Unicode characters in the + resulting output, if possible. + + When the decode mechanism is rtl_UriDecodeNone or rtl_UriDecodeToIuri, + this parameter is ignored (and is best specified as + RTL_TEXTENCODING_UTF8). + + @param pResult + Returns a decoded representation of the input text. Must itself not be + null, and must point to either null or a valid string. + + If the decode mechanism is rtl_UriDecodeStrict, and pText cannot be + converted to eCharset because it contains (encodings of) unmappable + characters (which implies that pText is not empty), then an empty string is + returned. + */ +void SAL_CALL rtl_uriDecode(rtl_uString * pText, + rtl_UriDecodeMechanism eMechanism, + rtl_TextEncoding eCharset, + rtl_uString ** pResult) + SAL_THROW_EXTERN_C(); + +/** Convert a relative URI reference into an absolute one. + + A URI reference is a URI plus an optional <"#" fragment> part. + + This function uses the algorithm described in RFC 2396, section 5.2, with + the following clarifications: (1) Backwards-compatible relative URIs + starting with a scheme component (see RFC 2396, section 5.2, step 3) are not + supported. (2) Segments "." and ".." within the path of the base URI are + not considered special, RFC 2396 seems a bit unlcear about that point. + (3) Erroneous excess segments ".." within the path of the relative URI (if + it is indeed relative) are left intact, as the examples in RFC 2396, + section C.2, suggest. (4) If the relative URI is a reference to the + "current document," the "current document" is taken to be the base URI. + + This function signals exceptions by returning false and letting pException + point to a message explaining the exception. + + @param pBaseUriRef + An absolute, hierarchical URI reference that serves as the base URI. If it + has to be inspected (i.e., pRelUriRef is not an absolute URI already), and + if it either is not an absolute URI (i.e., does not begin with a + <scheme ":"> part) or has a path that is non-empty but does not start + with "/", an exception will be signaled. + + @param pRelUriRef + An URI reference that may be either absolute or relative. If it is + absolute, it will be returned unmodified (and it need not be hierarchical + then). + + @param pResult + Returns an absolute URI reference. Must itself not be null, and must point + to either null or a valid string. If an exception is signalled, it is left + unchanged. + + @param pException + Returns an explanatory message in case an exception is signalled. Must + itself not be null, and must point to either null or a valid string. If no + exception is signalled, it is left unchanged. + + @return + True if no exception is signalled, otherwise false. + */ +sal_Bool SAL_CALL rtl_uriConvertRelToAbs(rtl_uString * pBaseUriRef, + rtl_uString * pRelUriRef, + rtl_uString ** pResult, + rtl_uString ** pException) + SAL_THROW_EXTERN_C(); + +#if defined __cplusplus +} +#endif /* __cplusplus */ + +#endif /* _RTL_URI_H_ */ diff --git a/sal/inc/rtl/uri.hxx b/sal/inc/rtl/uri.hxx new file mode 100644 index 000000000000..9dfe1d5ec80e --- /dev/null +++ b/sal/inc/rtl/uri.hxx @@ -0,0 +1,154 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_URI_HXX_ +#define _RTL_URI_HXX_ + +#include "rtl/malformeduriexception.hxx" +#include "rtl/uri.h" +#include "rtl/textenc.h" +#include "rtl/ustring.hxx" +#include "sal/types.h" + +namespace rtl { + +/** A wrapper around the C functions from <rtl/uri.h>. + */ +class Uri +{ +public: + /** A wrapper around rtl_uriEncode() from <rtl/uri.h> (see there), using + an array of 128 booleans as char class. + */ + static inline rtl::OUString encode(rtl::OUString const & rText, + sal_Bool const * pCharClass, + rtl_UriEncodeMechanism eMechanism, + rtl_TextEncoding eCharset) + SAL_THROW(()); + + /** A wrapper around rtl_uriEncode() from <rtl/uri.h> (see there), using + a predefined rtl_UriCharClass enumeration member. + */ + static inline rtl::OUString encode(rtl::OUString const & rText, + rtl_UriCharClass eCharClass, + rtl_UriEncodeMechanism eMechanism, + rtl_TextEncoding eCharset) + SAL_THROW(()); + + /** A wrapper around rtl_uriDecode() from <rtl/uri.h> (see there). + */ + static inline rtl::OUString decode(rtl::OUString const & rText, + rtl_UriDecodeMechanism eMechanism, + rtl_TextEncoding eCharset) + SAL_THROW(()); + + /** A wrapper around rtl_uriConvertRelToAbs() from <rtl/uri.h> (see there). + + @exception MalformedUriException + Thrown in case rtl_uriConvertRelToAbs() signals an exception due to a + malformed base URI. + */ + static inline rtl::OUString convertRelToAbs( + rtl::OUString const & rBaseUriRef, rtl::OUString const & rRelUriRef); + +private: + /** not implemented + @internal */ + Uri(); + + /** not implemented + @internal */ + Uri(Uri &); + + /** not implemented + @internal */ + ~Uri(); + + /** not implemented + @internal */ + void operator =(Uri); +}; + +inline rtl::OUString Uri::encode(rtl::OUString const & rText, + sal_Bool const * pCharClass, + rtl_UriEncodeMechanism eMechanism, + rtl_TextEncoding eCharset) + SAL_THROW(()) +{ + rtl::OUString aResult; + rtl_uriEncode(const_cast< rtl::OUString & >(rText).pData, + pCharClass, + eMechanism, + eCharset, + &aResult.pData); + return aResult; +} + +inline rtl::OUString Uri::encode(rtl::OUString const & rText, + rtl_UriCharClass eCharClass, + rtl_UriEncodeMechanism eMechanism, + rtl_TextEncoding eCharset) + SAL_THROW(()) +{ + rtl::OUString aResult; + rtl_uriEncode(const_cast< rtl::OUString & >(rText).pData, + rtl_getUriCharClass(eCharClass), + eMechanism, + eCharset, + &aResult.pData); + return aResult; +} + +inline rtl::OUString Uri::decode(rtl::OUString const & rText, + rtl_UriDecodeMechanism eMechanism, + rtl_TextEncoding eCharset) + SAL_THROW(()) +{ + rtl::OUString aResult; + rtl_uriDecode(const_cast< rtl::OUString & >(rText).pData, + eMechanism, + eCharset, + &aResult.pData); + return aResult; +} + +inline rtl::OUString Uri::convertRelToAbs(rtl::OUString const & rBaseUriRef, + rtl::OUString const & rRelUriRef) +{ + rtl::OUString aResult; + rtl::OUString aException; + if (!rtl_uriConvertRelToAbs( + const_cast< rtl::OUString & >(rBaseUriRef).pData, + const_cast< rtl::OUString & >(rRelUriRef).pData, &aResult.pData, + &aException.pData)) + throw MalformedUriException(aException); + return aResult; +} + +} + +#endif // _RTL_URI_HXX_ diff --git a/sal/inc/rtl/ustrbuf.h b/sal/inc/rtl/ustrbuf.h new file mode 100644 index 000000000000..632040818f21 --- /dev/null +++ b/sal/inc/rtl/ustrbuf.h @@ -0,0 +1,165 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_USTRBUF_H_ +#define _RTL_USTRBUF_H_ + +#include <rtl/ustring.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** @HTML + Allocates a new <code>String</code> that contains characters from + the character array argument. + + The <code>count</code> argument specifies + the length of the array. The initial capacity of the string buffer is + <code>16</code> plus the length of the string argument. + + @param newStr out parameter, contains the new string. The reference count is 1. + @param value the initial value of the string. + @param count the length of value. + */ +void SAL_CALL rtl_uStringbuffer_newFromStr_WithLength( rtl_uString ** newStr, + const sal_Unicode * value, + sal_Int32 count ); + +/** + Allocates a new <code>String</code> that contains the same sequence of + characters as the string argument. + + The initial capacity is the larger of: + <ul> + <li> The <code>bufferLen</code> argument. + <li> The <code>length</code> of the string argument. + </ul> + + @param newStr out parameter, contains the new string. The reference count is 1. + @param capacity the initial len of the string buffer. + @param oldStr the initial value of the string. + @return the new capacity of the string buffer + */ +sal_Int32 SAL_CALL rtl_uStringbuffer_newFromStringBuffer( rtl_uString ** newStr, + sal_Int32 capacity, + rtl_uString * olsStr ); + +/** + Ensures that the capacity of the buffer is at least equal to the + specified minimum. + + If the current capacity of this string buffer is less than the + argument, then a new internal buffer is allocated with greater + capacity. The new capacity is the larger of: + <ul> + <li>The <code>minimumCapacity</code> argument. + <li>Twice the old capacity, plus <code>2</code>. + </ul> + If the <code>minimumCapacity</code> argument is nonpositive, this + method takes no action and simply returns. + + @param capacity in: old capicity, out: new capacity. + @param minimumCapacity the minimum desired capacity. + */ +void SAL_CALL rtl_uStringbuffer_ensureCapacity( /*inout*/rtl_uString ** This, + /*inout*/sal_Int32* capacity, + sal_Int32 minimumCapacity); + +/** + Inserts the string representation of the <code>str</code> array + argument into this string buffer. + + The characters of the array argument are inserted into the + contents of this string buffer at the position indicated by + <code>offset</code>. The length of this string buffer increases by + the length of the argument. + + @param This The string, on that the operation should take place + @param capacity the capacity of the string buffer + @param offset the offset. + @param str a character array. + @param len the number of characters to append. + */ +void SAL_CALL rtl_uStringbuffer_insert( /*inout*/rtl_uString ** This, + /*inout*/sal_Int32 * capacity, + sal_Int32 offset, + const sal_Unicode * str, + sal_Int32 len); + +/** + Inserts a single UTF-32 character into this string buffer. + + <p>The single UTF-32 character will be represented within the string buffer + as either one or two UTF-16 code units.</p> + + @param pThis the string buffer on which the operation is performed + + @param capacity the capacity of the string buffer + + @param offset the offset into this string buffer (from zero to the length + of this string buffer, inclusive) + + @param c a well-formed UTF-32 code unit (that is, a value in the range + <code>0</code>–<code>0x10FFFF</code>, but excluding + <code>0xD800</code>–<code>0xDFFF</code>) + */ +void SAL_CALL rtl_uStringbuffer_insertUtf32( + rtl_uString ** pThis, sal_Int32 * capacity, sal_Int32 offset, sal_uInt32 c) + SAL_THROW_EXTERN_C(); + +/** + Inserts the 8-Bit ASCII string representation of the <code>str</code> + array argument into this string buffer. + + Since this function is optimized + for performance, the ASCII character values are not converted in any way. + The caller has to make sure that all ASCII characters are in the allowed + range between 0 and 127. + <p> + The characters of the array argument are inserted into the + contents of this string buffer at the position indicated by + <code>offset</code>. The length of this string buffer increases by + the length of the argument. + + @param This The string, on that the operation should take place + @param capacity the capacity of the string buffer + @param offset the offset. + @param str a character array. + @param len the number of characters to append. + */ +void SAL_CALL rtl_uStringbuffer_insert_ascii( /*inout*/rtl_uString ** This, + /*inout*/sal_Int32 * capacity, + sal_Int32 offset, + const sal_Char * str, + sal_Int32 len); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_USTRBUF_H_ */ diff --git a/sal/inc/rtl/ustrbuf.hxx b/sal/inc/rtl/ustrbuf.hxx new file mode 100644 index 000000000000..3f8421b1f3c7 --- /dev/null +++ b/sal/inc/rtl/ustrbuf.hxx @@ -0,0 +1,774 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_USTRBUF_HXX_ +#define _RTL_USTRBUF_HXX_ + +#include <osl/diagnose.h> +#include <rtl/ustrbuf.h> +#ifndef _RTL_USTRING_HXX +#include <rtl/ustring.hxx> +#endif + +#ifdef __cplusplus + +namespace rtl +{ + +/** @HTML + A string buffer implements a mutable sequence of characters. + <p> + String buffers are safe for use by multiple threads. The methods + are synchronized where necessary so that all the operations on any + particular instance behave as if they occur in some serial order. + <p> + String buffers are used by the compiler to implement the binary + string concatenation operator <code>+</code>. For example, the code: + <p><blockquote><pre> + x = "a" + 4 + "c" + </pre></blockquote><p> + is compiled to the equivalent of: + <p><blockquote><pre> + x = new OUStringBuffer().append("a").append(4).append("c") + .toString() + </pre></blockquote><p> + The principal operations on a <code>OUStringBuffer</code> are the + <code>append</code> and <code>insert</code> methods, which are + overloaded so as to accept data of any type. Each effectively + converts a given datum to a string and then appends or inserts the + characters of that string to the string buffer. The + <code>append</code> method always adds these characters at the end + of the buffer; the <code>insert</code> method adds the characters at + a specified point. + <p> + For example, if <code>z</code> refers to a string buffer object + whose current contents are "<code>start</code>", then + the method call <code>z.append("le")</code> would cause the string + buffer to contain "<code>startle</code>", whereas + <code>z.insert(4, "le")</code> would alter the string buffer to + contain "<code>starlet</code>". + <p> + Every string buffer has a capacity. As long as the length of the + character sequence contained in the string buffer does not exceed + the capacity, it is not necessary to allocate a new internal + buffer array. If the internal buffer overflows, it is + automatically made larger. + */ +class OUStringBuffer +{ +public: + /** + Constructs a string buffer with no characters in it and an + initial capacity of 16 characters. + */ + OUStringBuffer() + : pData(NULL) + , nCapacity( 16 ) + { + rtl_uString_new_WithLength( &pData, nCapacity ); + } + + /** + Allocates a new string buffer that contains the same sequence of + characters as the string buffer argument. + + @param value a <code>OStringBuffer</code>. + */ + OUStringBuffer( const OUStringBuffer & value ) + : pData(NULL) + , nCapacity( value.nCapacity ) + { + rtl_uStringbuffer_newFromStringBuffer( &pData, value.nCapacity, value.pData ); + } + + /** + Constructs a string buffer with no characters in it and an + initial capacity specified by the <code>length</code> argument. + + @param length the initial capacity. + */ + OUStringBuffer(sal_Int32 length) + : pData(NULL) + , nCapacity( length ) + { + rtl_uString_new_WithLength( &pData, length ); + } + + /** + Constructs a string buffer so that it represents the same + sequence of characters as the string argument. + + The initial + capacity of the string buffer is <code>16</code> plus the length + of the string argument. + + @param str the initial contents of the buffer. + */ + OUStringBuffer(OUString value) + : pData(NULL) + , nCapacity( value.getLength() + 16 ) + { + rtl_uStringbuffer_newFromStr_WithLength( &pData, value.getStr(), value.getLength() ); + } + + /** Assign to this a copy of value. + */ + OUStringBuffer& operator = ( const OUStringBuffer& value ) + { + if (this != &value) + { + rtl_uStringbuffer_newFromStringBuffer(&pData, + value.nCapacity, + value.pData); + nCapacity = value.nCapacity; + } + return *this; + } + + /** + Release the string data. + */ + ~OUStringBuffer() + { + rtl_uString_release( pData ); + } + + /** + Fill the string data in the new string and clear the buffer. + + This method is more efficient than the contructor of the string. It does + not copy the buffer. + + @return the string previously contained in the buffer. + */ + OUString makeStringAndClear() + { + OUString aRet( pData ); + rtl_uString_new(&pData); + nCapacity = 0; + return aRet; + } + + /** + Returns the length (character count) of this string buffer. + + @return the number of characters in this string buffer. + */ + sal_Int32 getLength() const + { + return pData->length; + } + + /** + Returns the current capacity of the String buffer. + + The capacity + is the amount of storage available for newly inserted + characters. The real buffer size is 2 bytes longer, because + all strings are 0 terminated. + + @return the current capacity of this string buffer. + */ + sal_Int32 getCapacity() const + { + return nCapacity; + } + + /** + Ensures that the capacity of the buffer is at least equal to the + specified minimum. + + The new capacity will be at least as large as the maximum of the current + length (so that no contents of the buffer is destroyed) and the given + minimumCapacity. If the given minimumCapacity is negative, nothing is + changed. + + @param minimumCapacity the minimum desired capacity. + */ + void ensureCapacity(sal_Int32 minimumCapacity) + { + rtl_uStringbuffer_ensureCapacity( &pData, &nCapacity, minimumCapacity ); + } + + /** + Sets the length of this String buffer. + + If the <code>newLength</code> argument is less than the current + length of the string buffer, the string buffer is truncated to + contain exactly the number of characters given by the + <code>newLength</code> argument. + <p> + If the <code>newLength</code> argument is greater than or equal + to the current length, sufficient null characters + (<code>'\u0000'</code>) are appended to the string buffer so that + length becomes the <code>newLength</code> argument. + <p> + The <code>newLength</code> argument must be greater than or equal + to <code>0</code>. + + @param newLength the new length of the buffer. + */ + void setLength(sal_Int32 newLength) + { + OSL_ASSERT(newLength >= 0); + // Avoid modifications if pData points to const empty string: + if( newLength != pData->length ) + { + if( newLength > nCapacity ) + rtl_uStringbuffer_ensureCapacity(&pData, &nCapacity, newLength); + else + pData->buffer[newLength] = 0; + pData->length = newLength; + } + } + + /** + Returns the character at a specific index in this string buffer. + + The first character of a string buffer is at index + <code>0</code>, the next at index <code>1</code>, and so on, for + array indexing. + <p> + The index argument must be greater than or equal to + <code>0</code>, and less than the length of this string buffer. + + @param index the index of the desired character. + @return the character at the specified index of this string buffer. + */ + sal_Unicode charAt( sal_Int32 index ) const + { + OSL_ASSERT(index >= 0 && index < pData->length); + return pData->buffer[ index ]; + } + + /** + Return a null terminated unicode character array. + */ + operator const sal_Unicode *() const { return pData->buffer; } + + /** + Return a null terminated unicode character array. + */ + const sal_Unicode* getStr() const { return pData->buffer; } + + + /** + The character at the specified index of this string buffer is set + to <code>ch</code>. + + The index argument must be greater than or equal to + <code>0</code>, and less than the length of this string buffer. + + @param index the index of the character to modify. + @param ch the new character. + */ + OUStringBuffer & setCharAt(sal_Int32 index, sal_Unicode ch) + { + OSL_ASSERT(index >= 0 && index < pData->length); + pData->buffer[ index ] = ch; + return *this; + } + + /** + Appends the string to this string buffer. + + The characters of the <code>String</code> argument are appended, in + order, to the contents of this string buffer, increasing the + length of this string buffer by the length of the argument. + + @param str a string. + @return this string buffer. + */ + OUStringBuffer & append(const OUString &str) + { + return append( str.getStr(), str.getLength() ); + } + + /** + Appends the string representation of the <code>char</code> array + argument to this string buffer. + + The characters of the array argument are appended, in order, to + the contents of this string buffer. The length of this string + buffer increases by the length of the argument. + + @param str the characters to be appended. + @return this string buffer. + */ + OUStringBuffer & append( const sal_Unicode * str ) + { + return append( str, rtl_ustr_getLength( str ) ); + } + + /** + Appends the string representation of the <code>char</code> array + argument to this string buffer. + + Characters of the character array <code>str</code> are appended, + in order, to the contents of this string buffer. The length of this + string buffer increases by the value of <code>len</code>. + + @param str the characters to be appended; must be non-null, and must + point to at least len characters + @param len the number of characters to append; must be non-negative + @return this string buffer. + */ + OUStringBuffer & append( const sal_Unicode * str, sal_Int32 len) + { + // insert behind the last character + rtl_uStringbuffer_insert( &pData, &nCapacity, getLength(), str, len ); + return *this; + } + + /** + Appends a 8-Bit ASCII character string to this string buffer. + + Since this method is optimized for performance. the ASCII + character values are not converted in any way. The caller + has to make sure that all ASCII characters are in the + allowed range between 0 and 127. The ASCII string must be + NULL-terminated. + <p> + The characters of the array argument are appended, in order, to + the contents of this string buffer. The length of this string + buffer increases by the length of the argument. + + @param str the 8-Bit ASCII characters to be appended. + @return this string buffer. + */ + OUStringBuffer & appendAscii( const sal_Char * str ) + { + return appendAscii( str, rtl_str_getLength( str ) ); + } + + /** + Appends a 8-Bit ASCII character string to this string buffer. + + Since this method is optimized for performance. the ASCII + character values are not converted in any way. The caller + has to make sure that all ASCII characters are in the + allowed range between 0 and 127. The ASCII string must be + NULL-terminated. + <p> + Characters of the character array <code>str</code> are appended, + in order, to the contents of this string buffer. The length of this + string buffer increases by the value of <code>len</code>. + + @param str the 8-Bit ASCII characters to be appended; must be non-null, + and must point to at least len characters + @param len the number of characters to append; must be non-negative + @return this string buffer. + */ + OUStringBuffer & appendAscii( const sal_Char * str, sal_Int32 len) + { + rtl_uStringbuffer_insert_ascii( &pData, &nCapacity, getLength(), str, len ); + return *this; + } + + + /** + Appends the string representation of the <code>sal_Bool</code> + argument to the string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param b a <code>sal_Bool</code>. + @return this string buffer. + */ + OUStringBuffer & append(sal_Bool b) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFBOOLEAN]; + return append( sz, rtl_ustr_valueOfBoolean( sz, b ) ); + } + + /** + Appends the string representation of the <code>char</code> + argument to this string buffer. + + The argument is appended to the contents of this string buffer. + The length of this string buffer increases by <code>1</code>. + + @param ch a <code>char</code>. + @return this string buffer. + */ + OUStringBuffer & append(sal_Unicode c) + { + return append( &c, 1 ); + } + + /** + Appends the string representation of the <code>sal_Int32</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param i an <code>sal_Int32</code>. + @return this string buffer. + */ + OUStringBuffer & append(sal_Int32 i, sal_Int16 radix = 10 ) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFINT32]; + return append( sz, rtl_ustr_valueOfInt32( sz, i, radix ) ); + } + + /** + Appends the string representation of the <code>long</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param l a <code>long</code>. + @return this string buffer. + */ + OUStringBuffer & append(sal_Int64 l, sal_Int16 radix = 10 ) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFINT64]; + return append( sz, rtl_ustr_valueOfInt64( sz, l, radix ) ); + } + + /** + Appends the string representation of the <code>float</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param f a <code>float</code>. + @return this string buffer. + */ + OUStringBuffer & append(float f) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFFLOAT]; + return append( sz, rtl_ustr_valueOfFloat( sz, f ) ); + } + + /** + Appends the string representation of the <code>double</code> + argument to this string buffer. + + The argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then appended to this string buffer. + + @param d a <code>double</code>. + @return this string buffer. + */ + OUStringBuffer & append(double d) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFDOUBLE]; + return append( sz, rtl_ustr_valueOfDouble( sz, d ) ); + } + + /** + Appends a single UTF-32 character to this string buffer. + + <p>The single UTF-32 character will be represented within the string + buffer as either one or two UTF-16 code units.</p> + + @param c a well-formed UTF-32 code unit (that is, a value in the range + <code>0</code>–<code>0x10FFFF</code>, but excluding + <code>0xD800</code>–<code>0xDFFF</code>) + + @return + this string buffer + */ + OUStringBuffer & appendUtf32(sal_uInt32 c) { + return insertUtf32(getLength(), c); + } + + /** + Inserts the string into this string buffer. + + The characters of the <code>String</code> argument are inserted, in + order, into this string buffer at the indicated offset. The length + of this string buffer is increased by the length of the argument. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param str a string. + @return this string buffer. + */ + OUStringBuffer & insert(sal_Int32 offset, const OUString & str) + { + return insert( offset, str.getStr(), str.getLength() ); + } + + /** + Inserts the string representation of the <code>char</code> array + argument into this string buffer. + + The characters of the array argument are inserted into the + contents of this string buffer at the position indicated by + <code>offset</code>. The length of this string buffer increases by + the length of the argument. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param ch a character array. + @return this string buffer. + */ + OUStringBuffer & insert( sal_Int32 offset, const sal_Unicode * str ) + { + return insert( offset, str, rtl_ustr_getLength( str ) ); + } + + /** + Inserts the string representation of the <code>char</code> array + argument into this string buffer. + + The characters of the array argument are inserted into the + contents of this string buffer at the position indicated by + <code>offset</code>. The length of this string buffer increases by + the length of the argument. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param ch a character array. + @param len the number of characters to append. + @return this string buffer. + */ + OUStringBuffer & insert( sal_Int32 offset, const sal_Unicode * str, sal_Int32 len) + { + // insert behind the last character + rtl_uStringbuffer_insert( &pData, &nCapacity, offset, str, len ); + return *this; + } + + /** + Inserts the string representation of the <code>sal_Bool</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>sal_Bool</code>. + @return this string buffer. + */ + OUStringBuffer & insert(sal_Int32 offset, sal_Bool b) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFBOOLEAN]; + return insert( offset, sz, rtl_ustr_valueOfBoolean( sz, b ) ); + } + + /** + Inserts the string representation of the <code>char</code> + argument into this string buffer. + + The second argument is inserted into the contents of this string + buffer at the position indicated by <code>offset</code>. The length + of this string buffer increases by one. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param ch a <code>char</code>. + @return this string buffer. + */ + OUStringBuffer & insert(sal_Int32 offset, sal_Unicode c) + { + return insert( offset, &c, 1 ); + } + + /** + Inserts the string representation of the second <code>sal_Int32</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b an <code>sal_Int32</code>. + @return this string buffer. + @exception StringIndexOutOfBoundsException if the offset is invalid. + */ + OUStringBuffer & insert(sal_Int32 offset, sal_Int32 i, sal_Int16 radix = 10 ) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFINT32]; + return insert( offset, sz, rtl_ustr_valueOfInt32( sz, i, radix ) ); + } + + /** + Inserts the string representation of the <code>long</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>long</code>. + @return this string buffer. + @exception StringIndexOutOfBoundsException if the offset is invalid. + */ + OUStringBuffer & insert(sal_Int32 offset, sal_Int64 l, sal_Int16 radix = 10 ) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFINT64]; + return insert( offset, sz, rtl_ustr_valueOfInt64( sz, l, radix ) ); + } + + /** + Inserts the string representation of the <code>float</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>float</code>. + @return this string buffer. + @exception StringIndexOutOfBoundsException if the offset is invalid. + */ + OUStringBuffer insert(sal_Int32 offset, float f) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFFLOAT]; + return insert( offset, sz, rtl_ustr_valueOfFloat( sz, f ) ); + } + + /** + Inserts the string representation of the <code>double</code> + argument into this string buffer. + + The second argument is converted to a string as if by the method + <code>String.valueOf</code>, and the characters of that + string are then inserted into this string buffer at the indicated + offset. + <p> + The offset argument must be greater than or equal to + <code>0</code>, and less than or equal to the length of this + string buffer. + + @param offset the offset. + @param b a <code>double</code>. + @return this string buffer. + @exception StringIndexOutOfBoundsException if the offset is invalid. + */ + OUStringBuffer & insert(sal_Int32 offset, double d) + { + sal_Unicode sz[RTL_USTR_MAX_VALUEOFDOUBLE]; + return insert( offset, sz, rtl_ustr_valueOfDouble( sz, d ) ); + } + + /** + Inserts a single UTF-32 character into this string buffer. + + <p>The single UTF-32 character will be represented within the string + buffer as either one or two UTF-16 code units.</p> + + @param offset the offset into this string buffer (from zero to the length + of this string buffer, inclusive) + + @param c a well-formed UTF-32 code unit (that is, a value in the range + <code>0</code>–<code>0x10FFFF</code>, but excluding + <code>0xD800</code>–<code>0xDFFF</code>) + + @return this string buffer + */ + OUStringBuffer & insertUtf32(sal_Int32 offset, sal_uInt32 c) { + rtl_uStringbuffer_insertUtf32(&pData, &nCapacity, offset, c); + return *this; + } + + /** Allows access to the internal data of this OUStringBuffer, for effective + manipulation. + + This method should be used with care. After you have called this + method, you may use the returned pInternalData or pInternalCapacity only + as long as you make no other method call on this OUStringBuffer. + + @param pInternalData + This output parameter receives a pointer to the internal data + (rtl_uString pointer). pInternalData itself must not be null. + + @param pInternalCapacity + This output parameter receives a pointer to the internal capacity. + pInternalCapacity itself must not be null. + */ + inline void accessInternals(rtl_uString *** pInternalData, + sal_Int32 ** pInternalCapacity) + { + *pInternalData = &pData; + *pInternalCapacity = &nCapacity; + } + +private: + /** + A pointer to the data structur which contains the data. + */ + rtl_uString * pData; + + /** + The len of the pData->buffer. + */ + sal_Int32 nCapacity; +}; + +} + +#endif /* __cplusplus */ +#endif /* _RTL_USTRBUF_HXX_ */ diff --git a/sal/inc/rtl/ustring.h b/sal/inc/rtl/ustring.h new file mode 100644 index 000000000000..22e697e370e8 --- /dev/null +++ b/sal/inc/rtl/ustring.h @@ -0,0 +1,1660 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_USTRING_H_ +#define _RTL_USTRING_H_ + +#include <sal/types.h> +#include <osl/interlck.h> +#include <rtl/string.h> +#include <rtl/textenc.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* ======================================================================= */ + +/** Return the length of a string. + + The length is equal to the number of 16-bit Unicode characters in the + string, without the terminating NUL character. + + @param str + a null-terminated string. + + @return + the length of the sequence of characters represented by this string, + excluding the terminating NUL character. + */ +sal_Int32 SAL_CALL rtl_ustr_getLength( const sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/** Compare two strings. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. Both strings must be + null-terminated. + + @param first + the first null-terminated string to be compared. + + @param second + the second null-terminated string which is compared with the first one. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_compare( const sal_Unicode * first, const sal_Unicode * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_compare_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Unicode * second, sal_Int32 secondLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings with a maximum count of characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @param shortenedLen + the maximum number of characters to compare. This length can be greater + or smaller than the lengths of the two strings. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_ustr_shortenedCompare_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Unicode * second, sal_Int32 secondLen, sal_Int32 shortenedLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings from back to front. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string + compares less than the second string, and a value greater than 0 if the + first string compares greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_reverseCompare_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Unicode * second, sal_Int32 secondLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings from back to front for equality. + + The comparison is based on the numeric value of each character in the + strings and returns 'true' if, ans only if, both strings are equal. + This function cannot be used for language-specific sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified len. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified len. + + @param len + the length of both strings. + + @return + true if both strings are equal, false if they are not equal. + */ + +sal_Bool SAL_CALL rtl_ustr_asciil_reverseEquals_WithLength( const sal_Unicode * first, const sal_Char * second, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Compare two strings, ignoring the case of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. Both strings must be null-terminated. + + @param first + the first null-terminated string to be compared. + + @param second + the second null-terminated string which is compared with the first one. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase( const sal_Unicode * first, const sal_Unicode * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings, ignoring the case of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Unicode * second, sal_Int32 secondLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings with a maximum count of characters, ignoring the case + of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @param shortenedLen + the maximum number of characters to compare. This length can be greater + or smaller than the lengths of the two strings. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Unicode * second, sal_Int32 secondLen, sal_Int32 shortenedLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. Both strings must be + null-terminated. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first null-terminated string to be compared. + + @param second + the second null-terminated ASCII string which is compared with the first + one. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_ustr_ascii_compare( const sal_Unicode * first, const sal_Char * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second null-terminated ASCII string which is compared with the first + one. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Char * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings with a maximum count of characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second null-terminated ASCII string which is compared with the first + one. + + @param shortenedLen + the maximum number of characters to compare. This length can be greater + or smaller than the lengths of the two strings. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompare_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 shortenedLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings from back to front. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. This function + cannot be used for language-specific sorting. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second ASCII string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string + compares less than the second string, and a value greater than 0 if the + first string compares greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_asciil_reverseCompare_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 secondLen ) SAL_THROW_EXTERN_C(); + +/** Compare two strings, ignoring the case of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. Both strings must be null-terminated. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first null-terminated string to be compared. + + @param second + the second null-terminated ASCII string which is compared with the first + one. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase( const sal_Unicode * first, const sal_Char * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings, ignoring the case of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second null-terminated ASCII string which is compared with the first + one. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Char * second ) SAL_THROW_EXTERN_C(); + +/** Compare two strings, ignoring the case of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second string which is compared with the first one. Need not be + null-terminated, but must be at least as long as the specified secondLen. + + @param secondLen + the length of the second string. + + @return + 0 if both strings are equal, a value less than 0 if the first string is + less than the second string, and a value greater than 0 if the first + string is greater than the second string. + */ +sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths( + sal_Unicode const * first, sal_Int32 firstLen, + char const * second, sal_Int32 secondLen) SAL_THROW_EXTERN_C(); + +/** Compare two strings with a maximum count of characters, ignoring the case + of ASCII characters. + + The comparison is based on the numeric value of each character in the + strings and returns a value indicating their relationship. Character + values between 65 and 90 (ASCII A--Z) are interpreted as values between 97 + and 122 (ASCII a--z). This function cannot be used for language-specific + sorting. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param first + the first string to be compared. Need not be null-terminated, but must be + at least as long as the specified firstLen. + + @param firstLen + the length of the first string. + + @param second + the second null-terminated ASCII string which is compared with the first + one. + + @param shortenedLen + the maximum number of characters to compare. This length can be greater + or smaller than the lengths of the two strings. + + @return + 0 if both substrings are equal, a value less than 0 if the first substring + is less than the second substring, and a value greater than 0 if the first + substring is greater than the second substring. + */ +sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( const sal_Unicode * first, sal_Int32 firstLen, const sal_Char * second, sal_Int32 shortenedLen ) SAL_THROW_EXTERN_C(); + +/** Return a hash code for a string. + + It is not allowed to store the hash code persistently, because later + versions could return other hash codes. The string must be + null-terminated. + + @param str + a null-terminated string. + + @return + a hash code for the given string. + */ +sal_Int32 SAL_CALL rtl_ustr_hashCode( const sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/** Return a hash code for a string. + + It is not allowed to store the hash code persistently, because later + versions could return other hash codes. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @return + a hash code for the given string. + */ +sal_Int32 SAL_CALL rtl_ustr_hashCode_WithLength( const sal_Unicode * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a character within a string. + + The string must be null-terminated. + + @param str + a null-terminated string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the first occurrence of the character in the + string, or -1 if the character does not occur. + */ +sal_Int32 SAL_CALL rtl_ustr_indexOfChar( const sal_Unicode * str, sal_Unicode ch ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a character within a string. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the first occurrence of the character in the + string, or -1 if the character does not occur. + */ +sal_Int32 SAL_CALL rtl_ustr_indexOfChar_WithLength( const sal_Unicode * str, sal_Int32 len, sal_Unicode ch ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a character within a string. + + The string must be null-terminated. + + @param str + a null-terminated string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the last occurrence of the character in the + string, or -1 if the character does not occur. The returned value is + always smaller than the string length. + */ +sal_Int32 SAL_CALL rtl_ustr_lastIndexOfChar( const sal_Unicode * str, sal_Unicode ch ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a character within a string. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param ch + the character to be searched for. + + @return + the index (starting at 0) of the last occurrence of the character in the + string, or -1 if the character does not occur. The returned value is + always smaller than the string length. + */ +sal_Int32 SAL_CALL rtl_ustr_lastIndexOfChar_WithLength( const sal_Unicode * str, sal_Int32 len, sal_Unicode ch ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + Both strings must be null-terminated. + + @param str + a null-terminated string. + + @param subStr + the null-terminated substring to be searched for. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_ustr_indexOfStr( const sal_Unicode * str, const sal_Unicode * subStr ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param subStr + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified subLen. + + @param subLen + the length of the substring. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_ustr_indexOfStr_WithLength( const sal_Unicode * str, sal_Int32 len, const sal_Unicode * subStr, sal_Int32 subLen ) SAL_THROW_EXTERN_C(); + +/** Search for the first occurrence of an ASCII substring within a string. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string; must be non-negative. + + @param subStr + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified subLen. Must only contain characters + in the ASCII range 0x00--7F. + + @param subLen + the length of the substring; must be non-negative. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within the string, or -1 if the substring does not occur. + If subLen is zero, -1 is returned. + + @since UDK 3.2.7 +*/ +sal_Int32 SAL_CALL rtl_ustr_indexOfAscii_WithLength( + sal_Unicode const * str, sal_Int32 len, + char const * subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + Both strings must be null-terminated. + + @param str + a null-terminated string. + + @param subStr + the null-terminated substring to be searched for. + + @return + the index (starting at 0) of the first character of the last occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_ustr_lastIndexOfStr( const sal_Unicode * str, const sal_Unicode * subStr ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of a substring within a string. + + If subStr is empty, or both str and subStr are empty, -1 is returned. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param subStr + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified subLen. + + @param subLen + the length of the substring. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within the string, or -1 if the substring does not occur. + */ +sal_Int32 SAL_CALL rtl_ustr_lastIndexOfStr_WithLength( const sal_Unicode * str, sal_Int32 len, const sal_Unicode * subStr, sal_Int32 subLen ) SAL_THROW_EXTERN_C(); + +/** Search for the last occurrence of an ASCII substring within a string. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string; must be non-negative. + + @param subStr + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified subLen. Must only contain characters + in the ASCII range 0x00--7F. + + @param subLen + the length of the substring; must be non-negative. + + @return + the index (starting at 0) of the first character of the last occurrence + of the substring within the string, or -1 if the substring does not occur. + If subLen is zero, -1 is returned. + + @since UDK 3.2.7 +*/ +sal_Int32 SAL_CALL rtl_ustr_lastIndexOfAscii_WithLength( + sal_Unicode const * str, sal_Int32 len, + char const * subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C(); + +/** Replace all occurrences of a single character within a string. + + If oldChar does not occur within str, then the string is not modified. + The string must be null-terminated. + + @param str + a null-terminated string. + + @param oldChar + the old character. + + @param newChar + the new character. + */ +void SAL_CALL rtl_ustr_replaceChar( sal_Unicode * str, sal_Unicode oldChar, sal_Unicode newChar ) SAL_THROW_EXTERN_C(); + +/** Replace all occurrences of a single character within a string. + + If oldChar does not occur within str, then the string is not modified. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + + @param oldChar + the old character. + + @param newChar + the new character. + */ +void SAL_CALL rtl_ustr_replaceChar_WithLength( sal_Unicode * str, sal_Int32 len, sal_Unicode oldChar, sal_Unicode newChar ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII uppercase letters to lowercase within a string. + + The characters with values between 65 and 90 (ASCII A--Z) are replaced + with values between 97 and 122 (ASCII a--z). The string must be + null-terminated. + + @param str + a null-terminated string. + */ +void SAL_CALL rtl_ustr_toAsciiLowerCase( sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII uppercase letters to lowercase within a string. + + The characters with values between 65 and 90 (ASCII A--Z) are replaced + with values between 97 and 122 (ASCII a--z). + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + */ +void SAL_CALL rtl_ustr_toAsciiLowerCase_WithLength( sal_Unicode * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII lowercase letters to uppercase within a string. + + The characters with values between 97 and 122 (ASCII a--z) are replaced + with values between 65 and 90 (ASCII A--Z). The string must be + null-terminated. + + @param str + a null-terminated string. + */ +void SAL_CALL rtl_ustr_toAsciiUpperCase( sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/** Convert all ASCII lowercase letters to uppercase within a string. + + The characters with values between 97 and 122 (ASCII a--z) are replaced + with values between 65 and 90 (ASCII A--Z). + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the length of the string. + */ +void SAL_CALL rtl_ustr_toAsciiUpperCase_WithLength( sal_Unicode * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Remove white space from both ends of a string. + + All characters with values less than or equal to 32 (the space character) + are considered to be white space. This function cannot be used for + language-specific operations. The string must be null-terminated. + + @param str + a null-terminated string. + + @return + the new length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_trim( sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/** Remove white space from both ends of the string. + + All characters with values less than or equal to 32 (the space character) + are considered to be white space. This function cannot be used for + language-specific operations. The string must be null-terminated. + + @param str + a string. Need not be null-terminated, but must be at least as long as + the specified len. + + @param len + the original length of the string. + + @return + the new length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_trim_WithLength( sal_Unicode * str, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Create the string representation of a boolean. + + If b is true, the buffer is filled with the string "true" and 5 is + returned. If b is false, the buffer is filled with the string "false" and + 6 is returned. This function cannot be used for language-specific + operations. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_USTR_MAX_VALUEOFBOOLEAN define to + create a buffer that is big enough. + + @param b + a boolean value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_valueOfBoolean( sal_Unicode * str, sal_Bool b ) SAL_THROW_EXTERN_C(); +#define RTL_USTR_MAX_VALUEOFBOOLEAN RTL_STR_MAX_VALUEOFBOOLEAN + +/** Create the string representation of a character. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_USTR_MAX_VALUEOFCHAR define to create a + buffer that is big enough. + + @param ch + a character value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_valueOfChar( sal_Unicode * str, sal_Unicode ch ) SAL_THROW_EXTERN_C(); +#define RTL_USTR_MAX_VALUEOFCHAR RTL_STR_MAX_VALUEOFCHAR + +/** Create the string representation of an integer. + + This function cannot be used for language-specific operations. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_USTR_MAX_VALUEOFINT32 define to create + a buffer that is big enough. + + @param i + an integer value. + + @param radix + the radix. Must be between RTL_USTR_MIN_RADIX (2) and RTL_USTR_MAX_RADIX + (36), inclusive. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_valueOfInt32( sal_Unicode * str, sal_Int32 i, sal_Int16 radix ) SAL_THROW_EXTERN_C(); +#define RTL_USTR_MIN_RADIX RTL_STR_MIN_RADIX +#define RTL_USTR_MAX_RADIX RTL_STR_MAX_RADIX +#define RTL_USTR_MAX_VALUEOFINT32 RTL_STR_MAX_VALUEOFINT32 + +/** Create the string representation of a long integer. + + This function cannot be used for language-specific operations. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_USTR_MAX_VALUEOFINT64 define to create + a buffer that is big enough. + + @param l + a long integer value. + + @param radix + the radix. Must be between RTL_USTR_MIN_RADIX (2) and RTL_USTR_MAX_RADIX + (36), inclusive. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_valueOfInt64( sal_Unicode * str, sal_Int64 l, sal_Int16 radix ) SAL_THROW_EXTERN_C(); +#define RTL_USTR_MAX_VALUEOFINT64 RTL_STR_MAX_VALUEOFINT64 + +/** Create the string representation of a float. + + This function cannot be used for language-specific conversion. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_USTR_MAX_VALUEOFFLOAT define to create + a buffer that is big enough. + + @param f + a float value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_valueOfFloat( sal_Unicode * str, float f ) SAL_THROW_EXTERN_C(); +#define RTL_USTR_MAX_VALUEOFFLOAT RTL_STR_MAX_VALUEOFFLOAT + +/** Create the string representation of a double. + + This function cannot be used for language-specific conversion. + + @param str + a buffer that is big enough to hold the result and the terminating NUL + character. You should use the RTL_USTR_MAX_VALUEOFDOUBLE define to create + a buffer that is big enough. + + @param d + a double value. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_ustr_valueOfDouble( sal_Unicode * str, double d ) SAL_THROW_EXTERN_C(); +#define RTL_USTR_MAX_VALUEOFDOUBLE RTL_STR_MAX_VALUEOFDOUBLE + +/** Interpret a string as a boolean. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @return + true if the string is "1" or "true" in any ASCII case, false otherwise. + */ +sal_Bool SAL_CALL rtl_ustr_toBoolean( const sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as an integer. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @param radix + the radix. Must be between RTL_USTR_MIN_RADIX (2) and RTL_USTR_MAX_RADIX + (36), inclusive. + + @return + the integer value represented by the string, or 0 if the string does not + represent an integer. + */ +sal_Int32 SAL_CALL rtl_ustr_toInt32( const sal_Unicode * str, sal_Int16 radix ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as a long integer. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @param radix + the radix. Must be between RTL_USTR_MIN_RADIX (2) and RTL_USTR_MAX_RADIX + (36), inclusive. + + @return + the long integer value represented by the string, or 0 if the string does + not represent a long integer. + */ +sal_Int64 SAL_CALL rtl_ustr_toInt64( const sal_Unicode * str, sal_Int16 radix ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as a float. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @return + the float value represented by the string, or 0.0 if the string does not + represent a float. + */ +float SAL_CALL rtl_ustr_toFloat( const sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/** Interpret a string as a double. + + This function cannot be used for language-specific conversion. The string + must be null-terminated. + + @param str + a null-terminated string. + + @return + the float value represented by the string, or 0.0 if the string does not + represent a double. + */ +double SAL_CALL rtl_ustr_toDouble( const sal_Unicode * str ) SAL_THROW_EXTERN_C(); + +/* ======================================================================= */ + +#if defined( SAL_W32) || defined(SAL_OS2) +#pragma pack(push, 4) +#endif + +/** The implementation of a Unicode string. + + @internal +*/ +typedef struct _rtl_uString +{ + oslInterlockedCount refCount; /* opaque */ + sal_Int32 length; + sal_Unicode buffer[1]; +} rtl_uString; + +#if defined( SAL_W32) || defined(SAL_OS2) +#pragma pack(pop) +#endif + +/* ----------------------------------------------------------------------- */ + +/** Increment the reference count of a string. + + @param str + a string. + */ +void SAL_CALL rtl_uString_acquire( rtl_uString * str ) SAL_THROW_EXTERN_C(); + +/** Decrement the reference count of a string. + + If the count goes to zero than the string data is deleted. + + @param str + a string. + */ +void SAL_CALL rtl_uString_release( rtl_uString * str ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string containing no characters. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + */ +void SAL_CALL rtl_uString_new( rtl_uString ** newStr ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string containing space for a given number of characters. + + If len is greater than zero, the reference count of the new string will be + 1. The values of all characters are set to 0 and the length of the string + is 0. This function does not handle out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param len + the number of characters. + */ +void SAL_CALL rtl_uString_new_WithLength( rtl_uString ** newStr, sal_Int32 nLen ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string that contains a copy of another string. + + If the length of value is greater than zero, the reference count of the + new string will be 1. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param value + a valid string. + */ +void SAL_CALL rtl_uString_newFromString( rtl_uString ** newStr, const rtl_uString * value ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string that contains a copy of a character array. + + If the length of value is greater than zero, the reference count of the + new string will be 1. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param value + a null-terminated character array. + */ +void SAL_CALL rtl_uString_newFromStr( rtl_uString ** newStr, const sal_Unicode * value ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string that contains a copy of a character array. + + If the length of value is greater than zero, the reference count of the + new string will be 1. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param value + a character array. Need not be null-terminated, but must be at least as + long as the specified len. + + @param len + the length of the character array. + */ +void SAL_CALL rtl_uString_newFromStr_WithLength( rtl_uString ** newStr, const sal_Unicode * value, sal_Int32 len ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string that contains a copy of a character array. + + If the length of value is greater than zero, the reference count of the + new string will be 1. This function does not handle out-of-memory + conditions. + + Since this function is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range of 0 and 127, inclusive. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param value + a null-terminated ASCII character array. + */ +void SAL_CALL rtl_uString_newFromAscii( rtl_uString ** newStr, const sal_Char * value ) SAL_THROW_EXTERN_C(); + +/** Allocate a new string from an array of Unicode code points. + + @param newString + a non-null pointer to a (possibly null) rtl_uString pointer, which (if + non-null) will have been passed to rtl_uString_release before the function + returns. Upon return, points to the newly allocated string or to null if + there was either an out-of-memory condition or the resulting number of + UTF-16 code units would have been larger than SAL_MAX_INT32. The newly + allocated string (if any) must ultimately be passed to rtl_uString_release. + + @param codePoints + an array of at least codePointCount code points, which each must be in the + range from 0 to 0x10FFFF, inclusive. May be null if codePointCount is zero. + + @param codePointCount + the non-negative number of code points. + + @since UDK 3.2.7 +*/ +void SAL_CALL rtl_uString_newFromCodePoints( + rtl_uString ** newString, sal_uInt32 const * codePoints, + sal_Int32 codePointCount) SAL_THROW_EXTERN_C(); + +/** Assign a new value to a string. + + First releases any value str might currently hold, then acquires + rightValue. + + @param str + pointer to the string. The pointed-to data must be null or a valid + string. + + @param rightValue + a valid string. + */ +void SAL_CALL rtl_uString_assign( rtl_uString ** str, rtl_uString * rightValue ) SAL_THROW_EXTERN_C(); + +/** Return the length of a string. + + The length is equal to the number of characters in the string. + + @param str + a valid string. + + @return + the length of the string. + */ +sal_Int32 SAL_CALL rtl_uString_getLength( const rtl_uString * str ) SAL_THROW_EXTERN_C(); + +/** Return a pointer to the underlying character array of a string. + + @param str + a valid string. + + @return + a pointer to the null-terminated character array. + */ +sal_Unicode * SAL_CALL rtl_uString_getStr( rtl_uString * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string that is the concatenation of two other strings. + + The new string does not necessarily have a reference count of 1 (in cases + where one of the two other strings is empty), so it must not be modified + without checking the reference count. This function does not handle + out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param left + a valid string. + + @param right + a valid string. + */ +void SAL_CALL rtl_uString_newConcat( rtl_uString ** newStr, rtl_uString * left, rtl_uString * right ) SAL_THROW_EXTERN_C(); + +/** Create a new string by replacing a substring of another string. + + The new string results from replacing a number of characters (count), + starting at the specified position (index) in the original string (str), + with some new substring (subStr). If subStr is null, than only a number + of characters is deleted. + + The new string does not necessarily have a reference count of 1, so it + must not be modified without checking the reference count. This function + does not handle out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + + @param index + the index into str at which to start replacement. Must be between 0 and + the length of str, inclusive. + + @param count + the number of charcters to remove. Must not be negative, and the sum of + index and count must not exceed the length of str. + + @param subStr + either null or a valid string to be inserted. + */ +void SAL_CALL rtl_uString_newReplaceStrAt( rtl_uString ** newStr, rtl_uString * str, sal_Int32 idx, sal_Int32 count, rtl_uString * subStr ) SAL_THROW_EXTERN_C(); + +/** Create a new string by replacing all occurrences of a single character + within another string. + + The new string results from replacing all occurrences of oldChar in str + with newChar. + + The new string does not necessarily have a reference count of 1 (in cases + where oldChar does not occur in str), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + + @param oldChar + the old character. + + @param newChar + the new character. + */ +void SAL_CALL rtl_uString_newReplace( rtl_uString ** newStr, rtl_uString * str, sal_Unicode oldChar, sal_Unicode newChar ) SAL_THROW_EXTERN_C(); + +/** Create a new string by converting all ASCII uppercase letters to lowercase + within another string. + + The new string results from replacing all characters with values between + 65 and 90 (ASCII A--Z) by values between 97 and 122 (ASCII a--z). + + This function cannot be used for language-specific conversion. The new + string does not necessarily have a reference count of 1 (in cases where + no characters need to be converted), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + */ +void SAL_CALL rtl_uString_newToAsciiLowerCase( rtl_uString ** newStr, rtl_uString * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string by converting all ASCII lowercase letters to uppercase + within another string. + + The new string results from replacing all characters with values between + 97 and 122 (ASCII a--z) by values between 65 and 90 (ASCII A--Z). + + This function cannot be used for language-specific conversion. The new + string does not necessarily have a reference count of 1 (in cases where + no characters need to be converted), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + */ +void SAL_CALL rtl_uString_newToAsciiUpperCase( rtl_uString ** newStr, rtl_uString * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string by removing white space from both ends of another + string. + + The new string results from removing all characters with values less than + or equal to 32 (the space character) form both ends of str. + + This function cannot be used for language-specific conversion. The new + string does not necessarily have a reference count of 1 (in cases where + no characters need to be removed), so it must not be modified without + checking the reference count. This function does not handle out-of-memory + conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a valid string. + */ +void SAL_CALL rtl_uString_newTrim( rtl_uString ** newStr, rtl_uString * str ) SAL_THROW_EXTERN_C(); + +/** Create a new string by extracting a single token from another string. + + Starting at index, the token's next token is searched for. If there is no + such token, the result is an empty string. Otherwise, all characters from + the start of that token and up to, but not including the next occurrence + of cTok make up the resulting token. The return value is the position of + the next token, or -1 if no more tokens follow. + + Example code could look like + rtl_uString * pToken = NULL; + sal_Int32 nIndex = 0; + do + { + ... + nIndex = rtl_uString_getToken(&pToken, pStr, 0, ';', nIndex); + ... + } + while (nIndex >= 0); + + The new string does not necessarily have a reference count of 1, so it + must not be modified without checking the reference count. This function + does not handle out-of-memory conditions. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. If either token or index is negative, an empty token is stored in + newStr (and -1 is returned). + + @param str + a valid string. + + @param token + the number of the token to return, starting at index. + + @param cTok + the character that seperates the tokens. + + @param index + the position at which searching for the token starts. Must not be greater + than the length of str. + + @return + the index of the next token, or -1 if no more tokens follow. + */ +sal_Int32 SAL_CALL rtl_uString_getToken( rtl_uString ** newStr , rtl_uString * str, sal_Int32 token, sal_Unicode cTok, sal_Int32 idx ) SAL_THROW_EXTERN_C(); + +/* ======================================================================= */ + +/** Supply an ASCII string literal together with its length and text encoding. + + This macro can be used to compute (some of) the arguments in function calls + like rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foo")). + + @param constAsciiStr + must be an expression of type "(possibly cv-qualified reference to) array of + (possibly cv-qualified) char." Each element of the referenced array must + represent an ASCII value in the range 0x00--0x7F. The last element of the + referenced array is not considered part of the represented ASCII string, and + its value should be 0x00. Depending on where this macro is used, the nature + of the supplied expression might be further restricted. +*/ +#define RTL_CONSTASCII_USTRINGPARAM( constAsciiStr ) constAsciiStr, ((sal_Int32)(sizeof(constAsciiStr)-1)), RTL_TEXTENCODING_ASCII_US + +/* ======================================================================= */ + +/* predefined constants for String-Conversion */ +#define OSTRING_TO_OUSTRING_CVTFLAGS (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE |\ + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |\ + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT) + +/* ----------------------------------------------------------------------- */ + +/** Create a new Unicode string by converting a byte string, using a specific + text encoding. + + The lengths of the byte string and the Unicode string may differ (e.g., + for double-byte encodings, UTF-7, UTF-8). + + If the length of the byte string is greater than zero, the reference count + of the new string will be 1. + + If an out-of-memory condition occurs, newStr will point to a null pointer + upon return. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + @param str + a byte character array. Need not be null-terminated, but must be at + least as long as the specified len. + + @param len + the length of the byte character array. + + @param encoding + the text encoding to use for conversion. + + @param convertFlags + flags which control the conversion. Either use + OSTRING_TO_OUSTRING_CVTFLAGS, or see + <http://udk.openoffice.org/cpp/man/spec/textconversion.html> for more + details. + */ +void SAL_CALL rtl_string2UString( rtl_uString ** newStr, const sal_Char * str, sal_Int32 len, rtl_TextEncoding encoding, sal_uInt32 convertFlags ) SAL_THROW_EXTERN_C(); + +/* ======================================================================= */ +/* Interning methods */ + +/** Return a canonical representation for a string. + + A pool of strings, initially empty is maintained privately + by the string class. On invocation, if present in the pool + the original string will be returned. Otherwise this string, + or a copy thereof will be added to the pool and returned. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + If an out-of-memory condition occurs, newStr will point to a null pointer + upon return. + + @param str + pointer to the string to be interned. + + @since UDK 3.2.7 + */ +void SAL_CALL rtl_uString_intern( rtl_uString ** newStr, + rtl_uString * str) SAL_THROW_EXTERN_C(); + +/** Return a canonical representation for a string. + + A pool of strings, initially empty is maintained privately + by the string class. On invocation, if present in the pool + the original string will be returned. Otherwise this string, + or a copy thereof will be added to the pool and returned. + + @param newStr + pointer to the new string. The pointed-to data must be null or a valid + string. + + If an out-of-memory condition occurs, newStr will point to a null pointer + upon return. + + @param str + a byte character array. Need not be null-terminated, but must be at + least as long as the specified len. + + @param len + the length of the byte character array. + + @param encoding + the text encoding to use for conversion. + + @param convertFlags + flags which control the conversion. Either use + OSTRING_TO_OUSTRING_CVTFLAGS, or see + <http://udk.openoffice.org/cpp/man/spec/textconversion.html> for more + details. + + @param pInfo + pointer to return conversion status in, or NULL. + + @since UDK 3.2.7 + */ +void SAL_CALL rtl_uString_internConvert( rtl_uString ** newStr, + const sal_Char * str, + sal_Int32 len, + rtl_TextEncoding encoding, + sal_uInt32 convertFlags, + sal_uInt32 *pInfo) SAL_THROW_EXTERN_C(); + +/** Iterate through a string based on code points instead of UTF-16 code units. + + See Chapter 3 of The Unicode Standard 5.0 (Addison--Wesley, 2006) for + definitions of the various terms used in this description. + + The given string is interpreted as a sequence of zero or more UTF-16 code + units. For each index into this sequence (from zero to one less than the + length of the sequence, inclusive), a code point represented starting at the + given index is computed as follows: + + - If the UTF-16 code unit addressed by the index constitutes a well-formed + UTF-16 code unit sequence, the computed code point is the scalar value + encoded by that UTF-16 code unit sequence. + + - Otherwise, if the index is at least two UTF-16 code units away from the + end of the sequence, and the sequence of two UTF-16 code units addressed by + the index constitutes a well-formed UTF-16 code unit sequence, the computed + code point is the scalar value encoded by that UTF-16 code unit sequence. + + - Otherwise, the computed code point is the UTF-16 code unit addressed by + the index. (This last case catches unmatched surrogates as well as indices + pointing into the middle of surrogate pairs.) + + @param string + pointer to a valid string; must not be null. + + @param indexUtf16 + pointer to a UTF-16 based index into the given string; must not be null. On + entry, the index must be in the range from zero to the length of the string + (in UTF-16 code units), inclusive. Upon successful return, the index will + be updated to address the UTF-16 code unit that is the given + incrementCodePoints away from the initial index. + + @param incrementCodePoints + the number of code points to move the given *indexUtf16. If non-negative, + moving is done after determining the code point at the index. If negative, + moving is done before determining the code point at the (then updated) + index. The value must be such that the resulting UTF-16 based index is in + the range from zero to the length of the string (in UTF-16 code units), + inclusive. + + @return + the code point (an integer in the range from 0 to 0x10FFFF, inclusive) that + is represented within the string starting at the index computed as follows: + If incrementCodePoints is non-negative, the index is the initial value of + *indexUtf16; if incrementCodePoints is negative, the index is the updated + value of *indexUtf16. In either case, the computed index must be in the + range from zero to one less than the length of the string (in UTF-16 code + units), inclusive. + + @since UDK 3.2.7 +*/ +sal_uInt32 SAL_CALL rtl_uString_iterateCodePoints( + rtl_uString const * string, sal_Int32 * indexUtf16, + sal_Int32 incrementCodePoints); + +/** Converts a byte string to a Unicode string, signalling failure. + + @param target + An out parameter receiving the converted string. Must not be null itself, + and must contain either null or a pointer to a valid rtl_uString; the + contents are unspecified if conversion fails (rtl_convertStringToUString + returns false). + + @param source + The byte string. May only be null if length is zero. + + @param length + The length of the byte string. Must be non-negative. + + @param encoding + The text encoding to convert from. Must be an octet encoding (i.e., + rtl_isOctetTextEncoding(encoding) must return true). + + @param flags + A combination of RTL_TEXTTOUNICODE_FLAGS that detail how to do the + conversion (see rtl_convertTextToUnicode). RTL_TEXTTOUNICODE_FLAGS_FLUSH + need not be included, it is implicitly assumed. Typical uses are either + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR | + RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR (fail if a byte or multi-byte sequence + cannot be converted from the source encoding) or + OSTRING_TO_OUSTRING_CVTFLAGS (make a best efforts conversion). + + @return + True if the conversion succeeded, false otherwise. + + @since UDK 3.2.9 +*/ +sal_Bool SAL_CALL rtl_convertStringToUString( + rtl_uString ** target, char const * source, sal_Int32 length, + rtl_TextEncoding encoding, sal_uInt32 flags) SAL_THROW_EXTERN_C(); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTL_USTRING_H_ */ diff --git a/sal/inc/rtl/ustring.hxx b/sal/inc/rtl/ustring.hxx new file mode 100644 index 000000000000..9a2ef8b9edc9 --- /dev/null +++ b/sal/inc/rtl/ustring.hxx @@ -0,0 +1,1540 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _RTL_USTRING_HXX_ +#define _RTL_USTRING_HXX_ + +#ifdef __cplusplus + +#ifndef _RTL_DIAGNOSE_H_ +#include "osl/diagnose.h" +#endif +#include <rtl/ustring.h> +#include <rtl/string.hxx> +#include <rtl/memory.h> + +#if defined EXCEPTIONS_OFF +#include <stdlib.h> +#else +#include <new> +#endif + +namespace rtl +{ +/* ======================================================================= */ + +/** + This String class provide base functionality for C++ like Unicode + character array handling. The advantage of this class is, that it + handle all the memory managament for you - and it do it + more efficient. If you assign a string to another string, the + data of both strings are shared (without any copy operation or + memory allocation) as long as you do not change the string. This class + stores also the length of the string, so that many operations are + faster as the C-str-functions. + + This class provide only readonly string handling. So you could create + a string and you could only query the content from this string. + It provide also functionality to change the string, but this results + in every case in a new string instance (in the most cases with an + memory allocation). You don't have functionality to change the + content of the string. If you want change the string content, than + you should us the OStringBuffer class, which provide these + functionality and avoid to much memory allocation. + + The design of this class is similar to the string classes in Java + and so more people should have fewer understanding problems when they + use this class. +*/ + +class OUString +{ +public: + /** @internal */ + rtl_uString * pData; + +private: + /** @internal */ + class DO_NOT_ACQUIRE{}; + + /** @internal */ + OUString( rtl_uString * value, DO_NOT_ACQUIRE * ) + { + pData = value; + } + +public: + /** + New string containing no characters. + */ + OUString() SAL_THROW(()) + { + pData = 0; + rtl_uString_new( &pData ); + } + + /** + New string from OUString. + + @param str a OUString. + */ + OUString( const OUString & str ) SAL_THROW(()) + { + pData = str.pData; + rtl_uString_acquire( pData ); + } + + /** + New string from OUString data. + + @param str a OUString data. + */ + OUString( rtl_uString * str ) SAL_THROW(()) + { + pData = str; + rtl_uString_acquire( pData ); + } + /** New OUString from OUString data without acquiring it. Takeover of ownership. + + @param str + OUString data + @param dummy + SAL_NO_ACQUIRE to distinguish from other ctors + */ + inline OUString( rtl_uString * str, __sal_NoAcquire ) SAL_THROW( () ) + { pData = str; } + + + /** + New string from a single Unicode character. + + @param value a Unicode character. + */ + explicit OUString( sal_Unicode value ) SAL_THROW(()) + : pData (0) + { + rtl_uString_newFromStr_WithLength( &pData, &value, 1 ); + } + + /** + New string from a Unicode character buffer array. + + @param value a NULL-terminated Unicode character array. + */ + OUString( const sal_Unicode * value ) SAL_THROW(()) + { + pData = 0; + rtl_uString_newFromStr( &pData, value ); + } + + /** + New string from a Uniocde character buffer array. + + @param value a Unicode character array. + @param length the number of character which should be copied. + The character array length must be greater or + equal than this value. + */ + OUString( const sal_Unicode * value, sal_Int32 length ) SAL_THROW(()) + { + pData = 0; + rtl_uString_newFromStr_WithLength( &pData, value, length ); + } + + /** + New string from a 8-Bit character buffer array. + + @param value a 8-Bit character array. + @param length the number of character which should be converted. + The 8-Bit character array length must be + greater or equal than this value. + @param encoding the text encoding from which the 8-Bit character + sequence should be converted. + @param convertFlags flags which controls the conversion. + see RTL_TEXTTOUNICODE_FLAGS_... + + @exception std::bad_alloc is thrown if an out-of-memory condition occurs + */ + OUString( const sal_Char * value, sal_Int32 length, + rtl_TextEncoding encoding, + sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS ) + { + pData = 0; + rtl_string2UString( &pData, value, length, encoding, convertFlags ); +#if defined EXCEPTIONS_OFF + OSL_ASSERT(pData != NULL); +#else + if (pData == 0) { + throw std::bad_alloc(); + } +#endif + } + + /** Create a new string from an array of Unicode code points. + + @param codePoints + an array of at least codePointCount code points, which each must be in + the range from 0 to 0x10FFFF, inclusive. May be null if codePointCount + is zero. + + @param codePointCount + the non-negative number of code points. + + @exception std::bad_alloc + is thrown if either an out-of-memory condition occurs or the resulting + number of UTF-16 code units would have been larger than SAL_MAX_INT32. + + @since UDK 3.2.7 + */ + inline explicit OUString( + sal_uInt32 const * codePoints, sal_Int32 codePointCount): + pData(NULL) + { + rtl_uString_newFromCodePoints(&pData, codePoints, codePointCount); + if (pData == NULL) { +#if defined EXCEPTIONS_OFF + abort(); +#else + throw std::bad_alloc(); +#endif + } + } + + /** + Release the string data. + */ + ~OUString() SAL_THROW(()) + { + rtl_uString_release( pData ); + } + + /** Provides an OUString const & passing a storage pointer of an + rtl_uString * handle. + It is more convenient to use C++ OUString member functions when dealing + with rtl_uString * handles. Using this function avoids unnecessary + acquire()/release() calls for a temporary OUString object. + + @param ppHandle + pointer to storage + @return + OUString const & based on given storage + */ + static inline OUString const & unacquired( rtl_uString * const * ppHandle ) + { return * reinterpret_cast< OUString const * >( ppHandle ); } + + /** + Assign a new string. + + @param str a OUString. + */ + OUString & operator=( const OUString & str ) SAL_THROW(()) + { + rtl_uString_assign( &pData, str.pData ); + return *this; + } + + /** + Append a string to this string. + + @param str a OUString. + */ + OUString & operator+=( const OUString & str ) SAL_THROW(()) + { + rtl_uString_newConcat( &pData, pData, str.pData ); + return *this; + } + + /** + Returns the length of this string. + + The length is equal to the number of Unicode characters in this string. + + @return the length of the sequence of characters represented by this + object. + */ + sal_Int32 getLength() const SAL_THROW(()) { return pData->length; } + + /** + Returns a pointer to the Unicode character buffer from this string. + + It isn't necessarily NULL terminated. + + @return a pointer to the Unicode characters buffer from this object. + */ + operator const sal_Unicode *() const SAL_THROW(()) { return pData->buffer; } + + /** + Returns a pointer to the Unicode character buffer from this string. + + It isn't necessarily NULL terminated. + + @return a pointer to the Unicode characters buffer from this object. + */ + const sal_Unicode * getStr() const SAL_THROW(()) { return pData->buffer; } + + /** + Compares two strings. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + This function can't be used for language specific sorting. + + @param str the object to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 compareTo( const OUString & str ) const SAL_THROW(()) + { + return rtl_ustr_compare_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ); + } + + /** + Compares two strings with an maximum count of characters. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + This function can't be used for language specific sorting. + + @param str the object to be compared. + @param maxLength the maximum count of characters to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 compareTo( const OUString & str, sal_Int32 maxLength ) const SAL_THROW(()) + { + return rtl_ustr_shortenedCompare_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length, maxLength ); + } + + /** + Compares two strings in reverse order. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + This function can't be used for language specific sorting. + + @param str the object to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 reverseCompareTo( const OUString & str ) const SAL_THROW(()) + { + return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ); + } + + /** + Perform a comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string. + This function can't be used for language specific comparison. + + @param str the object to be compared. + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equals( const OUString & str ) const SAL_THROW(()) + { + if ( pData->length != str.pData->length ) + return sal_False; + if ( pData == str.pData ) + return sal_True; + return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ) == 0; + } + + /** + Perform a ASCII lowercase comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string, + ignoring the case. + Character values between 65 and 90 (ASCII A-Z) are interpreted as + values between 97 and 122 (ASCII a-z). + This function can't be used for language specific comparison. + + @param str the object to be compared. + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equalsIgnoreAsciiCase( const OUString & str ) const SAL_THROW(()) + { + if ( pData->length != str.pData->length ) + return sal_False; + if ( pData == str.pData ) + return sal_True; + return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ) == 0; + } + + /** + Match against a substring appearing in this string. + + The result is true if and only if the second string appears as a substring + of this string, at the given position. + This function can't be used for language specific comparison. + + @param str the object (substring) to be compared. + @param fromIndex the index to start the comparion from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return sal_True if str match with the characters in the string + at the given position; + sal_False, otherwise. + */ + sal_Bool match( const OUString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + return rtl_ustr_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + str.pData->buffer, str.pData->length, str.pData->length ) == 0; + } + + /** + Match against a substring appearing in this string, ignoring the case of + ASCII letters. + + The result is true if and only if the second string appears as a substring + of this string, at the given position. + Character values between 65 and 90 (ASCII A-Z) are interpreted as + values between 97 and 122 (ASCII a-z). + This function can't be used for language specific comparison. + + @param str the object (substring) to be compared. + @param fromIndex the index to start the comparion from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return sal_True if str match with the characters in the string + at the given position; + sal_False, otherwise. + */ + sal_Bool matchIgnoreAsciiCase( const OUString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + return rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + str.pData->buffer, str.pData->length, + str.pData->length ) == 0; + } + + /** + Compares two strings. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated. + This function can't be used for language specific sorting. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 compareToAscii( const sal_Char* asciiStr ) const SAL_THROW(()) + { + return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length, asciiStr ); + } + + /** + Compares two strings with an maximum count of characters. + + The comparison is based on the numeric value of each character in + the strings and return a value indicating their relationship. + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated. + This function can't be used for language specific sorting. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @param maxLength the maximum count of characters to be compared. + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 compareToAscii( const sal_Char * asciiStr, sal_Int32 maxLength ) const SAL_THROW(()) + { + return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer, pData->length, + asciiStr, maxLength ); + } + + /** + Compares two strings in reverse order. + + This could be useful, if normally both strings start with the same + content. The comparison is based on the numeric value of each character + in the strings and return a value indicating their relationship. + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated and must be greater or + equal as asciiStrLength. + This function can't be used for language specific sorting. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @param asciiStrLength the length of the ascii string + @return 0 - if both strings are equal + < 0 - if this string is less than the string argument + > 0 - if this string is greater than the string argument + */ + sal_Int32 reverseCompareToAsciiL( const sal_Char * asciiStr, sal_Int32 asciiStrLength ) const SAL_THROW(()) + { + return rtl_ustr_asciil_reverseCompare_WithLength( pData->buffer, pData->length, + asciiStr, asciiStrLength ); + } + + /** + Perform a comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string. + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated. + This function can't be used for language specific comparison. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equalsAscii( const sal_Char* asciiStr ) const SAL_THROW(()) + { + return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length, + asciiStr ) == 0; + } + + /** + Perform a comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string. + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated and must be greater or + equal as asciiStrLength. + This function can't be used for language specific comparison. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @param asciiStrLength the length of the ascii string + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equalsAsciiL( const sal_Char* asciiStr, sal_Int32 asciiStrLength ) const SAL_THROW(()) + { + if ( pData->length != asciiStrLength ) + return sal_False; + + return rtl_ustr_asciil_reverseEquals_WithLength( + pData->buffer, asciiStr, asciiStrLength ); + } + + /** + Perform a ASCII lowercase comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string, + ignoring the case. + Character values between 65 and 90 (ASCII A-Z) are interpreted as + values between 97 and 122 (ASCII a-z). + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated. + This function can't be used for language specific comparison. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equalsIgnoreAsciiCaseAscii( const sal_Char * asciiStr ) const SAL_THROW(()) + { + return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0; + } + + /** + Perform a ASCII lowercase comparison of two strings. + + The result is true if and only if second string + represents the same sequence of characters as the first string, + ignoring the case. + Character values between 65 and 90 (ASCII A-Z) are interpreted as + values between 97 and 122 (ASCII a-z). + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated and must be greater or + equal as asciiStrLength. + This function can't be used for language specific comparison. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @param asciiStrLength the length of the ascii string + @return sal_True if the strings are equal; + sal_False, otherwise. + */ + sal_Bool equalsIgnoreAsciiCaseAsciiL( const sal_Char * asciiStr, sal_Int32 asciiStrLength ) const SAL_THROW(()) + { + if ( pData->length != asciiStrLength ) + return sal_False; + + return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0; + } + + /** + Match against a substring appearing in this string. + + The result is true if and only if the second string appears as a substring + of this string, at the given position. + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated and must be greater or + equal as asciiStrLength. + This function can't be used for language specific comparison. + + @param str the object (substring) to be compared. + @param fromIndex the index to start the comparion from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return sal_True if str match with the characters in the string + at the given position; + sal_False, otherwise. + */ + sal_Bool matchAsciiL( const sal_Char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + asciiStr, asciiStrLength ) == 0; + } + + /** + Match against a substring appearing in this string, ignoring the case of + ASCII letters. + + The result is true if and only if the second string appears as a substring + of this string, at the given position. + Character values between 65 and 90 (ASCII A-Z) are interpreted as + values between 97 and 122 (ASCII a-z). + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated and must be greater or + equal as asciiStrLength. + This function can't be used for language specific comparison. + + @param asciiStr the 8-Bit ASCII character string to be compared. + @param asciiStrLength the length of the ascii string + @param fromIndex the index to start the comparion from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return sal_True if str match with the characters in the string + at the given position; + sal_False, otherwise. + */ + sal_Bool matchIgnoreAsciiCaseAsciiL( const sal_Char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + asciiStr, asciiStrLength ) == 0; + } + + /** + Check whether this string ends with a given ASCII string. + + @param asciiStr a sequence of at least asciiStrLength ASCII characters + (bytes in the range 0x00--0x7F) + @param asciiStrLen the length of asciiStr; must be non-negative + @return true if this string ends with asciiStr; otherwise, false is + returned + + @since UDK 3.2.7 + */ + inline bool endsWithAsciiL(char const * asciiStr, sal_Int32 asciiStrLength) + const + { + return asciiStrLength <= pData->length + && rtl_ustr_asciil_reverseEquals_WithLength( + pData->buffer + pData->length - asciiStrLength, asciiStr, + asciiStrLength); + } + + /** + Check whether this string ends with a given ASCII string, ignoring the + case of ASCII letters. + + @param asciiStr a sequence of at least asciiStrLength ASCII characters + (bytes in the range 0x00--0x7F) + @param asciiStrLen the length of asciiStr; must be non-negative + @return true if this string ends with asciiStr, ignoring the case of ASCII + letters ("A"--"Z" and "a"--"z"); otherwise, false is returned + */ + inline bool endsWithIgnoreAsciiCaseAsciiL( + char const * asciiStr, sal_Int32 asciiStrLength) const + { + return asciiStrLength <= pData->length + && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths( + pData->buffer + pData->length - asciiStrLength, + asciiStrLength, asciiStr, asciiStrLength) + == 0); + } + + friend sal_Bool operator == ( const OUString& rStr1, const OUString& rStr2 ) SAL_THROW(()) + { return rStr1.getLength() == rStr2.getLength() && rStr1.compareTo( rStr2 ) == 0; } + friend sal_Bool operator == ( const OUString& rStr1, const sal_Unicode * pStr2 ) SAL_THROW(()) + { return rStr1.compareTo( pStr2 ) == 0; } + friend sal_Bool operator == ( const sal_Unicode * pStr1, const OUString& rStr2 ) SAL_THROW(()) + { return OUString( pStr1 ).compareTo( rStr2 ) == 0; } + + friend sal_Bool operator != ( const OUString& rStr1, const OUString& rStr2 ) SAL_THROW(()) + { return !(operator == ( rStr1, rStr2 )); } + friend sal_Bool operator != ( const OUString& rStr1, const sal_Unicode * pStr2 ) SAL_THROW(()) + { return !(operator == ( rStr1, pStr2 )); } + friend sal_Bool operator != ( const sal_Unicode * pStr1, const OUString& rStr2 ) SAL_THROW(()) + { return !(operator == ( pStr1, rStr2 )); } + + friend sal_Bool operator < ( const OUString& rStr1, const OUString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) < 0; } + friend sal_Bool operator > ( const OUString& rStr1, const OUString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) > 0; } + friend sal_Bool operator <= ( const OUString& rStr1, const OUString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) <= 0; } + friend sal_Bool operator >= ( const OUString& rStr1, const OUString& rStr2 ) SAL_THROW(()) + { return rStr1.compareTo( rStr2 ) >= 0; } + + /** + Returns a hashcode for this string. + + @return a hash code value for this object. + + @see rtl::OUStringHash for convenient use of STLPort's hash_map + */ + sal_Int32 hashCode() const SAL_THROW(()) + { + return rtl_ustr_hashCode_WithLength( pData->buffer, pData->length ); + } + + /** + Returns the index within this string of the first occurrence of the + specified character, starting the search at the specified index. + + @param ch character to be located. + @param fromIndex the index to start the search from. + The index must be greater or equal than 0 + and less or equal as the string length. + @return the index of the first occurrence of the character in the + character sequence represented by this string that is + greater than or equal to fromIndex, or + -1 if the character does not occur. + */ + sal_Int32 indexOf( sal_Unicode ch, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + sal_Int32 ret = rtl_ustr_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch ); + return (ret < 0 ? ret : ret+fromIndex); + } + + /** + Returns the index within this string of the last occurrence of the + specified character, searching backward starting at the end. + + @param ch character to be located. + @return the index of the last occurrence of the character in the + character sequence represented by this string, or + -1 if the character does not occur. + */ + sal_Int32 lastIndexOf( sal_Unicode ch ) const SAL_THROW(()) + { + return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch ); + } + + /** + Returns the index within this string of the last occurrence of the + specified character, searching backward starting before the specified + index. + + @param ch character to be located. + @param fromIndex the index before which to start the search. + @return the index of the last occurrence of the character in the + character sequence represented by this string that + is less than fromIndex, or -1 + if the character does not occur before that point. + */ + sal_Int32 lastIndexOf( sal_Unicode ch, sal_Int32 fromIndex ) const SAL_THROW(()) + { + return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch ); + } + + /** + Returns the index within this string of the first occurrence of the + specified substring, starting at the specified index. + + If str doesn't include any character, always -1 is + returned. This is also the case, if both strings are empty. + + @param str the substring to search for. + @param fromIndex the index to start the search from. + @return If the string argument occurs one or more times as a substring + within this string at the starting index, then the index + of the first character of the first such substring is + returned. If it does not occur as a substring starting + at fromIndex or beyond, -1 is returned. + */ + sal_Int32 indexOf( const OUString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(()) + { + sal_Int32 ret = rtl_ustr_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, + str.pData->buffer, str.pData->length ); + return (ret < 0 ? ret : ret+fromIndex); + } + + /** + Returns the index within this string of the first occurrence of the + specified ASCII substring, starting at the specified index. + + @param str + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified len. Must only contain characters + in the ASCII range 0x00--7F. + + @param len + the length of the substring; must be non-negative. + + @param fromIndex + the index to start the search from. Must be in the range from zero to + the length of this string, inclusive. + + @return + the index (starting at 0) of the first character of the first occurrence + of the substring within this string starting at the given fromIndex, or + -1 if the substring does not occur. If len is zero, -1 is returned. + + @since UDK 3.2.7 + */ + sal_Int32 indexOfAsciiL( + char const * str, sal_Int32 len, sal_Int32 fromIndex = 0) const + SAL_THROW(()) + { + sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength( + pData->buffer + fromIndex, pData->length - fromIndex, str, len); + return ret < 0 ? ret : ret + fromIndex; + } + + /** + Returns the index within this string of the last occurrence of + the specified substring, searching backward starting at the end. + + The returned index indicates the starting index of the substring + in this string. + If str doesn't include any character, always -1 is + returned. This is also the case, if both strings are empty. + + @param str the substring to search for. + @return If the string argument occurs one or more times as a substring + within this string, then the index of the first character of + the last such substring is returned. If it does not occur as + a substring, -1 is returned. + */ + sal_Int32 lastIndexOf( const OUString & str ) const SAL_THROW(()) + { + return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, pData->length, + str.pData->buffer, str.pData->length ); + } + + /** + Returns the index within this string of the last occurrence of + the specified substring, searching backward starting before the specified + index. + + The returned index indicates the starting index of the substring + in this string. + If str doesn't include any character, always -1 is + returned. This is also the case, if both strings are empty. + + @param str the substring to search for. + @param fromIndex the index before which to start the search. + @return If the string argument occurs one or more times as a substring + within this string before the starting index, then the index + of the first character of the last such substring is + returned. Otherwise, -1 is returned. + */ + sal_Int32 lastIndexOf( const OUString & str, sal_Int32 fromIndex ) const SAL_THROW(()) + { + return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, fromIndex, + str.pData->buffer, str.pData->length ); + } + + /** + Returns the index within this string of the last occurrence of the + specified ASCII substring. + + @param str + the substring to be searched for. Need not be null-terminated, but must + be at least as long as the specified len. Must only contain characters + in the ASCII range 0x00--7F. + + @param len + the length of the substring; must be non-negative. + + @return + the index (starting at 0) of the first character of the last occurrence + of the substring within this string, or -1 if the substring does not + occur. If len is zero, -1 is returned. + + @since UDK 3.2.7 + */ + sal_Int32 lastIndexOfAsciiL(char const * str, sal_Int32 len) const + SAL_THROW(()) + { + return rtl_ustr_lastIndexOfAscii_WithLength( + pData->buffer, pData->length, str, len); + } + + /** + Returns a new string that is a substring of this string. + + The substring begins at the specified beginIndex. It is an error for + beginIndex to be negative or to be greater than the length of this string. + + @param beginIndex the beginning index, inclusive. + @return the specified substring. + */ + OUString copy( sal_Int32 beginIndex ) const SAL_THROW(()) + { + OSL_ASSERT(beginIndex >= 0 && beginIndex <= getLength()); + if ( beginIndex == 0 ) + return *this; + else + { + rtl_uString* pNew = 0; + rtl_uString_newFromStr_WithLength( &pNew, pData->buffer+beginIndex, getLength()-beginIndex ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + } + + /** + Returns a new string that is a substring of this string. + + The substring begins at the specified beginIndex and contains count + characters. It is an error for either beginIndex or count to be negative, + or for beginIndex + count to be greater than the length of this string. + + @param beginIndex the beginning index, inclusive. + @param count the number of characters. + @return the specified substring. + */ + OUString copy( sal_Int32 beginIndex, sal_Int32 count ) const SAL_THROW(()) + { + OSL_ASSERT(beginIndex >= 0 && beginIndex <= getLength() + && count >= 0 && count <= getLength() - beginIndex); + if ( (beginIndex == 0) && (count == getLength()) ) + return *this; + else + { + rtl_uString* pNew = 0; + rtl_uString_newFromStr_WithLength( &pNew, pData->buffer+beginIndex, count ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + } + + /** + Concatenates the specified string to the end of this string. + + @param str the string that is concatenated to the end + of this string. + @return a string that represents the concatenation of this string + followed by the string argument. + */ + OUString concat( const OUString & str ) const SAL_THROW(()) + { + rtl_uString* pNew = 0; + rtl_uString_newConcat( &pNew, pData, str.pData ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + friend OUString operator+( const OUString& rStr1, const OUString& rStr2 ) SAL_THROW(()) + { + return rStr1.concat( rStr2 ); + } + + /** + Returns a new string resulting from replacing n = count characters + from position index in this string with newStr. + + @param index the replacing index in str. + The index must be greater or equal as 0 and + less or equal as the length of the string. + @param count the count of charcters that will replaced + The count must be greater or equal as 0 and + less or equal as the length of the string minus index. + @param newStr the new substring. + @return the new string. + */ + OUString replaceAt( sal_Int32 index, sal_Int32 count, const OUString& newStr ) const SAL_THROW(()) + { + rtl_uString* pNew = 0; + rtl_uString_newReplaceStrAt( &pNew, pData, index, count, newStr.pData ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns a new string resulting from replacing all occurrences of + oldChar in this string with newChar. + + If the character oldChar does not occur in the character sequence + represented by this object, then the string is assigned with + str. + + @param oldChar the old character. + @param newChar the new character. + @return a string derived from this string by replacing every + occurrence of oldChar with newChar. + */ + OUString replace( sal_Unicode oldChar, sal_Unicode newChar ) const SAL_THROW(()) + { + rtl_uString* pNew = 0; + rtl_uString_newReplace( &pNew, pData, oldChar, newChar ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Converts from this string all ASCII uppercase characters (65-90) + to ASCII lowercase characters (97-122). + + This function can't be used for language specific conversion. + If the string doesn't contain characters which must be converted, + then the new string is assigned with str. + + @return the string, converted to ASCII lowercase. + */ + OUString toAsciiLowerCase() const SAL_THROW(()) + { + rtl_uString* pNew = 0; + rtl_uString_newToAsciiLowerCase( &pNew, pData ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Converts from this string all ASCII lowercase characters (97-122) + to ASCII uppercase characters (65-90). + + This function can't be used for language specific conversion. + If the string doesn't contain characters which must be converted, + then the new string is assigned with str. + + @return the string, converted to ASCII uppercase. + */ + OUString toAsciiUpperCase() const SAL_THROW(()) + { + rtl_uString* pNew = 0; + rtl_uString_newToAsciiUpperCase( &pNew, pData ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns a new string resulting from removing white space from both ends + of the string. + + All characters that have codes less than or equal to + 32 (the space character) are considered to be white space. + If the string doesn't contain white spaces at both ends, + then the new string is assigned with str. + + @return the string, with white space removed from the front and end. + */ + OUString trim() const SAL_THROW(()) + { + rtl_uString* pNew = 0; + rtl_uString_newTrim( &pNew, pData ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns a token in the string. + + Example: + sal_Int32 nIndex = 0; + do + { + ... + OUString aToken = aStr.getToken( 0, ';', nIndex ); + ... + } + while ( nIndex >= 0 ); + + @param token the number of the token to return + @param cTok the character which seperate the tokens. + @param index the position at which the token is searched in the + string. + The index must not be greater than the length of the + string. + This param is set to the position of the + next token or to -1, if it is the last token. + @return the token; if either token or index is negative, an empty token + is returned (and index is set to -1) + */ + OUString getToken( sal_Int32 token, sal_Unicode cTok, sal_Int32& index ) const SAL_THROW(()) + { + rtl_uString * pNew = 0; + index = rtl_uString_getToken( &pNew, pData, token, cTok, index ); + return OUString( pNew, (DO_NOT_ACQUIRE *)0 ); + } + + /** + Returns the Boolean value from this string. + + This function can't be used for language specific conversion. + + @return sal_True, if the string is 1 or "True" in any ASCII case. + sal_False in any other case. + */ + sal_Bool toBoolean() const SAL_THROW(()) + { + return rtl_ustr_toBoolean( pData->buffer ); + } + + /** + Returns the first character from this string. + + @return the first character from this string or 0, if this string + is emptry. + */ + sal_Unicode toChar() const SAL_THROW(()) + { + return pData->buffer[0]; + } + + /** + Returns the int32 value from this string. + + This function can't be used for language specific conversion. + + @param radix the radix (between 2 and 36) + @return the int32 represented from this string. + 0 if this string represents no number. + */ + sal_Int32 toInt32( sal_Int16 radix = 10 ) const SAL_THROW(()) + { + return rtl_ustr_toInt32( pData->buffer, radix ); + } + + /** + Returns the int64 value from this string. + + This function can't be used for language specific conversion. + + @param radix the radix (between 2 and 36) + @return the int64 represented from this string. + 0 if this string represents no number. + */ + sal_Int64 toInt64( sal_Int16 radix = 10 ) const SAL_THROW(()) + { + return rtl_ustr_toInt64( pData->buffer, radix ); + } + + /** + Returns the float value from this string. + + This function can't be used for language specific conversion. + + @return the float represented from this string. + 0.0 if this string represents no number. + */ + float toFloat() const SAL_THROW(()) + { + return rtl_ustr_toFloat( pData->buffer ); + } + + /** + Returns the double value from this string. + + This function can't be used for language specific conversion. + + @return the double represented from this string. + 0.0 if this string represents no number. + */ + double toDouble() const SAL_THROW(()) + { + return rtl_ustr_toDouble( pData->buffer ); + } + + + /** + Return a canonical representation for a string. + + A pool of strings, initially empty is maintained privately + by the string class. On invocation, if present in the pool + the original string will be returned. Otherwise this string, + or a copy thereof will be added to the pool and returned. + + @return + a version of the string from the pool. + + @exception std::bad_alloc is thrown if an out-of-memory condition occurs + + @since UDK 3.2.7 + */ + OUString intern() const + { + rtl_uString * pNew = 0; + rtl_uString_intern( &pNew, pData ); +#if defined EXCEPTIONS_OFF + OSL_ASSERT(pNew != NULL); +#else + if (pNew == 0) { + throw std::bad_alloc(); + } +#endif + return OUString( pNew, (DO_NOT_ACQUIRE *)0 ); + } + + /** + Return a canonical representation for a converted string. + + A pool of strings, initially empty is maintained privately + by the string class. On invocation, if present in the pool + the original string will be returned. Otherwise this string, + or a copy thereof will be added to the pool and returned. + + @param value a 8-Bit character array. + @param length the number of character which should be converted. + The 8-Bit character array length must be + greater or equal than this value. + @param encoding the text encoding from which the 8-Bit character + sequence should be converted. + @param convertFlags flags which controls the conversion. + see RTL_TEXTTOUNICODE_FLAGS_... + @param pInfo pointer to return conversion status or NULL. + + @return + a version of the converted string from the pool. + + @exception std::bad_alloc is thrown if an out-of-memory condition occurs + + @since UDK 3.2.7 + */ + static OUString intern( const sal_Char * value, sal_Int32 length, + rtl_TextEncoding encoding, + sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS, + sal_uInt32 *pInfo = NULL ) + { + rtl_uString * pNew = 0; + rtl_uString_internConvert( &pNew, value, length, encoding, + convertFlags, pInfo ); +#if defined EXCEPTIONS_OFF + OSL_ASSERT(pNew != NULL); +#else + if (pNew == 0) { + throw std::bad_alloc(); + } +#endif + return OUString( pNew, (DO_NOT_ACQUIRE *)0 ); + } + + /** + Converts to an OString, signalling failure. + + @param pTarget + An out parameter receiving the converted OString. Must not be null; the + contents are not modified if conversion fails (convertToOString returns + false). + + @param nEncoding + The text encoding to convert into. Must be an octet encoding (i.e., + rtl_isOctetTextEncoding(nEncoding) must return true). + + @param nFlags + A combination of RTL_UNICODETOTEXT_FLAGS that detail how to do the + conversion (see rtl_convertUnicodeToText). RTL_UNICODETOTEXT_FLAGS_FLUSH + need not be included, it is implicitly assumed. Typical uses are either + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR | + RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR (fail if a Unicode character cannot + be converted to the target nEncoding) or OUSTRING_TO_OSTRING_CVTFLAGS + (make a best efforts conversion). + + @return + True if the conversion succeeded, false otherwise. + */ + inline bool convertToString(OString * pTarget, rtl_TextEncoding nEncoding, + sal_uInt32 nFlags) const + { + return rtl_convertUStringToString(&pTarget->pData, pData->buffer, + pData->length, nEncoding, nFlags); + } + + /** Iterate through this string based on code points instead of UTF-16 code + units. + + See Chapter 3 of The Unicode Standard 5.0 (Addison--Wesley, 2006) for + definitions of the various terms used in this description. + + This string is interpreted as a sequence of zero or more UTF-16 code + units. For each index into this sequence (from zero to one less than + the length of the sequence, inclusive), a code point represented + starting at the given index is computed as follows: + + - If the UTF-16 code unit addressed by the index constitutes a + well-formed UTF-16 code unit sequence, the computed code point is the + scalar value encoded by that UTF-16 code unit sequence. + + - Otherwise, if the index is at least two UTF-16 code units away from + the end of the sequence, and the sequence of two UTF-16 code units + addressed by the index constitutes a well-formed UTF-16 code unit + sequence, the computed code point is the scalar value encoded by that + UTF-16 code unit sequence. + + - Otherwise, the computed code point is the UTF-16 code unit addressed + by the index. (This last case catches unmatched surrogates as well as + indices pointing into the middle of surrogate pairs.) + + @param indexUtf16 + pointer to a UTF-16 based index into this string; must not be null. On + entry, the index must be in the range from zero to the length of this + string (in UTF-16 code units), inclusive. Upon successful return, the + index will be updated to address the UTF-16 code unit that is the given + incrementCodePoints away from the initial index. + + @param incrementCodePoints + the number of code points to move the given *indexUtf16. If + non-negative, moving is done after determining the code point at the + index. If negative, moving is done before determining the code point + at the (then updated) index. The value must be such that the resulting + UTF-16 based index is in the range from zero to the length of this + string (in UTF-16 code units), inclusive. + + @return + the code point (an integer in the range from 0 to 0x10FFFF, inclusive) + that is represented within this string starting at the index computed as + follows: If incrementCodePoints is non-negative, the index is the + initial value of *indexUtf16; if incrementCodePoints is negative, the + index is the updated value of *indexUtf16. In either case, the computed + index must be in the range from zero to one less than the length of this + string (in UTF-16 code units), inclusive. + + @since UDK 3.2.7 + */ + inline sal_uInt32 iterateCodePoints( + sal_Int32 * indexUtf16, sal_Int32 incrementCodePoints = 1) const + { + return rtl_uString_iterateCodePoints( + pData, indexUtf16, incrementCodePoints); + } + + /** + Returns the string representation of the sal_Bool argument. + + If the sal_Bool is true, the string "true" is returned. + If the sal_Bool is false, the string "false" is returned. + This function can't be used for language specific conversion. + + @param b a sal_Bool. + @return a string with the string representation of the argument. + */ + static OUString valueOf( sal_Bool b ) SAL_THROW(()) + { + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFBOOLEAN]; + rtl_uString* pNewData = 0; + rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfBoolean( aBuf, b ) ); + return OUString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the char argument. + + @param c a character. + @return a string with the string representation of the argument. + */ + static OUString valueOf( sal_Unicode c ) SAL_THROW(()) + { + return OUString( &c, 1 ); + } + + /** + Returns the string representation of the int argument. + + This function can't be used for language specific conversion. + + @param i a int32. + @param radix the radix (between 2 and 36) + @return a string with the string representation of the argument. + */ + static OUString valueOf( sal_Int32 i, sal_Int16 radix = 10 ) SAL_THROW(()) + { + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT32]; + rtl_uString* pNewData = 0; + rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfInt32( aBuf, i, radix ) ); + return OUString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the long argument. + + This function can't be used for language specific conversion. + + @param ll a int64. + @param radix the radix (between 2 and 36) + @return a string with the string representation of the argument. + */ + static OUString valueOf( sal_Int64 ll, sal_Int16 radix = 10 ) SAL_THROW(()) + { + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT64]; + rtl_uString* pNewData = 0; + rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfInt64( aBuf, ll, radix ) ); + return OUString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the float argument. + + This function can't be used for language specific conversion. + + @param f a float. + @return a string with the string representation of the argument. + */ + static OUString valueOf( float f ) SAL_THROW(()) + { + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFFLOAT]; + rtl_uString* pNewData = 0; + rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfFloat( aBuf, f ) ); + return OUString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns the string representation of the double argument. + + This function can't be used for language specific conversion. + + @param d a double. + @return a string with the string representation of the argument. + */ + static OUString valueOf( double d ) SAL_THROW(()) + { + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFDOUBLE]; + rtl_uString* pNewData = 0; + rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfDouble( aBuf, d ) ); + return OUString( pNewData, (DO_NOT_ACQUIRE*)0 ); + } + + /** + Returns a OUString copied without conversion from an ASCII + character string. + + Since this method is optimized for performance, the ASCII character + values are not converted in any way. The caller has to make sure that + all ASCII characters are in the allowed range between 0 and + 127. The ASCII string must be NULL-terminated. + + @param value the 8-Bit ASCII character string + @return a string with the string representation of the argument. + */ + static OUString createFromAscii( const sal_Char * value ) SAL_THROW(()) + { + rtl_uString* pNew = 0; + rtl_uString_newFromAscii( &pNew, value ); + return OUString( pNew, (DO_NOT_ACQUIRE*)0 ); + } +}; + +/* ======================================================================= */ + +/** A helper to use OUStrings with hash maps. + + Instances of this class are unary function objects that can be used as + hash function arguments to STLPort's hash_map and similar constructs. + */ +struct OUStringHash +{ + /** Compute a hash code for a string. + + @param rString + a string. + + @return + a hash code for the string. This hash code should not be stored + persistently, as its computation may change in later revisions. + */ + size_t operator()(const rtl::OUString& rString) const + { return (size_t)rString.hashCode(); } +}; + +/* ======================================================================= */ + +/** Convert an OString to an OUString, using a specific text encoding. + + The lengths of the two strings may differ (e.g., for double-byte + encodings, UTF-7, UTF-8). + + @param rStr + an OString to convert. + + @param encoding + the text encoding to use for conversion. + + @param convertFlags + flags which control the conversion. Either use + OSTRING_TO_OUSTRING_CVTFLAGS, or see + <http://udk.openoffice.org/cpp/man/spec/textconversion.html> for more + details. + */ +inline OUString OStringToOUString( const OString & rStr, + rtl_TextEncoding encoding, + sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS ) +{ + return OUString( rStr.getStr(), rStr.getLength(), encoding, convertFlags ); +} + +/** Convert an OUString to an OString, using a specific text encoding. + + The lengths of the two strings may differ (e.g., for double-byte + encodings, UTF-7, UTF-8). + + @param rStr + an OUString to convert. + + @param encoding + the text encoding to use for conversion. + + @param convertFlags + flags which control the conversion. Either use + OUSTRING_TO_OSTRING_CVTFLAGS, or see + <http://udk.openoffice.org/cpp/man/spec/textconversion.html> for more + details. + */ +inline OString OUStringToOString( const OUString & rUnicode, + rtl_TextEncoding encoding, + sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS ) +{ + return OString( rUnicode.getStr(), rUnicode.getLength(), encoding, convertFlags ); +} + +/* ======================================================================= */ + +} /* Namespace */ + +#endif /* __cplusplus */ + +#endif /* _RTL_USTRING_HXX */ diff --git a/sal/inc/rtl/uuid.h b/sal/inc/rtl/uuid.h new file mode 100644 index 000000000000..3ff5bb2c1232 --- /dev/null +++ b/sal/inc/rtl/uuid.h @@ -0,0 +1,209 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _RTL_UUID_H_ +#define _RTL_UUID_H_ + + +#include <sal/types.h> +#include <rtl/string.h> + +/** + @HTML + @file + Specification (from draft-leach-uuids-guids-01.txt ) + + <p> + A UUID is an identifier that is unique across both space and time, + with respect to the space of all UUIDs. To be precise, the UUID + consists of a finite bit space. Thus, collision cannot be avoided in + principle. A UUID can be used for multiple purposes, from tagging objects + with an extremely short lifetime, to reliably identifying very persistent + objects across a network. + + <p> + The generation of UUIDs does not require that a registration + authority be contacted for each identifier. Instead, Version 4 UUIDs are + generated from (pseudo unique) sequences of (pseudo) random bits. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** Generates a new Version 4 (random number based) UUID (Universally Unique + IDentifier). + + @param pTargetUUID pointer to at least 16 bytes of memory. After the call it contains + the newly generated uuid in network byte order. + @param pPredecessorUUID ignored (was used when this function returned + Version 1 instead of Version 4 UUIDs). + @param bUseEthernetAddress ignored (was used when this function returned + Version 1 instead of Version 4 UUIDs). + */ +void SAL_CALL rtl_createUuid( sal_uInt8 *pTargetUUID , + const sal_uInt8 *pPredecessorUUID, + sal_Bool bUseEthernetAddress ); + +/** Compare two UUID's lexically + + <p> + Note: lexical ordering is not temporal ordering! + <p> + Note: For equalnesschecking, a memcmp(pUUID1,pUUID2,16) is more efficient + + @return + <ul> + <li>-1 u1 is lexically before u2 + <li>0 u1 is equal to u2 + <li>1 u1 is lexically after u2 + </ul> + + */ +sal_Int32 SAL_CALL rtl_compareUuid( const sal_uInt8 *pUUID1 , const sal_uInt8 *pUUID2 ); + +/** Creates named UUIDs. + + <p> + The version 3 UUID is meant for generating UUIDs from <em>names</em> that + are drawn from, and unique within, some <em>name space</em>. Some examples + of names (and, implicitly, name spaces) might be DNS names, URLs, ISO + Object IDs (OIDs), reserved words in a programming language, or X.500 + Distinguished Names (DNs); thus, the concept of name and name space + should be broadly construed, and not limited to textual names. + + <p> + The requirements for such UUIDs are as follows: + + <ul> + <li> The UUIDs generated at different times from the same name in the + same namespace MUST be equal + + <li> The UUIDs generated from two different names in the same namespace + should be different (with very high probability) + + <li> The UUIDs generated from the same name in two different namespaces + should be different with (very high probability) + + <li> If two UUIDs that were generated from names are equal, then they + were generated from the same name in the same namespace (with very + high probability). + </ul> + + @param pTargetUUID pointer to at least 16 bytes of memory. After the call + it contains the newly generated uuid in network byte order. + @param pNameSpaceUUID The namespace uuid. Below are some predefined ones, + but any arbitray uuid can be used as namespace. + + @param pName the name + */ +void SAL_CALL rtl_createNamedUuid( + sal_uInt8 *pTargetUUID, + const sal_uInt8 *pNameSpaceUUID, + const rtl_String *pName + ); + + + +/* + Predefined Namespaces + (Use them the following way : sal_uInt8 aNsDNS[16]) = RTL_UUID_NAMESPACE_DNS; + */ +/** namesapce DNS + + <p> + (Use them the following way : sal_uInt8 aNsDNS[16]) = RTL_UUID_NAMESPACE_DNS; + <p> + 6ba7b810-9dad-11d1-80b4-00c04fd430c8 */ +#define RTL_UUID_NAMESPACE_DNS {\ + 0x6b,0xa7,0xb8,0x10,\ + 0x9d,0xad,\ + 0x11,0xd1,\ + 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8\ + } + +/** namespace URL + + <p> + 6ba7b811-9dad-11d1-80b4-00c04fd430c8 */ +#define RTL_UUID_NAMESPACE_URL { \ + 0x6b, 0xa7, 0xb8, 0x11,\ + 0x9d, 0xad,\ + 0x11, 0xd1,\ + 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8\ + } + +/** namespace oid + + <p> + 6ba7b812-9dad-11d1-80b4-00c04fd430c8 */ +#define RTL_UUID_NAMESPACE_OID {\ + 0x6b, 0xa7, 0xb8, 0x12,\ + 0x9d, 0xad,\ + 0x11, 0xd1,\ + 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8\ + } + +/** namespace X500 + + <p> + 6ba7b814-9dad-11d1-80b4-00c04fd430c8 */ +#define RTL_UUID_NAMESPACE_X500 {\ + 0x6b, 0xa7, 0xb8, 0x14,\ + 0x9d, 0xad,\ + 0x11, 0xd1,\ + 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8\ + } + + +/* + This macro must have a value below the system time resolution of the + system. The uuid routines use this value as an upper limit for adding ticks to the + the predecessor time value if system times are equal. + */ +#ifdef SAL_W32 +#define UUID_SYSTEM_TIME_RESOLUTION_100NS_TICKS 1000 +#elif defined SAL_OS2 // YD we use posix functions for time +#define UUID_SYSTEM_TIME_RESOLUTION_100NS_TICKS 10 +#elif LINUX +#define UUID_SYSTEM_TIME_RESOLUTION_100NS_TICKS 10 +#elif NETBSD +#define UUID_SYSTEM_TIME_RESOLUTION_100NS_TICKS 10 +#elif FREEBSD +#define UUID_SYSTEM_TIME_RESOLUTION_100NS_TICKS 10 +#elif SOLARIS +#define UUID_SYSTEM_TIME_RESOLUTION_100NS_TICKS 10 +#elif MACOSX +#define UUID_SYSTEM_TIME_RESOLUTION_100NS_TICKS 100000 +#else +#error "System time resolution must be calculated!" +#endif + +#ifdef __cplusplus +} +#endif + +#endif |