src/cas/uima/arrayfs.hpp - uima-uimacpp - Git at Google

 #ifndef UIMA_ARRAYFS_HPP
 #define UIMA_ARRAYFS_HPP
 /** \file arrayfs.hpp .
 -----------------------------------------------------------------------------


  * 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.

 -----------------------------------------------------------------------------

     \brief Declares all ArrayFS classes (IntArrayFS, FloatArrayFS etc)

    Description:

 -----------------------------------------------------------------------------


 -------------------------------------------------------------------------- */


 /* ----------------------------------------------------------------------- */
 /*       Include dependencies                                              */
 /* ----------------------------------------------------------------------- */

 #include "uima/pragmas.hpp"

 #include "uima/lowlevel_typedefs.hpp"
 #include "uima/typesystem.hpp"
 #include "uima/casexception.hpp"
 #include "uima/featurestructure.hpp"
 #include "uima/internal_typeshortcuts.hpp"

 #include "unicode/utf.h"
 /* ----------------------------------------------------------------------- */
 /*       Constants                                                         */
 /* ----------------------------------------------------------------------- */

 /* ----------------------------------------------------------------------- */
 /*       Forward declarations                                              */
 /* ----------------------------------------------------------------------- */


 namespace uima {
   class CAS;
   namespace lowlevel {
     class FSHeap;
   }
 }

 /* ----------------------------------------------------------------------- */
 /*       Types / Classes                                                   */
 /* ----------------------------------------------------------------------- */

 namespace uima {
   // exceptions
   UIMA_EXC_CLASSDECLARE(FSIsNotArrayException, CASException);
   UIMA_EXC_CLASSDECLARE(FSArrayOutOfBoundsException, CASException);
 } // namespace uima

 /* ----------------------------------------------------------------------- */
 /*       ArrayFS                                                            */
 /* ----------------------------------------------------------------------- */

 namespace uima {
   /// @if internal
   template< class T, const uima::lowlevel::TyFSType ARRAY_TYPE >
   /// @endif internal
   /**
    * A on object representing an array of CAS elements.
    * An element can be either a FeatureStructure or a float or an int or a
    * string. For each such element type there is a sub-class of BasicListFS
    * implementing this template interface with type specific methods:
    * ArrayFS, IntArrayFS, FloatArrayFS, StringArrayFS.
    *
    * All get methods may throw an <code>InvalidFSObjectException</code> if the
    * feature structure object is not valid.
    * All access methods using array indexes may throw an
    * <code>FSArrayOutOfBoundsException</code> if the index is >= the array size.
    *
    * Creating an array can be done like this:
      @code
      // store elements of a vector of strings in an array feature
      FeatureStructure fsNewString;           // re-used for each new string
      const size_t uiARRAY_SIZE = vecStrings.size();
      StringArrayFS fsNewArray = tcas.createStringArrayFS(uiARRAY_SIZE); // create an array
      // build up a fs array from our vector
      for (size_t i = 0; i < vecStrings.size(); ++i) {
         fsNewArray.set(i, vecStrings[i]);
      }
      // now that the array is complete, set the feature value to the array
      fsWithArrayFeature.setFSValue(fArrayFeature, fsNewArray);
      @endcode
    * Accessing a array can be done like this:
      @code
      // get array
      StringArrayFS fsArray = fsWithArrayFeature.getStringArrayFSValue(fArrayFeature);
      // iterate array
      for (size_t i = 0; i < fsArray.size(); ++i) {
         cout << fsArray.get(i) << " ";
      }
      @endcode
    *
    * The example uses StringArrayFS to show the usage of the interfaces with
    * strings. Usage of FeatureStructure, int or float values is analogous.
    *
    * Arrays can not be resized after creation. If more (or less) elements are
    * required in the array a new array must be created.
    * Elements from the old array may be copied to then new array.
    * Finally the new array must be assigned to the array feature holding the
    * old array.
    *
    * @see ArrayFS
    * @see IntArrayFS
    * @see FloatArrayFS
    * @see StringArrayFS
    */
   class UIMA_LINK_IMPORTSPEC BasicArrayFS  : public FeatureStructure {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     BasicArrayFS(lowlevel::TyFS anFS, uima::CAS&, bool bDoChecks = true);
     /// @endif internal
   public:

     /**
      * Default CTOR: Creates an invalid BasicArrayFS (use CAS::createArrayFS() instead)
      */
     BasicArrayFS();

     /**
      * Upgrade/Conversion CTOR: Creates an ArrayFS from an existing FeatureStructure.
      * fs must be of type array.
      *
      * @throws FSIsNotArrayException
      */
     explicit BasicArrayFS( FeatureStructure const & fs );

     /**
      * get the <code>n</code>th element of an array.
      * @throws InvalidFSObjectException
      * @throws FSArrayOutOfBoundsException
      */
     T get(size_t n) const;

     /**
      * set the <code>n</code>th element of an array.
      * @throws InvalidFSObjectException
      * @throws FSArrayOutOfBoundsException
      */
     void set(size_t n, T const & val);

     /**
      * get the size of the array
      * @throws InvalidFSObjectException
      */
     size_t size() const;

     /**
      * Copy the contents of the array from <code>start</code> to <code>end</code>
      * to the destination <code>destArray</code> with destination offset
      * <code>destOffset</code>.
      *
      * @param uiStart The index of the first element to copy.
      * @param numelements number of element, the index after the last element to copy.
      * @param destArray The array to copy to.
      * @param uiDestOffset Where to start copying into <code>destArray</code>.
      *
      * @throws InvalidFSObjectException
      * @throws FSArrayOutOfBoundsException If <code>start &lt; 0</code>
      * or <code>end > size()</code> or
      * <code>destOffset + (end - start) > destArray.length</code>.
      */
     void copyToArray(
       size_t uiStart,
       size_t uiEnd,
       T* destArray,
       size_t uiDestOffset) const;

     void copyFromArray(
       T const * sourceArray,
       size_t uiStart,
       size_t uiEnd,
       size_t uiOffset);

  /**
    * Copy the contents of the array from <code>start</code> for <code>numelements</code> to the
    * destination <code>destArray</code> with destination offset <code>destOffset</code>.
    *
    * @param srcOffset	  The index of the first element to copy.
    * @param dest          The array to copy to.
    * @param destOffset    Where to start copying into.
    * @param numelements   The number of elements to copy.
    * @throws InvalidFSObjectException
    * @throws FSArrayOutOfBoundsException
    *        If <code>srcOffset &lt; 0</code> or <code>length > size()</code> or
    *        <code>destOffset + length > destArray.length</code>.
    */
   void copyToArray(size_t srcOffset, T * destArray, size_t destOffset, size_t numelements) const ;


  /**
    * Copy the contents of an external array into this array.
    *
    * @param src          The source array.
    * @param srcOffset    Where to start copying in the source array.
    * @param destOffset   Where to start copying to in the destination array.
    * @param length       The number of elements to copy.
    * @throws InvalidFSObjectException
    * @throws FSArrayOutOfBoundsException If <code>srcOffset or destOffset &lt; 0</code>
    * or <code>length > size()</code> or
    * <code>destOffset + length > size()</code>.
    *
    * NOTE: replace copyFromArray with this API to be consistent with the Java API.
    */

 //  void copyFromArray(T const * src, size_t srcOffset, size_t destOffset, size_t length) ;

     /// @if internal
     /**
      * create a feature structure of type empty list (list length is zero)
      * @param bIsPermanent indicate if the data should be permanent,
      *                     i.e., has a lifetime longer than the document
      */
     static BasicArrayFS createArrayFS( CAS & cas, size_t uiSize, bool bIsPermanent = false );
     /// @endif internal

   }
   ; // class ArrayFS

   typedef BasicArrayFS< FeatureStructure, internal::gs_tyFSArrayType > BasicFSArrayFS;
   /**
    * A ArrayFS object implements an array of FeatureStructure values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see IntArrayFS
    * @see StringArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC ArrayFS : public BasicFSArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     ArrayFS(lowlevel::TyFS anFS, uima::CAS& cas, bool bDoChecks = true) :
         BasicFSArrayFS(anFS, cas, bDoChecks) {}
   public:
     ArrayFS() :
         BasicFSArrayFS() {}

     explicit ArrayFS( FeatureStructure const & fs ) :
         BasicFSArrayFS(fs) {}

     ArrayFS( BasicFSArrayFS const & fs ) :
         BasicFSArrayFS(fs) {}
     /// @endif internal
   };

   typedef BasicArrayFS< float, internal::gs_tyFloatArrayType > BasicFloatArrayFS;
   /**
    * A FloatArrayFS object implements an array of float values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see IntArrayFS
    * @see StringArrayFS
    */
   class UIMA_LINK_IMPORTSPEC FloatArrayFS : public BasicFloatArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     FloatArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicFloatArrayFS(anFS, cas, bDoChecks) {}
   public:
     FloatArrayFS() :
         BasicFloatArrayFS() {}

     explicit FloatArrayFS( FeatureStructure const & fs ) :
         BasicFloatArrayFS(fs) {}

     FloatArrayFS( BasicFloatArrayFS const & fs ) :
         BasicFloatArrayFS(fs) {}
     /// @endif internal
   };

   typedef BasicArrayFS< int, internal::gs_tyIntArrayType > BasicIntArrayFS;
   /**
    * A IntArrayFS object implements an array of int values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see StringArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC IntArrayFS : public BasicIntArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     IntArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicIntArrayFS(anFS, cas, bDoChecks) {}
   public:
     IntArrayFS() :
         BasicIntArrayFS() {}

     explicit IntArrayFS( FeatureStructure const & fs ) :
         BasicIntArrayFS(fs) {}

     IntArrayFS( BasicIntArrayFS const & fs ) :
         BasicIntArrayFS(fs) {}
     /// @endif internal
   };

   typedef BasicArrayFS< UnicodeStringRef, internal::gs_tyStringArrayType > BasicStringArrayFS;
   /**
    * A StringArrayFS object implements an array of string values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see IntArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC StringArrayFS : public BasicStringArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     StringArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicStringArrayFS(anFS, cas, bDoChecks) {}
   public:
     StringArrayFS() :
         BasicStringArrayFS() {}

     explicit StringArrayFS( FeatureStructure const & fs ) :
         BasicStringArrayFS(fs) {}

     StringArrayFS( BasicStringArrayFS const & fs ) :
         BasicStringArrayFS(fs) {}
     /// @endif internal
   };

   typedef BasicArrayFS< bool, internal::gs_tyBooleanArrayType > BasicBooleanArrayFS;
   /**
    * A ByteArrayFS object implements an array of byte values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see StringArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC BooleanArrayFS : public BasicBooleanArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     BooleanArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicBooleanArrayFS(anFS, cas, bDoChecks) {}
   public:
     BooleanArrayFS() :
         BasicBooleanArrayFS() {}

     explicit BooleanArrayFS( FeatureStructure const & fs ) :
         BasicBooleanArrayFS(fs) {}

     BooleanArrayFS( BasicBooleanArrayFS const & fs ) :
         BasicBooleanArrayFS(fs) {}
     /// @endif internal
   };


   typedef BasicArrayFS< char, internal::gs_tyByteArrayType > BasicByteArrayFS;
   /**
    * A ByteArrayFS object implements an array of byte values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see StringArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC ByteArrayFS : public BasicByteArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     ByteArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicByteArrayFS(anFS, cas, bDoChecks) {}
   public:
     ByteArrayFS() :
         BasicByteArrayFS() {}

     explicit ByteArrayFS( FeatureStructure const & fs ) :
         BasicByteArrayFS(fs) {}

     ByteArrayFS( BasicByteArrayFS const & fs ) :
         BasicByteArrayFS(fs) {}
     /// @endif internal
   };

   typedef BasicArrayFS<short, internal::gs_tyShortArrayType > BasicShortArrayFS;
   /**
    * A ShortArrayFS object implements an array of short values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see StringArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC ShortArrayFS : public BasicShortArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     ShortArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicShortArrayFS(anFS, cas, bDoChecks) {}
   public:
     ShortArrayFS() :
         BasicShortArrayFS() {}

     explicit ShortArrayFS( FeatureStructure const & fs ) :
         BasicShortArrayFS(fs) {}

     ShortArrayFS( BasicShortArrayFS const & fs ) :
         BasicShortArrayFS(fs) {}
     /// @endif internal
   };

   typedef BasicArrayFS< INT64, internal::gs_tyLongArrayType > BasicLongArrayFS;
   /**
    * A ShortArrayFS object implements an array of short values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see StringArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC LongArrayFS : public BasicLongArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     LongArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicLongArrayFS(anFS, cas, bDoChecks) {}
   public:
     LongArrayFS() :
         BasicLongArrayFS() {}

     explicit LongArrayFS( FeatureStructure const & fs ) :
         BasicLongArrayFS(fs) {}

     LongArrayFS( BasicLongArrayFS const & fs ) :
         BasicLongArrayFS(fs) {}
     /// @endif internal
   };


   typedef BasicArrayFS<double, internal::gs_tyDoubleArrayType > BasicDoubleArrayFS;
   /**
    * A StringArrayFS object implements an array of string values.
    * It is derived from the BasicArrayFS template interface so all
    * interesting member functions are derived from BasicArrayFS.
    * @see BasicArrayFS
    * @see ArrayFS
    * @see IntArrayFS
    * @see FloatArrayFS
    */
   class UIMA_LINK_IMPORTSPEC DoubleArrayFS : public BasicDoubleArrayFS {
     /// @if internal
     friend class CAS;
     friend class FeatureStructure;
   protected:
     DoubleArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
         BasicDoubleArrayFS(anFS, cas, bDoChecks) {}
   public:
     DoubleArrayFS() :
         BasicDoubleArrayFS() {}

     explicit DoubleArrayFS( FeatureStructure const & fs ) :
         BasicDoubleArrayFS(fs) {}

     DoubleArrayFS( BasicDoubleArrayFS const & fs ) :
         BasicDoubleArrayFS(fs) {}
     /// @endif internal
   };


 } // namespace uima

 #endif
 /* <EOF> */
	#ifndef UIMA_ARRAYFS_HPP
	#define UIMA_ARRAYFS_HPP
	/** \file arrayfs.hpp .
	-----------------------------------------------------------------------------



	* 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.

	-----------------------------------------------------------------------------

	\brief Declares all ArrayFS classes (IntArrayFS, FloatArrayFS etc)

	Description:

	-----------------------------------------------------------------------------


	-------------------------------------------------------------------------- */


	/* ----------------------------------------------------------------------- */
	/* Include dependencies */
	/* ----------------------------------------------------------------------- */

	#include "uima/pragmas.hpp"

	#include "uima/lowlevel_typedefs.hpp"
	#include "uima/typesystem.hpp"
	#include "uima/casexception.hpp"
	#include "uima/featurestructure.hpp"
	#include "uima/internal_typeshortcuts.hpp"

	#include "unicode/utf.h"
	/* ----------------------------------------------------------------------- */
	/* Constants */
	/* ----------------------------------------------------------------------- */

	/* ----------------------------------------------------------------------- */
	/* Forward declarations */
	/* ----------------------------------------------------------------------- */


	namespace uima {
	class CAS;
	namespace lowlevel {
	class FSHeap;
	}
	}

	/* ----------------------------------------------------------------------- */
	/* Types / Classes */
	/* ----------------------------------------------------------------------- */

	namespace uima {
	// exceptions
	UIMA_EXC_CLASSDECLARE(FSIsNotArrayException, CASException);
	UIMA_EXC_CLASSDECLARE(FSArrayOutOfBoundsException, CASException);
	} // namespace uima

	/* ----------------------------------------------------------------------- */
	/* ArrayFS */
	/* ----------------------------------------------------------------------- */

	namespace uima {
	/// @if internal
	template< class T, const uima::lowlevel::TyFSType ARRAY_TYPE >
	/// @endif internal
	/**
	* A on object representing an array of CAS elements.
	* An element can be either a FeatureStructure or a float or an int or a
	* string. For each such element type there is a sub-class of BasicListFS
	* implementing this template interface with type specific methods:
	* ArrayFS, IntArrayFS, FloatArrayFS, StringArrayFS.
	*
	* All get methods may throw an <code>InvalidFSObjectException</code> if the
	* feature structure object is not valid.
	* All access methods using array indexes may throw an
	* <code>FSArrayOutOfBoundsException</code> if the index is >= the array size.
	*
	* Creating an array can be done like this:
	@code
	// store elements of a vector of strings in an array feature
	FeatureStructure fsNewString; // re-used for each new string
	const size_t uiARRAY_SIZE = vecStrings.size();
	StringArrayFS fsNewArray = tcas.createStringArrayFS(uiARRAY_SIZE); // create an array
	// build up a fs array from our vector
	for (size_t i = 0; i < vecStrings.size(); ++i) {
	fsNewArray.set(i, vecStrings[i]);
	}
	// now that the array is complete, set the feature value to the array
	fsWithArrayFeature.setFSValue(fArrayFeature, fsNewArray);
	@endcode
	* Accessing a array can be done like this:
	@code
	// get array
	StringArrayFS fsArray = fsWithArrayFeature.getStringArrayFSValue(fArrayFeature);
	// iterate array
	for (size_t i = 0; i < fsArray.size(); ++i) {
	cout << fsArray.get(i) << " ";
	}
	@endcode
	*
	* The example uses StringArrayFS to show the usage of the interfaces with
	* strings. Usage of FeatureStructure, int or float values is analogous.
	*
	* Arrays can not be resized after creation. If more (or less) elements are
	* required in the array a new array must be created.
	* Elements from the old array may be copied to then new array.
	* Finally the new array must be assigned to the array feature holding the
	* old array.
	*
	* @see ArrayFS
	* @see IntArrayFS
	* @see FloatArrayFS
	* @see StringArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC BasicArrayFS : public FeatureStructure {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	BasicArrayFS(lowlevel::TyFS anFS, uima::CAS&, bool bDoChecks = true);
	/// @endif internal
	public:

	/**
	* Default CTOR: Creates an invalid BasicArrayFS (use CAS::createArrayFS() instead)
	*/
	BasicArrayFS();

	/**
	* Upgrade/Conversion CTOR: Creates an ArrayFS from an existing FeatureStructure.
	* fs must be of type array.
	*
	* @throws FSIsNotArrayException
	*/
	explicit BasicArrayFS( FeatureStructure const & fs );

	/**
	* get the <code>n</code>th element of an array.
	* @throws InvalidFSObjectException
	* @throws FSArrayOutOfBoundsException
	*/
	T get(size_t n) const;

	/**
	* set the <code>n</code>th element of an array.
	* @throws InvalidFSObjectException
	* @throws FSArrayOutOfBoundsException
	*/
	void set(size_t n, T const & val);

	/**
	* get the size of the array
	* @throws InvalidFSObjectException
	*/
	size_t size() const;

	/**
	* Copy the contents of the array from <code>start</code> to <code>end</code>
	* to the destination <code>destArray</code> with destination offset
	* <code>destOffset</code>.
	*
	* @param uiStart The index of the first element to copy.
	* @param numelements number of element, the index after the last element to copy.
	* @param destArray The array to copy to.
	* @param uiDestOffset Where to start copying into <code>destArray</code>.
	*
	* @throws InvalidFSObjectException
	* @throws FSArrayOutOfBoundsException If <code>start < 0</code>
	* or <code>end > size()</code> or
	* <code>destOffset + (end - start) > destArray.length</code>.
	*/
	void copyToArray(
	size_t uiStart,
	size_t uiEnd,
	T* destArray,
	size_t uiDestOffset) const;

	void copyFromArray(
	T const * sourceArray,
	size_t uiStart,
	size_t uiEnd,
	size_t uiOffset);

	/**
	* Copy the contents of the array from <code>start</code> for <code>numelements</code> to the
	* destination <code>destArray</code> with destination offset <code>destOffset</code>.
	*
	* @param srcOffset The index of the first element to copy.
	* @param dest The array to copy to.
	* @param destOffset Where to start copying into.
	* @param numelements The number of elements to copy.
	* @throws InvalidFSObjectException
	* @throws FSArrayOutOfBoundsException
	* If <code>srcOffset < 0</code> or <code>length > size()</code> or
	* <code>destOffset + length > destArray.length</code>.
	*/
	void copyToArray(size_t srcOffset, T * destArray, size_t destOffset, size_t numelements) const ;


	/**
	* Copy the contents of an external array into this array.
	*
	* @param src The source array.
	* @param srcOffset Where to start copying in the source array.
	* @param destOffset Where to start copying to in the destination array.
	* @param length The number of elements to copy.
	* @throws InvalidFSObjectException
	* @throws FSArrayOutOfBoundsException If <code>srcOffset or destOffset < 0</code>
	* or <code>length > size()</code> or
	* <code>destOffset + length > size()</code>.
	*
	* NOTE: replace copyFromArray with this API to be consistent with the Java API.
	*/

	// void copyFromArray(T const * src, size_t srcOffset, size_t destOffset, size_t length) ;

	/// @if internal
	/**
	* create a feature structure of type empty list (list length is zero)
	* @param bIsPermanent indicate if the data should be permanent,
	* i.e., has a lifetime longer than the document
	*/
	static BasicArrayFS createArrayFS( CAS & cas, size_t uiSize, bool bIsPermanent = false );
	/// @endif internal

	}
	; // class ArrayFS

	typedef BasicArrayFS< FeatureStructure, internal::gs_tyFSArrayType > BasicFSArrayFS;
	/**
	* A ArrayFS object implements an array of FeatureStructure values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see IntArrayFS
	* @see StringArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC ArrayFS : public BasicFSArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	ArrayFS(lowlevel::TyFS anFS, uima::CAS& cas, bool bDoChecks = true) :
	BasicFSArrayFS(anFS, cas, bDoChecks) {}
	public:
	ArrayFS() :
	BasicFSArrayFS() {}

	explicit ArrayFS( FeatureStructure const & fs ) :
	BasicFSArrayFS(fs) {}

	ArrayFS( BasicFSArrayFS const & fs ) :
	BasicFSArrayFS(fs) {}
	/// @endif internal
	};

	typedef BasicArrayFS< float, internal::gs_tyFloatArrayType > BasicFloatArrayFS;
	/**
	* A FloatArrayFS object implements an array of float values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see IntArrayFS
	* @see StringArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC FloatArrayFS : public BasicFloatArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	FloatArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicFloatArrayFS(anFS, cas, bDoChecks) {}
	public:
	FloatArrayFS() :
	BasicFloatArrayFS() {}

	explicit FloatArrayFS( FeatureStructure const & fs ) :
	BasicFloatArrayFS(fs) {}

	FloatArrayFS( BasicFloatArrayFS const & fs ) :
	BasicFloatArrayFS(fs) {}
	/// @endif internal
	};

	typedef BasicArrayFS< int, internal::gs_tyIntArrayType > BasicIntArrayFS;
	/**
	* A IntArrayFS object implements an array of int values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see StringArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC IntArrayFS : public BasicIntArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	IntArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicIntArrayFS(anFS, cas, bDoChecks) {}
	public:
	IntArrayFS() :
	BasicIntArrayFS() {}

	explicit IntArrayFS( FeatureStructure const & fs ) :
	BasicIntArrayFS(fs) {}

	IntArrayFS( BasicIntArrayFS const & fs ) :
	BasicIntArrayFS(fs) {}
	/// @endif internal
	};

	typedef BasicArrayFS< UnicodeStringRef, internal::gs_tyStringArrayType > BasicStringArrayFS;
	/**
	* A StringArrayFS object implements an array of string values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see IntArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC StringArrayFS : public BasicStringArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	StringArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicStringArrayFS(anFS, cas, bDoChecks) {}
	public:
	StringArrayFS() :
	BasicStringArrayFS() {}

	explicit StringArrayFS( FeatureStructure const & fs ) :
	BasicStringArrayFS(fs) {}

	StringArrayFS( BasicStringArrayFS const & fs ) :
	BasicStringArrayFS(fs) {}
	/// @endif internal
	};

	typedef BasicArrayFS< bool, internal::gs_tyBooleanArrayType > BasicBooleanArrayFS;
	/**
	* A ByteArrayFS object implements an array of byte values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see StringArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC BooleanArrayFS : public BasicBooleanArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	BooleanArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicBooleanArrayFS(anFS, cas, bDoChecks) {}
	public:
	BooleanArrayFS() :
	BasicBooleanArrayFS() {}

	explicit BooleanArrayFS( FeatureStructure const & fs ) :
	BasicBooleanArrayFS(fs) {}

	BooleanArrayFS( BasicBooleanArrayFS const & fs ) :
	BasicBooleanArrayFS(fs) {}
	/// @endif internal
	};



	typedef BasicArrayFS< char, internal::gs_tyByteArrayType > BasicByteArrayFS;
	/**
	* A ByteArrayFS object implements an array of byte values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see StringArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC ByteArrayFS : public BasicByteArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	ByteArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicByteArrayFS(anFS, cas, bDoChecks) {}
	public:
	ByteArrayFS() :
	BasicByteArrayFS() {}

	explicit ByteArrayFS( FeatureStructure const & fs ) :
	BasicByteArrayFS(fs) {}

	ByteArrayFS( BasicByteArrayFS const & fs ) :
	BasicByteArrayFS(fs) {}
	/// @endif internal
	};

	typedef BasicArrayFS<short, internal::gs_tyShortArrayType > BasicShortArrayFS;
	/**
	* A ShortArrayFS object implements an array of short values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see StringArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC ShortArrayFS : public BasicShortArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	ShortArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicShortArrayFS(anFS, cas, bDoChecks) {}
	public:
	ShortArrayFS() :
	BasicShortArrayFS() {}

	explicit ShortArrayFS( FeatureStructure const & fs ) :
	BasicShortArrayFS(fs) {}

	ShortArrayFS( BasicShortArrayFS const & fs ) :
	BasicShortArrayFS(fs) {}
	/// @endif internal
	};

	typedef BasicArrayFS< INT64, internal::gs_tyLongArrayType > BasicLongArrayFS;
	/**
	* A ShortArrayFS object implements an array of short values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see StringArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC LongArrayFS : public BasicLongArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	LongArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicLongArrayFS(anFS, cas, bDoChecks) {}
	public:
	LongArrayFS() :
	BasicLongArrayFS() {}

	explicit LongArrayFS( FeatureStructure const & fs ) :
	BasicLongArrayFS(fs) {}

	LongArrayFS( BasicLongArrayFS const & fs ) :
	BasicLongArrayFS(fs) {}
	/// @endif internal
	};


	typedef BasicArrayFS<double, internal::gs_tyDoubleArrayType > BasicDoubleArrayFS;
	/**
	* A StringArrayFS object implements an array of string values.
	* It is derived from the BasicArrayFS template interface so all
	* interesting member functions are derived from BasicArrayFS.
	* @see BasicArrayFS
	* @see ArrayFS
	* @see IntArrayFS
	* @see FloatArrayFS
	*/
	class UIMA_LINK_IMPORTSPEC DoubleArrayFS : public BasicDoubleArrayFS {
	/// @if internal
	friend class CAS;
	friend class FeatureStructure;
	protected:
	DoubleArrayFS(lowlevel::TyFS anFS, uima::CAS & cas, bool bDoChecks = true) :
	BasicDoubleArrayFS(anFS, cas, bDoChecks) {}
	public:
	DoubleArrayFS() :
	BasicDoubleArrayFS() {}

	explicit DoubleArrayFS( FeatureStructure const & fs ) :
	BasicDoubleArrayFS(fs) {}

	DoubleArrayFS( BasicDoubleArrayFS const & fs ) :
	BasicDoubleArrayFS(fs) {}
	/// @endif internal
	};



	} // namespace uima

	#endif
	/* <EOF> */