AOO410/main/cppu/inc/uno/sequence2.h

/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#ifndef _UNO_SEQUENCE2_H_
#define _UNO_SEQUENCE2_H_

#include <sal/types.h>
#include <uno/data.h>

#ifdef __cplusplus
extern "C"
{
#endif

struct _typelib_TypeDescriptionReference;
struct _typelib_TypeDescription;
typedef sal_Sequence uno_Sequence;

/** Assigns a sequence.
    
	@param ppDest		destinstaion sequence
	@param pSource		source sequence
	@param pTypeDescr	type description of the sequence and NOT of an element
	@param release		function called each time an interface needs to
                        be released; defaults (0) to uno
*/
void SAL_CALL uno_sequence_assign(
	uno_Sequence ** ppDest,
	uno_Sequence * pSource,
	struct _typelib_TypeDescription * pTypeDescr,
	uno_ReleaseFunc release )
	SAL_THROW_EXTERN_C();
/** Assigns a sequence.
    
	@param ppDest		destinstaion sequence
	@param pSource		source sequence
	@param pType		type of the sequence and NOT of an element
	@param release		function called each time an interface needs to
                        be released; defaults (0) to uno
*/
void SAL_CALL uno_type_sequence_assign(
	uno_Sequence ** ppDest,
	uno_Sequence * pSource,
	struct _typelib_TypeDescriptionReference * pType,
	uno_ReleaseFunc release )
	SAL_THROW_EXTERN_C();

/** Constructs a new sequence with given elements.
    
	@param ppSequence		  out parameter sequence;
                              0 if memory allocation has failed
	@param pTypeDescr		  type description of the sequence and NOT of an
                              element
	@param pElements		  if 0, then all elements are default constructed
	@param len				  number of elements
	@param acquire			  function called each time an interface needs to
                              be acquired; defaults (0) to uno
    @return                   false, if memoray allocation has failed
*/
sal_Bool SAL_CALL uno_sequence_construct(
	uno_Sequence ** ppSequence,
	struct _typelib_TypeDescription * pTypeDescr,
	void * pElements, sal_Int32 len,
	uno_AcquireFunc acquire )
	SAL_THROW_EXTERN_C();
/** Constructs a new sequence with given elements.
    
	@param ppSequence		  out parameter sequence;
                              0 if memory allocation has failed
	@param pType			  type of the sequence and NOT of an element
	@param pElements		  if 0, then all elements are default constructed
	@param len				  number of elements
	@param acquire			  function called each time an interface needs to
                              be acquired; defaults (0) to uno
    @return                   false, if memoray allocation has failed
*/
sal_Bool SAL_CALL uno_type_sequence_construct(
	uno_Sequence ** ppSequence,
	struct _typelib_TypeDescriptionReference * pType,
	void * pElements, sal_Int32 len,
	uno_AcquireFunc acquire )
	SAL_THROW_EXTERN_C();

/** Assures that the reference count of the given sequence is one.
    Otherwise a new copy of the sequence is created with a reference count
    of one.
    
	@param ppSequence		inout sequence
	@param pTypeDescr		type description of sequence
	@param acquire			function called each time an interface needs to
                            be acquired; defaults (0) to uno
	@param release			function called each time an interface needs to
                            be released; defaults (0) to uno
    @return                 false, if memoray allocation has failed
*/
sal_Bool SAL_CALL uno_sequence_reference2One(
	uno_Sequence ** ppSequence,
	struct _typelib_TypeDescription * pTypeDescr,
	uno_AcquireFunc acquire,
	uno_ReleaseFunc release )
	SAL_THROW_EXTERN_C();
/** Assures that the reference count of the given sequence is one.
    Otherwise a new copy of the sequence is created with a reference count
    of one.
    
	@param ppSequence		inout sequence
	@param pType			type of sequence
	@param acquire			function called each time an interface needs to
                            be acquired; defaults (0) to uno
	@param release			function called each time an interface needs to
                            be released; defaults (0) to uno
    @return                 false, if memoray allocation has failed
*/
sal_Bool SAL_CALL uno_type_sequence_reference2One(
	uno_Sequence ** ppSequence,
	struct _typelib_TypeDescriptionReference * pType,
	uno_AcquireFunc acquire,
	uno_ReleaseFunc release )
	SAL_THROW_EXTERN_C();

/** Reallocates length of a sequence. This truncates a sequence or enlarges
    it default constructing appended elements.
    
	@param ppSequence		inout sequence
	@param pTypeDescr		type description of sequence
	@param nSize			new size of sequence
	@param acquire			function called each time an interface needs to
                            be acquired; defaults (0) to uno
	@param release			function called each time an interface needs to
                            be released; defaults (0) to uno
    @return                 false, if memoray allocation has failed
*/
sal_Bool SAL_CALL uno_sequence_realloc(
	uno_Sequence ** ppSequence,
	struct _typelib_TypeDescription * pTypeDescr,
	sal_Int32 nSize,
	uno_AcquireFunc acquire,
	uno_ReleaseFunc release )
	SAL_THROW_EXTERN_C();
/** Reallocates length of a sequence. This truncates a sequence or enlarges
    it default constructing appended elements.
    
	@param ppSequence		inout sequence
	@param pType			type of sequence
	@param nSize			new size of sequence
	@param acquire			function called each time an interface needs to
                            be acquired; defaults (0) to uno
	@param release			function called each time an interface needs to
                            be released; defaults (0) to uno
    @return                 false, if memoray allocation has failed
*/
sal_Bool SAL_CALL uno_type_sequence_realloc(
	uno_Sequence ** ppSequence,
	struct _typelib_TypeDescriptionReference * pType,
	sal_Int32 nSize,
	uno_AcquireFunc acquire,
	uno_ReleaseFunc release )
	SAL_THROW_EXTERN_C();

#ifdef __cplusplus
}
#endif

#endif