diff options
Diffstat (limited to 'cppu/inc/com/sun/star/uno/Sequence.h')
| -rw-r--r-- | cppu/inc/com/sun/star/uno/Sequence.h | 90 |
1 files changed, 45 insertions, 45 deletions
diff --git a/cppu/inc/com/sun/star/uno/Sequence.h b/cppu/inc/com/sun/star/uno/Sequence.h index 942050866eae..8b6cda8f322e 100644 --- a/cppu/inc/com/sun/star/uno/Sequence.h +++ b/cppu/inc/com/sun/star/uno/Sequence.h @@ -2,7 +2,7 @@ /************************************************************************* * * 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 @@ -44,19 +44,19 @@ class ByteSequence; } namespace com -{ +{ namespace sun -{ +{ 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). - + @tplparam E element type of sequence */ template< class E > @@ -66,7 +66,7 @@ class Sequence @internal */ uno_Sequence * _pSequence; - + public: // these are here to force memory de/allocation to sal lib. /** @internal */ @@ -85,135 +85,135 @@ public: inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () ) {} - + /** Static pointer to typelib type of sequence. Don't use directly, call getCppuType(). @internal */ static typelib_TypeDescriptionReference * s_pType; - + /** typedefs the element type of the sequence */ typedef E ElementType; - + /** 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 */ 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 ); - + /** Constructor: Creates a default constructed sequence of given length. - + @param len initial sequence length */ 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. - + @param rSeq another sequence of same type @return this sequence */ inline Sequence< E > & SAL_CALL operator = ( const Sequence< E > & rSeq ) SAL_THROW( () ); - + /** Gets length of the sequence. - + @return length of sequence */ 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. - + @return true, if elements count is greater than zero */ inline sal_Bool SAL_CALL hasElements() const SAL_THROW( () ) { 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. - + @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. - + @return pointer to elements array */ inline E * SAL_CALL getArray(); - + /** 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! - + @param nIndex index @return non-const C++ reference to element */ 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( () ); - + /** 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( () ); - + /** 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( () ); - + /** 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 @@ -221,13 +221,13 @@ public: 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 ); - + /** Provides UNacquired sequence handle. - + @return UNacquired sequence handle */ inline uno_Sequence * SAL_CALL get() const SAL_THROW( () ) @@ -235,7 +235,7 @@ public: }; /** Creates a UNO byte sequence from a SAL byte sequence. - + @param rByteSequence a byte sequence @return a UNO byte sequence */ @@ -251,7 +251,7 @@ inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence( There are cases (involving templates) where uses of getCppuType are known to not compile. Use cppu::UnoType or cppu::getTypeFavourUnsigned instead. - + @tplparam E element type of sequence @param dummy typed pointer for function signature @return type of IDL sequence @@ -265,7 +265,7 @@ SAL_CALL getCppuType( const ::com::sun::star::uno::Sequence< E > * ) 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! @tplparam E element type of sequence @@ -279,7 +279,7 @@ SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType ) /** Gets the meta type of IDL sequence< char >. This function has been introduced due to ambiguities with unsigned short. - + @param dummy typed pointer for function signature @return type of IDL sequence< char > */ |