INTEGRATION: CWS cliuno01 (1.14.44); FILE MERGED

2003/07/24 15:18:59 dbo 1.14.44.2: - sequence reallocation fix
- more code cleanup
- test code
2003/07/23 16:39:19 dbo 1.14.44.1: - fixing cppu core sequence routines returning 0 handle upon memory allocation failure
- C++ Sequence<> throws ::std::bad_alloc upon memory allocation failure

1 files changed, 81 insertions, 47 deletions

diff --git a/cppu/inc/com/sun/star/uno/Sequence.h b/cppu/inc/com/sun/star/uno/Sequence.h
index a4bae5e6ff31..58532fd6728e 100644
--- a/cppu/inc/com/sun/star/uno/Sequence.h
+++ b/cppu/inc/com/sun/star/uno/Sequence.h
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: Sequence.h,v $
  *
- *  $Revision: 1.14 $
+ *  $Revision: 1.15 $
  *
- *  last change: $Author: dbo $ $Date: 2001-11-09 09:14:30 $
+ *  last change: $Author: obo $ $Date: 2003-09-04 10:51:35 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -62,17 +62,21 @@
 #define _COM_SUN_STAR_UNO_SEQUENCE_H_
 
 #ifndef _TYPELIB_TYPEDESCRIPTION_H_
-#include <typelib/typedescription.h>
+#include "typelib/typedescription.h"
 #endif
 #ifndef _UNO_SEQUENCE2_H_
-#include <uno/sequence2.h>
+#include "uno/sequence2.h"
 #endif
 #ifndef _COM_SUN_STAR_UNO_TYPE_H_
-#include <com/sun/star/uno/Type.h>
+#include "com/sun/star/uno/Type.h"
 #endif
 
 #ifndef _RTL_ALLOC_H_
-#include <rtl/alloc.h>
+#include "rtl/alloc.h"
+#endif
+
+#if ! defined EXCEPTIONS_OFF
+#include <new>
 #endif
 
 
@@ -90,10 +94,10 @@ namespace star
 namespace uno
 {
 
-/** Template C++ class representing an IDL sequence. Template argument is the sequence element type.
-    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).
+/** Template C++ class representing an IDL sequence. Template argument is the
+    sequence element type.  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).
 
     @tplparam E element type of sequence
 */
@@ -108,16 +112,20 @@ class Sequence
 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( () )
+    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( () )
+    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( () )
+    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( () )
+    inline static void SAL_CALL operator delete ( void *, void * )
+        SAL_THROW( () )
         {}
 
     /** Static pointer to typelib type of sequence.
@@ -133,38 +141,48 @@ public:
     /** Default constructor: Creates an empty sequence.
     */
     inline Sequence() SAL_THROW( () );
+
     /** Copy constructor: Creates a copy of given sequence.
 
         @param rSeq another sequence of same type
     */
     inline Sequence( const Sequence< E > & rSeq ) SAL_THROW( () );
+
     /** Constructor: Takes over ownership of given sequence.
 
         @param pSequence a sequence
-        @param dummy SAL_NO_ACQUIRE to force obvious distinction to other constructors
+        @param dummy SAL_NO_ACQUIRE to force obvious distinction to other
+        constructors
     */
-    inline Sequence( uno_Sequence * pSequence, __sal_NoAcquire ) SAL_THROW( () );
+    inline Sequence( uno_Sequence * pSequence, __sal_NoAcquire )
+        SAL_THROW( () );
+
     /** Constructor: Creates a copy of given elements.
 
         @param pElement an array of elements
         @param len length of array
     */
-    inline Sequence( const E * pElements, sal_Int32 len ) SAL_THROW( () );
+    inline Sequence( const E * pElements, sal_Int32 len );
+
     /** Constructor: Creates a default constructed sequence of given length.
 
         @param len initial sequence length
     */
-    inline Sequence( sal_Int32 len ) SAL_THROW( () );
-    /** Destructor: Releases sequence handle. Last handle will destruct elements and free memory.
+    inline Sequence( sal_Int32 len );
+
+    /** Destructor: Releases sequence handle. Last handle will destruct
+        elements and free memory.
     */
     inline ~Sequence() SAL_THROW( () );
 
-    /** Assignment operator: Acquires given sequence handle and releases previously set handle.
+    /** Assignment operator: Acquires given sequence handle and releases
+        previously set handle.
 
         @param rSeq another sequence of same type
         @return this sequence
     */
-    inline Sequence< E > & SAL_CALL operator = ( const Sequence< E > & rSeq ) SAL_THROW( () );
+    inline Sequence< E > & SAL_CALL operator = ( const Sequence< E > & rSeq )
+        SAL_THROW( () );
 
     /** Gets length of the sequence.
 
@@ -172,7 +190,9 @@ public:
     */
     inline sal_Int32 SAL_CALL getLength() const SAL_THROW( () )
         { return _pSequence->nElements; }
-    /** Tests whether the sequence has elements, i.e. elements count is greater than zero.
+
+    /** Tests whether the sequence has elements, i.e. elements count is
+        greater than zero.
 
         @return true, if elements count is greater than zero
     */
@@ -180,62 +200,73 @@ public:
         { return (_pSequence->nElements > 0); }
 
     /** Gets a pointer to elements array for reading.
-        If the sequence has a length of 0, then the returned pointer is undefined.
+        If the sequence has a length of 0, then the returned pointer is
+        undefined.
 
         @return pointer to elements array
     */
     inline const E * SAL_CALL getConstArray() const SAL_THROW( () )
         { return reinterpret_cast< const E * >( _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 copy constructing all elements to keep value semantics!
-        If the sequence has a length of 0, then the returned pointer is undefined.
+        In general if the sequence has a handle acquired by other sequences
+        (reference count > 1), then a new sequence is created copy constructing
+        all elements to keep value semantics!
+        If the sequence has a length of 0, then the returned pointer is
+        undefined.
 
         @return pointer to elements array
     */
-    inline E * SAL_CALL getArray() SAL_THROW( () );
+    inline E * SAL_CALL getArray();
 
-    /** Non-const index operator: Obtains a reference to element indexed at given position.
+    /** Non-const index operator: Obtains a reference to element indexed at
+        given position.
         The implementation does not check for array bounds!
-        In general if the sequence has a handle acquired by other sequences (reference count > 1),
-        then a new sequence is created copy constructing all elements to keep value semantics!
+        In general if the sequence has a handle acquired by other sequences
+        (reference count > 1), then a new sequence is created copy constructing
+        all elements to keep value semantics!
 
         @param nIndex index
         @return non-const C++ reference to element
     */
-    inline E & SAL_CALL operator [] ( sal_Int32 nIndex ) SAL_THROW( () );
-    /** Const index operator: Obtains a reference to element indexed at given position.
-        The implementation does not check for array bounds!
+    inline E & SAL_CALL operator [] ( sal_Int32 nIndex );
+
+    /** Const index operator: Obtains a reference to element indexed at
+        given position.  The implementation does not check for array bounds!
 
         @param nIndex index
         @return const C++ reference to element
     */
-    inline const E & SAL_CALL operator [] ( sal_Int32 nIndex ) const SAL_THROW( () );
+    inline const E & SAL_CALL operator [] ( sal_Int32 nIndex ) const
+        SAL_THROW( () );
 
     /** Equality operator: Compares two sequences.
 
         @param rSeq another sequence of same type (right side)
         @return true if both sequences are equal, false otherwise
     */
-    inline sal_Bool SAL_CALL operator == ( const Sequence< E > & rSeq ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator == ( const Sequence< E > & rSeq ) const
+        SAL_THROW( () );
+
     /** Unequality operator: Compares two sequences.
 
         @param rSeq another sequence of same type (right side)
         @return false if both sequences are equal, true otherwise
     */
-    inline sal_Bool SAL_CALL operator != ( const Sequence< E > & rSeq ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator != ( const Sequence< E > & rSeq ) const
+        SAL_THROW( () );
 
     /** Reallocates sequence to new length.
-        If the new length is smaller than the former, then upper elements will be destructed
-        (and their memory freed). If the new length is greater than the former, then
-        upper (new) elements are default constructed.
-        If the sequence has a handle acquired by other sequences (reference count > 1),
-        then the remaining elements are copy constructed to a new sequence handle to keep
-        value semantics!
+        If the new length is smaller than the former, then upper elements will
+        be destructed (and their memory freed).  If the new length is greater
+        than the former, then upper (new) elements are default constructed.
+        If the sequence has a handle acquired by other sequences
+        (reference count > 1), then the remaining elements are copy constructed
+        to a new sequence handle to keep value semantics!
 
         @param nSize new size of sequence
     */
-    inline void SAL_CALL realloc( sal_Int32 nSize ) SAL_THROW( () );
+    inline void SAL_CALL realloc( sal_Int32 nSize );
 
     /** Provides UNacquired sequence handle.
 
@@ -266,11 +297,13 @@ inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence(
 */
 template< class E >
 inline const ::com::sun::star::uno::Type &
-SAL_CALL getCppuType( const ::com::sun::star::uno::Sequence< E > * ) SAL_THROW( () );
+SAL_CALL getCppuType( const ::com::sun::star::uno::Sequence< E > * )
+    SAL_THROW( () );
 
 /** Gets the meta type of IDL sequence.
-    This function has been introduced, because one cannot get the (templated) cppu type out
-    of C++ array types.  Array types have special getCppuArrayTypeN() functions.
+    This function has been introduced, because one cannot get the (templated)
+    cppu type out of C++ array types.  Array types have special
+    getCppuArrayTypeN() functions.
 
     @attention
     the given element type must be the same as the template argument type!
@@ -280,7 +313,8 @@ SAL_CALL getCppuType( const ::com::sun::star::uno::Sequence< E > * ) SAL_THROW(
 */
 template< class E >
 inline const ::com::sun::star::uno::Type &
-SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType ) SAL_THROW( () );
+SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType )
+    SAL_THROW( () );
 
 /** Gets the meta type of IDL sequence< char >.
     This function has been introduced due to ambiguities with unsigned short.