OpenCascade.js
API ReferenceSyntheticNCollectionAutoGenerated

Generated

OCCT package Generated: BRepToolsWrapper, GeomToolsWrapper, NCollection_Array1_AppParCurves_ConstraintCouple,…

NCollection_Array1_AppParCurves_ConstraintCouple

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_AppParCurves_MultiBSpCurve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_AppParCurves_MultiCurve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_AppParCurves_MultiPoint

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: AppParCurves_MultiPoint): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: unknown): unknown

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: unknown): unknown

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: unknown): unknown

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): AppParCurves_MultiPoint
    Returns

    first element

  • ChangeFirst(): AppParCurves_MultiPoint
    Returns

    first element

  • Last(): AppParCurves_MultiPoint
    Returns

    last element

  • ChangeLast(): AppParCurves_MultiPoint
    Returns

    last element

  • Value(theIndex: number): AppParCurves_MultiPoint

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): AppParCurves_MultiPoint

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): AppParCurves_MultiPoint

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): AppParCurves_MultiPoint

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: AppParCurves_MultiPoint): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_Bnd_Box

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Bnd_Box): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_Bnd_Box): NCollection_Array1_Bnd_Box

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_Bnd_Box): NCollection_Array1_Bnd_Box

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_Bnd_Box): NCollection_Array1_Bnd_Box

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Bnd_Box
    Returns

    first element

  • ChangeFirst(): Bnd_Box
    Returns

    first element

  • Last(): Bnd_Box
    Returns

    last element

  • ChangeLast(): Bnd_Box
    Returns

    last element

  • Value(theIndex: number): Bnd_Box

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Bnd_Box

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Bnd_Box

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Bnd_Box

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Bnd_Box): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_Bnd_Box2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Bnd_Box2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_Bnd_Box2d): NCollection_Array1_Bnd_Box2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_Bnd_Box2d): NCollection_Array1_Bnd_Box2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_Bnd_Box2d): NCollection_Array1_Bnd_Box2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Bnd_Box2d
    Returns

    first element

  • ChangeFirst(): Bnd_Box2d
    Returns

    first element

  • Last(): Bnd_Box2d
    Returns

    last element

  • ChangeLast(): Bnd_Box2d
    Returns

    last element

  • Value(theIndex: number): Bnd_Box2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Bnd_Box2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Bnd_Box2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Bnd_Box2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Bnd_Box2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_Bnd_Sphere

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Bnd_Sphere): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_Bnd_Sphere): NCollection_Array1_Bnd_Sphere

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_Bnd_Sphere): NCollection_Array1_Bnd_Sphere

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_Bnd_Sphere): NCollection_Array1_Bnd_Sphere

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Bnd_Sphere
    Returns

    first element

  • ChangeFirst(): Bnd_Sphere
    Returns

    first element

  • Last(): Bnd_Sphere
    Returns

    last element

  • ChangeLast(): Bnd_Sphere
    Returns

    last element

  • Value(theIndex: number): Bnd_Sphere

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Bnd_Sphere

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Bnd_Sphere

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Bnd_Sphere

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Bnd_Sphere): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_bool

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: boolean): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_bool): NCollection_Array1_bool

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_bool): NCollection_Array1_bool

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_bool): NCollection_Array1_bool

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): boolean
    Returns

    first element

  • ChangeFirst(): boolean
    Returns

    first element

  • Last(): boolean
    Returns

    last element

  • ChangeLast(): boolean
    Returns

    last element

  • Value(theIndex: number): boolean

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): boolean

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): boolean

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): boolean

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: boolean): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_BOPDS_Pave

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: BOPDS_Pave): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_BOPDS_Pave): NCollection_Array1_BOPDS_Pave

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_BOPDS_Pave): NCollection_Array1_BOPDS_Pave

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_BOPDS_Pave): NCollection_Array1_BOPDS_Pave

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): BOPDS_Pave
    Returns

    first element

  • ChangeFirst(): BOPDS_Pave
    Returns

    first element

  • Last(): BOPDS_Pave
    Returns

    last element

  • ChangeLast(): BOPDS_Pave
    Returns

    last element

  • Value(theIndex: number): BOPDS_Pave

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): BOPDS_Pave

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): BOPDS_Pave

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): BOPDS_Pave

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: BOPDS_Pave): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_BRepAdaptor_Curve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: BRepAdaptor_Curve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_BRepAdaptor_Curve): NCollection_Array1_BRepAdaptor_Curve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_BRepAdaptor_Curve): NCollection_Array1_BRepAdaptor_Curve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_BRepAdaptor_Curve): NCollection_Array1_BRepAdaptor_Curve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): BRepAdaptor_Curve
    Returns

    first element

  • ChangeFirst(): BRepAdaptor_Curve
    Returns

    first element

  • Last(): BRepAdaptor_Curve
    Returns

    last element

  • ChangeLast(): BRepAdaptor_Curve
    Returns

    last element

  • Value(theIndex: number): BRepAdaptor_Curve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): BRepAdaptor_Curve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): BRepAdaptor_Curve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): BRepAdaptor_Curve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: BRepAdaptor_Curve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_char

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: string): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_char): NCollection_Array1_char

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_char): NCollection_Array1_char

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_char): NCollection_Array1_char

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): string
    Returns

    first element

  • ChangeFirst(): string
    Returns

    first element

  • Last(): string
    Returns

    last element

  • ChangeLast(): string
    Returns

    last element

  • Value(theIndex: number): string

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): string

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): string

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): string

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: string): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_ChFiDS_CircSection

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: ChFiDS_CircSection): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_ChFiDS_CircSection): NCollection_Array1_ChFiDS_CircSection

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_ChFiDS_CircSection): NCollection_Array1_ChFiDS_CircSection

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_ChFiDS_CircSection): NCollection_Array1_ChFiDS_CircSection

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): ChFiDS_CircSection
    Returns

    first element

  • ChangeFirst(): ChFiDS_CircSection
    Returns

    first element

  • Last(): ChFiDS_CircSection
    Returns

    last element

  • ChangeLast(): ChFiDS_CircSection
    Returns

    last element

  • Value(theIndex: number): ChFiDS_CircSection

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): ChFiDS_CircSection

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): ChFiDS_CircSection

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): ChFiDS_CircSection

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: ChFiDS_CircSection): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_double

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: number): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_double): NCollection_Array1_double

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_double): NCollection_Array1_double

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_double): NCollection_Array1_double

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): number
    Returns

    first element

  • ChangeFirst(): number
    Returns

    first element

  • Last(): number
    Returns

    last element

  • ChangeLast(): number
    Returns

    last element

  • Value(theIndex: number): number

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): number

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): number

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): number

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: number): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_Extrema_POnCurv

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Extrema_POnCurv): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_Extrema_POnCurv): NCollection_Array1_Extrema_POnCurv

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_Extrema_POnCurv): NCollection_Array1_Extrema_POnCurv

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_Extrema_POnCurv): NCollection_Array1_Extrema_POnCurv

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Extrema_POnCurv
    Returns

    first element

  • ChangeFirst(): Extrema_POnCurv
    Returns

    first element

  • Last(): Extrema_POnCurv
    Returns

    last element

  • ChangeLast(): Extrema_POnCurv
    Returns

    last element

  • Value(theIndex: number): Extrema_POnCurv

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Extrema_POnCurv

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Extrema_POnCurv

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Extrema_POnCurv

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Extrema_POnCurv): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_Extrema_POnCurv2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Extrema_POnCurv2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_Extrema_POnCurv2d): NCollection_Array1_Extrema_POnCurv2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_Extrema_POnCurv2d): NCollection_Array1_Extrema_POnCurv2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_Extrema_POnCurv2d): NCollection_Array1_Extrema_POnCurv2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Extrema_POnCurv2d
    Returns

    first element

  • ChangeFirst(): Extrema_POnCurv2d
    Returns

    first element

  • Last(): Extrema_POnCurv2d
    Returns

    last element

  • ChangeLast(): Extrema_POnCurv2d
    Returns

    last element

  • Value(theIndex: number): Extrema_POnCurv2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Extrema_POnCurv2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Extrema_POnCurv2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Extrema_POnCurv2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Extrema_POnCurv2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_Extrema_POnSurf

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Extrema_POnSurf): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_Extrema_POnSurf): NCollection_Array1_Extrema_POnSurf

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_Extrema_POnSurf): NCollection_Array1_Extrema_POnSurf

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_Extrema_POnSurf): NCollection_Array1_Extrema_POnSurf

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Extrema_POnSurf
    Returns

    first element

  • ChangeFirst(): Extrema_POnSurf
    Returns

    first element

  • Last(): Extrema_POnSurf
    Returns

    last element

  • ChangeLast(): Extrema_POnSurf
    Returns

    last element

  • Value(theIndex: number): Extrema_POnSurf

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Extrema_POnSurf

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Extrema_POnSurf

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Extrema_POnSurf

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Extrema_POnSurf): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_float

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: number): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_float): NCollection_Array1_float

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_float): NCollection_Array1_float

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_float): NCollection_Array1_float

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): number
    Returns

    first element

  • ChangeFirst(): number
    Returns

    first element

  • Last(): number
    Returns

    last element

  • ChangeLast(): number
    Returns

    last element

  • Value(theIndex: number): number

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): number

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): number

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): number

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: number): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_GccEnt_Position

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: GccEnt_Position): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_GccEnt_Position): NCollection_Array1_GccEnt_Position

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_GccEnt_Position): NCollection_Array1_GccEnt_Position

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_GccEnt_Position): NCollection_Array1_GccEnt_Position

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): GccEnt_Position
    Returns

    first element

  • ChangeFirst(): GccEnt_Position
    Returns

    first element

  • Last(): GccEnt_Position
    Returns

    last element

  • ChangeLast(): GccEnt_Position
    Returns

    last element

  • Value(theIndex: number): GccEnt_Position

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): GccEnt_Position

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): GccEnt_Position

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): GccEnt_Position

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: GccEnt_Position): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Circ2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Circ2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Circ2d): NCollection_Array1_gp_Circ2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Circ2d): NCollection_Array1_gp_Circ2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Circ2d): NCollection_Array1_gp_Circ2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Circ2d
    Returns

    first element

  • ChangeFirst(): gp_Circ2d
    Returns

    first element

  • Last(): gp_Circ2d
    Returns

    last element

  • ChangeLast(): gp_Circ2d
    Returns

    last element

  • Value(theIndex: number): gp_Circ2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Circ2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Circ2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Circ2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Circ2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Dir

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Dir): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Dir): NCollection_Array1_gp_Dir

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Dir): NCollection_Array1_gp_Dir

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Dir): NCollection_Array1_gp_Dir

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Dir
    Returns

    first element

  • ChangeFirst(): gp_Dir
    Returns

    first element

  • Last(): gp_Dir
    Returns

    last element

  • ChangeLast(): gp_Dir
    Returns

    last element

  • Value(theIndex: number): gp_Dir

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Dir

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Dir

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Dir

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Dir): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Dir2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Dir2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Dir2d): NCollection_Array1_gp_Dir2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Dir2d): NCollection_Array1_gp_Dir2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Dir2d): NCollection_Array1_gp_Dir2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Dir2d
    Returns

    first element

  • ChangeFirst(): gp_Dir2d
    Returns

    first element

  • Last(): gp_Dir2d
    Returns

    last element

  • ChangeLast(): gp_Dir2d
    Returns

    last element

  • Value(theIndex: number): gp_Dir2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Dir2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Dir2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Dir2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Dir2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_GTrsf2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_GTrsf2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_GTrsf2d): NCollection_Array1_gp_GTrsf2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_GTrsf2d): NCollection_Array1_gp_GTrsf2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_GTrsf2d): NCollection_Array1_gp_GTrsf2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_GTrsf2d
    Returns

    first element

  • ChangeFirst(): gp_GTrsf2d
    Returns

    first element

  • Last(): gp_GTrsf2d
    Returns

    last element

  • ChangeLast(): gp_GTrsf2d
    Returns

    last element

  • Value(theIndex: number): gp_GTrsf2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_GTrsf2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_GTrsf2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_GTrsf2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_GTrsf2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Lin

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Lin): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Lin): NCollection_Array1_gp_Lin

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Lin): NCollection_Array1_gp_Lin

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Lin): NCollection_Array1_gp_Lin

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Lin
    Returns

    first element

  • ChangeFirst(): gp_Lin
    Returns

    first element

  • Last(): gp_Lin
    Returns

    last element

  • ChangeLast(): gp_Lin
    Returns

    last element

  • Value(theIndex: number): gp_Lin

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Lin

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Lin

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Lin

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Lin): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Lin2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Lin2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Lin2d): NCollection_Array1_gp_Lin2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Lin2d): NCollection_Array1_gp_Lin2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Lin2d): NCollection_Array1_gp_Lin2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Lin2d
    Returns

    first element

  • ChangeFirst(): gp_Lin2d
    Returns

    first element

  • Last(): gp_Lin2d
    Returns

    last element

  • ChangeLast(): gp_Lin2d
    Returns

    last element

  • Value(theIndex: number): gp_Lin2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Lin2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Lin2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Lin2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Lin2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Mat

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Mat): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Mat): NCollection_Array1_gp_Mat

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Mat): NCollection_Array1_gp_Mat

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Mat): NCollection_Array1_gp_Mat

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Mat
    Returns

    first element

  • ChangeFirst(): gp_Mat
    Returns

    first element

  • Last(): gp_Mat
    Returns

    last element

  • ChangeLast(): gp_Mat
    Returns

    last element

  • Value(theIndex: number): gp_Mat

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Mat

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Mat

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Mat

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Mat): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Pnt

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Pnt): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Pnt): NCollection_Array1_gp_Pnt

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Pnt): NCollection_Array1_gp_Pnt

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Pnt): NCollection_Array1_gp_Pnt

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Pnt
    Returns

    first element

  • ChangeFirst(): gp_Pnt
    Returns

    first element

  • Last(): gp_Pnt
    Returns

    last element

  • ChangeLast(): gp_Pnt
    Returns

    last element

  • Value(theIndex: number): gp_Pnt

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Pnt

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Pnt

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Pnt

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Pnt): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Pnt2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Pnt2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Pnt2d): NCollection_Array1_gp_Pnt2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Pnt2d): NCollection_Array1_gp_Pnt2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Pnt2d): NCollection_Array1_gp_Pnt2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Pnt2d
    Returns

    first element

  • ChangeFirst(): gp_Pnt2d
    Returns

    first element

  • Last(): gp_Pnt2d
    Returns

    last element

  • ChangeLast(): gp_Pnt2d
    Returns

    last element

  • Value(theIndex: number): gp_Pnt2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Pnt2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Pnt2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Pnt2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Pnt2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Trsf

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Trsf): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Trsf): NCollection_Array1_gp_Trsf

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Trsf): NCollection_Array1_gp_Trsf

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Trsf): NCollection_Array1_gp_Trsf

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Trsf
    Returns

    first element

  • ChangeFirst(): gp_Trsf
    Returns

    first element

  • Last(): gp_Trsf
    Returns

    last element

  • ChangeLast(): gp_Trsf
    Returns

    last element

  • Value(theIndex: number): gp_Trsf

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Trsf

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Trsf

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Trsf

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Trsf): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Vec

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Vec): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Vec): NCollection_Array1_gp_Vec

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Vec): NCollection_Array1_gp_Vec

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Vec): NCollection_Array1_gp_Vec

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Vec
    Returns

    first element

  • ChangeFirst(): gp_Vec
    Returns

    first element

  • Last(): gp_Vec
    Returns

    last element

  • ChangeLast(): gp_Vec
    Returns

    last element

  • Value(theIndex: number): gp_Vec

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Vec

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Vec

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Vec

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Vec): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_Vec2d

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_Vec2d): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_Vec2d): NCollection_Array1_gp_Vec2d

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_Vec2d): NCollection_Array1_gp_Vec2d

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_Vec2d): NCollection_Array1_gp_Vec2d

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_Vec2d
    Returns

    first element

  • ChangeFirst(): gp_Vec2d
    Returns

    first element

  • Last(): gp_Vec2d
    Returns

    last element

  • ChangeLast(): gp_Vec2d
    Returns

    last element

  • Value(theIndex: number): gp_Vec2d

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_Vec2d

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_Vec2d

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_Vec2d

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_Vec2d): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_XY

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_XY): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_XY): NCollection_Array1_gp_XY

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_XY): NCollection_Array1_gp_XY

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_XY): NCollection_Array1_gp_XY

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_XY
    Returns

    first element

  • ChangeFirst(): gp_XY
    Returns

    first element

  • Last(): gp_XY
    Returns

    last element

  • ChangeLast(): gp_XY
    Returns

    last element

  • Value(theIndex: number): gp_XY

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_XY

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_XY

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_XY

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_XY): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_gp_XYZ

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: gp_XYZ): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_gp_XYZ): NCollection_Array1_gp_XYZ

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_gp_XYZ): NCollection_Array1_gp_XYZ

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_gp_XYZ): NCollection_Array1_gp_XYZ

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): gp_XYZ
    Returns

    first element

  • ChangeFirst(): gp_XYZ
    Returns

    first element

  • Last(): gp_XYZ
    Returns

    last element

  • ChangeLast(): gp_XYZ
    Returns

    last element

  • Value(theIndex: number): gp_XYZ

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): gp_XYZ

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): gp_XYZ

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): gp_XYZ

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: gp_XYZ): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Adaptor3d_Curve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Adaptor3d_Curve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Adaptor3d_Curve): NCollection_Array1_handle_Adaptor3d_Curve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Adaptor3d_Curve): NCollection_Array1_handle_Adaptor3d_Curve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Adaptor3d_Curve): NCollection_Array1_handle_Adaptor3d_Curve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Adaptor3d_Curve
    Returns

    first element

  • ChangeFirst(): Adaptor3d_Curve
    Returns

    first element

  • Last(): Adaptor3d_Curve
    Returns

    last element

  • ChangeLast(): Adaptor3d_Curve
    Returns

    last element

  • Value(theIndex: number): Adaptor3d_Curve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Adaptor3d_Curve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Adaptor3d_Curve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Adaptor3d_Curve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Adaptor3d_Curve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Adaptor3d_Surface

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Adaptor3d_Surface): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Adaptor3d_Surface): NCollection_Array1_handle_Adaptor3d_Surface

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Adaptor3d_Surface): NCollection_Array1_handle_Adaptor3d_Surface

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Adaptor3d_Surface): NCollection_Array1_handle_Adaptor3d_Surface

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Adaptor3d_Surface
    Returns

    first element

  • ChangeFirst(): Adaptor3d_Surface
    Returns

    first element

  • Last(): Adaptor3d_Surface
    Returns

    last element

  • ChangeLast(): Adaptor3d_Surface
    Returns

    last element

  • Value(theIndex: number): Adaptor3d_Surface

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Adaptor3d_Surface

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Adaptor3d_Surface

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Adaptor3d_Surface

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Adaptor3d_Surface): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_ChFiDS_Stripe

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: ChFiDS_Stripe): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_ChFiDS_Stripe): NCollection_Array1_handle_ChFiDS_Stripe

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_ChFiDS_Stripe): NCollection_Array1_handle_ChFiDS_Stripe

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_ChFiDS_Stripe): NCollection_Array1_handle_ChFiDS_Stripe

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): ChFiDS_Stripe
    Returns

    first element

  • ChangeFirst(): ChFiDS_Stripe
    Returns

    first element

  • Last(): ChFiDS_Stripe
    Returns

    last element

  • ChangeLast(): ChFiDS_Stripe
    Returns

    last element

  • Value(theIndex: number): ChFiDS_Stripe

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): ChFiDS_Stripe

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): ChFiDS_Stripe

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): ChFiDS_Stripe

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: ChFiDS_Stripe): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Expr_GeneralExpression

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_Expr_NamedUnknown

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Expr_NamedUnknown): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Expr_NamedUnknown): NCollection_Array1_handle_Expr_NamedUnknown

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Expr_NamedUnknown): NCollection_Array1_handle_Expr_NamedUnknown

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Expr_NamedUnknown): NCollection_Array1_handle_Expr_NamedUnknown

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Expr_NamedUnknown
    Returns

    first element

  • ChangeFirst(): Expr_NamedUnknown
    Returns

    first element

  • Last(): Expr_NamedUnknown
    Returns

    last element

  • ChangeLast(): Expr_NamedUnknown
    Returns

    last element

  • Value(theIndex: number): Expr_NamedUnknown

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Expr_NamedUnknown

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Expr_NamedUnknown

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Expr_NamedUnknown

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Expr_NamedUnknown): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Expr_SingleRelation

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Expr_SingleRelation): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Expr_SingleRelation): NCollection_Array1_handle_Expr_SingleRelation

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Expr_SingleRelation): NCollection_Array1_handle_Expr_SingleRelation

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Expr_SingleRelation): NCollection_Array1_handle_Expr_SingleRelation

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Expr_SingleRelation
    Returns

    first element

  • ChangeFirst(): Expr_SingleRelation
    Returns

    first element

  • Last(): Expr_SingleRelation
    Returns

    last element

  • ChangeLast(): Expr_SingleRelation
    Returns

    last element

  • Value(theIndex: number): Expr_SingleRelation

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Expr_SingleRelation

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Expr_SingleRelation

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Expr_SingleRelation

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Expr_SingleRelation): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Geom_BezierCurve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Geom_BezierCurve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Geom_BezierCurve): NCollection_Array1_handle_Geom_BezierCurve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Geom_BezierCurve): NCollection_Array1_handle_Geom_BezierCurve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Geom_BezierCurve): NCollection_Array1_handle_Geom_BezierCurve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Geom_BezierCurve
    Returns

    first element

  • ChangeFirst(): Geom_BezierCurve
    Returns

    first element

  • Last(): Geom_BezierCurve
    Returns

    last element

  • ChangeLast(): Geom_BezierCurve
    Returns

    last element

  • Value(theIndex: number): Geom_BezierCurve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Geom_BezierCurve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Geom_BezierCurve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Geom_BezierCurve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Geom_BezierCurve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Geom_BSplineCurve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Geom_BSplineCurve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Geom_BSplineCurve): NCollection_Array1_handle_Geom_BSplineCurve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Geom_BSplineCurve): NCollection_Array1_handle_Geom_BSplineCurve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Geom_BSplineCurve): NCollection_Array1_handle_Geom_BSplineCurve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Geom_BSplineCurve
    Returns

    first element

  • ChangeFirst(): Geom_BSplineCurve
    Returns

    first element

  • Last(): Geom_BSplineCurve
    Returns

    last element

  • ChangeLast(): Geom_BSplineCurve
    Returns

    last element

  • Value(theIndex: number): Geom_BSplineCurve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Geom_BSplineCurve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Geom_BSplineCurve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Geom_BSplineCurve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Geom_BSplineCurve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Geom_Curve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Geom_Curve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Geom_Curve): NCollection_Array1_handle_Geom_Curve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Geom_Curve): NCollection_Array1_handle_Geom_Curve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Geom_Curve): NCollection_Array1_handle_Geom_Curve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Geom_Curve
    Returns

    first element

  • ChangeFirst(): Geom_Curve
    Returns

    first element

  • Last(): Geom_Curve
    Returns

    last element

  • ChangeLast(): Geom_Curve
    Returns

    last element

  • Value(theIndex: number): Geom_Curve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Geom_Curve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Geom_Curve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Geom_Curve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Geom_Curve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Geom_Surface

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Geom_Surface): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Geom_Surface): NCollection_Array1_handle_Geom_Surface

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Geom_Surface): NCollection_Array1_handle_Geom_Surface

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Geom_Surface): NCollection_Array1_handle_Geom_Surface

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Geom_Surface
    Returns

    first element

  • ChangeFirst(): Geom_Surface
    Returns

    first element

  • Last(): Geom_Surface
    Returns

    last element

  • ChangeLast(): Geom_Surface
    Returns

    last element

  • Value(theIndex: number): Geom_Surface

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Geom_Surface

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Geom_Surface

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Geom_Surface

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Geom_Surface): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Geom2d_BezierCurve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Geom2d_BezierCurve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Geom2d_BezierCurve): NCollection_Array1_handle_Geom2d_BezierCurve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Geom2d_BezierCurve): NCollection_Array1_handle_Geom2d_BezierCurve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Geom2d_BezierCurve): NCollection_Array1_handle_Geom2d_BezierCurve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Geom2d_BezierCurve
    Returns

    first element

  • ChangeFirst(): Geom2d_BezierCurve
    Returns

    first element

  • Last(): Geom2d_BezierCurve
    Returns

    last element

  • ChangeLast(): Geom2d_BezierCurve
    Returns

    last element

  • Value(theIndex: number): Geom2d_BezierCurve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Geom2d_BezierCurve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Geom2d_BezierCurve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Geom2d_BezierCurve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Geom2d_BezierCurve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Geom2d_BSplineCurve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Geom2d_BSplineCurve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Geom2d_BSplineCurve): NCollection_Array1_handle_Geom2d_BSplineCurve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Geom2d_BSplineCurve): NCollection_Array1_handle_Geom2d_BSplineCurve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Geom2d_BSplineCurve): NCollection_Array1_handle_Geom2d_BSplineCurve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Geom2d_BSplineCurve
    Returns

    first element

  • ChangeFirst(): Geom2d_BSplineCurve
    Returns

    first element

  • Last(): Geom2d_BSplineCurve
    Returns

    last element

  • ChangeLast(): Geom2d_BSplineCurve
    Returns

    last element

  • Value(theIndex: number): Geom2d_BSplineCurve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Geom2d_BSplineCurve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Geom2d_BSplineCurve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Geom2d_BSplineCurve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Geom2d_BSplineCurve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Geom2d_Curve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Geom2d_Curve): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Geom2d_Curve): NCollection_Array1_handle_Geom2d_Curve

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Geom2d_Curve): NCollection_Array1_handle_Geom2d_Curve

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Geom2d_Curve): NCollection_Array1_handle_Geom2d_Curve

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Geom2d_Curve
    Returns

    first element

  • ChangeFirst(): Geom2d_Curve
    Returns

    first element

  • Last(): Geom2d_Curve
    Returns

    last element

  • ChangeLast(): Geom2d_Curve
    Returns

    last element

  • Value(theIndex: number): Geom2d_Curve

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Geom2d_Curve

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Geom2d_Curve

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Geom2d_Curve

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Geom2d_Curve): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_GeomFill_LocationLaw

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: GeomFill_LocationLaw): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_GeomFill_LocationLaw): NCollection_Array1_handle_GeomFill_LocationLaw

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_GeomFill_LocationLaw): NCollection_Array1_handle_GeomFill_LocationLaw

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_GeomFill_LocationLaw): NCollection_Array1_handle_GeomFill_LocationLaw

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): GeomFill_LocationLaw
    Returns

    first element

  • ChangeFirst(): GeomFill_LocationLaw
    Returns

    first element

  • Last(): GeomFill_LocationLaw
    Returns

    last element

  • ChangeLast(): GeomFill_LocationLaw
    Returns

    last element

  • Value(theIndex: number): GeomFill_LocationLaw

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): GeomFill_LocationLaw

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): GeomFill_LocationLaw

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): GeomFill_LocationLaw

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: GeomFill_LocationLaw): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_GeomFill_SectionLaw

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: GeomFill_SectionLaw): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_GeomFill_SectionLaw): NCollection_Array1_handle_GeomFill_SectionLaw

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_GeomFill_SectionLaw): NCollection_Array1_handle_GeomFill_SectionLaw

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_GeomFill_SectionLaw): NCollection_Array1_handle_GeomFill_SectionLaw

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): GeomFill_SectionLaw
    Returns

    first element

  • ChangeFirst(): GeomFill_SectionLaw
    Returns

    first element

  • Last(): GeomFill_SectionLaw
    Returns

    last element

  • ChangeLast(): GeomFill_SectionLaw
    Returns

    last element

  • Value(theIndex: number): GeomFill_SectionLaw

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): GeomFill_SectionLaw

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): GeomFill_SectionLaw

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): GeomFill_SectionLaw

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: GeomFill_SectionLaw): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_HLRAlgo_PolyData

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: HLRAlgo_PolyData): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_HLRAlgo_PolyData): NCollection_Array1_handle_HLRAlgo_PolyData

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_HLRAlgo_PolyData): NCollection_Array1_handle_HLRAlgo_PolyData

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_HLRAlgo_PolyData): NCollection_Array1_handle_HLRAlgo_PolyData

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): HLRAlgo_PolyData
    Returns

    first element

  • ChangeFirst(): HLRAlgo_PolyData
    Returns

    first element

  • Last(): HLRAlgo_PolyData
    Returns

    last element

  • ChangeLast(): HLRAlgo_PolyData
    Returns

    last element

  • Value(theIndex: number): HLRAlgo_PolyData

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): HLRAlgo_PolyData

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): HLRAlgo_PolyData

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): HLRAlgo_PolyData

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: HLRAlgo_PolyData): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_HLRAlgo_PolyInternalNode

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_HLRAlgo_PolyShellData

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESAppli_FiniteElement

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESAppli_Flow

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESAppli_Flow): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESAppli_Flow): NCollection_Array1_handle_IGESAppli_Flow

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESAppli_Flow): NCollection_Array1_handle_IGESAppli_Flow

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESAppli_Flow): NCollection_Array1_handle_IGESAppli_Flow

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESAppli_Flow
    Returns

    first element

  • ChangeFirst(): IGESAppli_Flow
    Returns

    first element

  • Last(): IGESAppli_Flow
    Returns

    last element

  • ChangeLast(): IGESAppli_Flow
    Returns

    last element

  • Value(theIndex: number): IGESAppli_Flow

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESAppli_Flow

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESAppli_Flow

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESAppli_Flow

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESAppli_Flow): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESAppli_Node

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESAppli_Node): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESAppli_Node): NCollection_Array1_handle_IGESAppli_Node

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESAppli_Node): NCollection_Array1_handle_IGESAppli_Node

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESAppli_Node): NCollection_Array1_handle_IGESAppli_Node

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESAppli_Node
    Returns

    first element

  • ChangeFirst(): IGESAppli_Node
    Returns

    first element

  • Last(): IGESAppli_Node
    Returns

    last element

  • ChangeLast(): IGESAppli_Node
    Returns

    last element

  • Value(theIndex: number): IGESAppli_Node

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESAppli_Node

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESAppli_Node

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESAppli_Node

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESAppli_Node): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESData_IGESEntity

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESData_IGESEntity): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESData_IGESEntity): NCollection_Array1_handle_IGESData_IGESEntity

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESData_IGESEntity): NCollection_Array1_handle_IGESData_IGESEntity

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESData_IGESEntity): NCollection_Array1_handle_IGESData_IGESEntity

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESData_IGESEntity
    Returns

    first element

  • ChangeFirst(): IGESData_IGESEntity
    Returns

    first element

  • Last(): IGESData_IGESEntity
    Returns

    last element

  • ChangeLast(): IGESData_IGESEntity
    Returns

    last element

  • Value(theIndex: number): IGESData_IGESEntity

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESData_IGESEntity

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESData_IGESEntity

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESData_IGESEntity

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESData_IGESEntity): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESData_LineFontEntity

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESData_ViewKindEntity

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESDefs_TabularData

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESDefs_TabularData): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESDefs_TabularData): NCollection_Array1_handle_IGESDefs_TabularData

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESDefs_TabularData): NCollection_Array1_handle_IGESDefs_TabularData

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESDefs_TabularData): NCollection_Array1_handle_IGESDefs_TabularData

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESDefs_TabularData
    Returns

    first element

  • ChangeFirst(): IGESDefs_TabularData
    Returns

    first element

  • Last(): IGESDefs_TabularData
    Returns

    last element

  • ChangeLast(): IGESDefs_TabularData
    Returns

    last element

  • Value(theIndex: number): IGESDefs_TabularData

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESDefs_TabularData

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESDefs_TabularData

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESDefs_TabularData

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESDefs_TabularData): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESDimen_GeneralNote

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESDimen_LeaderArrow

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESDraw_ConnectPoint

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESDraw_ConnectPoint): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: unknown): unknown

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: unknown): unknown

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: unknown): unknown

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESDraw_ConnectPoint
    Returns

    first element

  • ChangeFirst(): IGESDraw_ConnectPoint
    Returns

    first element

  • Last(): IGESDraw_ConnectPoint
    Returns

    last element

  • ChangeLast(): IGESDraw_ConnectPoint
    Returns

    last element

  • Value(theIndex: number): IGESDraw_ConnectPoint

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESDraw_ConnectPoint

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESDraw_ConnectPoint

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESDraw_ConnectPoint

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESDraw_ConnectPoint): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESGeom_Boundary

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESGeom_Boundary): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESGeom_Boundary): NCollection_Array1_handle_IGESGeom_Boundary

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESGeom_Boundary): NCollection_Array1_handle_IGESGeom_Boundary

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESGeom_Boundary): NCollection_Array1_handle_IGESGeom_Boundary

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESGeom_Boundary
    Returns

    first element

  • ChangeFirst(): IGESGeom_Boundary
    Returns

    first element

  • Last(): IGESGeom_Boundary
    Returns

    last element

  • ChangeLast(): IGESGeom_Boundary
    Returns

    last element

  • Value(theIndex: number): IGESGeom_Boundary

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESGeom_Boundary

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESGeom_Boundary

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESGeom_Boundary

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESGeom_Boundary): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESGeom_CurveOnSurface

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESGeom_TransformationMatrix

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESGraph_Color

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESGraph_Color): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESGraph_Color): NCollection_Array1_handle_IGESGraph_Color

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESGraph_Color): NCollection_Array1_handle_IGESGraph_Color

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESGraph_Color): NCollection_Array1_handle_IGESGraph_Color

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESGraph_Color
    Returns

    first element

  • ChangeFirst(): IGESGraph_Color
    Returns

    first element

  • Last(): IGESGraph_Color
    Returns

    last element

  • ChangeLast(): IGESGraph_Color
    Returns

    last element

  • Value(theIndex: number): IGESGraph_Color

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESGraph_Color

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESGraph_Color

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESGraph_Color

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESGraph_Color): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESGraph_TextDisplayTemplate

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESGraph_TextFontDef

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_IGESSolid_Face

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESSolid_Face): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESSolid_Face): NCollection_Array1_handle_IGESSolid_Face

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESSolid_Face): NCollection_Array1_handle_IGESSolid_Face

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESSolid_Face): NCollection_Array1_handle_IGESSolid_Face

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESSolid_Face
    Returns

    first element

  • ChangeFirst(): IGESSolid_Face
    Returns

    first element

  • Last(): IGESSolid_Face
    Returns

    last element

  • ChangeLast(): IGESSolid_Face
    Returns

    last element

  • Value(theIndex: number): IGESSolid_Face

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESSolid_Face

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESSolid_Face

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESSolid_Face

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESSolid_Face): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESSolid_Loop

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESSolid_Loop): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESSolid_Loop): NCollection_Array1_handle_IGESSolid_Loop

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESSolid_Loop): NCollection_Array1_handle_IGESSolid_Loop

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESSolid_Loop): NCollection_Array1_handle_IGESSolid_Loop

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESSolid_Loop
    Returns

    first element

  • ChangeFirst(): IGESSolid_Loop
    Returns

    first element

  • Last(): IGESSolid_Loop
    Returns

    last element

  • ChangeLast(): IGESSolid_Loop
    Returns

    last element

  • Value(theIndex: number): IGESSolid_Loop

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESSolid_Loop

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESSolid_Loop

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESSolid_Loop

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESSolid_Loop): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESSolid_Shell

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESSolid_Shell): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESSolid_Shell): NCollection_Array1_handle_IGESSolid_Shell

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESSolid_Shell): NCollection_Array1_handle_IGESSolid_Shell

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESSolid_Shell): NCollection_Array1_handle_IGESSolid_Shell

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESSolid_Shell
    Returns

    first element

  • ChangeFirst(): IGESSolid_Shell
    Returns

    first element

  • Last(): IGESSolid_Shell
    Returns

    last element

  • ChangeLast(): IGESSolid_Shell
    Returns

    last element

  • Value(theIndex: number): IGESSolid_Shell

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESSolid_Shell

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESSolid_Shell

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESSolid_Shell

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESSolid_Shell): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_IGESSolid_VertexList

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: IGESSolid_VertexList): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_IGESSolid_VertexList): NCollection_Array1_handle_IGESSolid_VertexList

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_IGESSolid_VertexList): NCollection_Array1_handle_IGESSolid_VertexList

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_IGESSolid_VertexList): NCollection_Array1_handle_IGESSolid_VertexList

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): IGESSolid_VertexList
    Returns

    first element

  • ChangeFirst(): IGESSolid_VertexList
    Returns

    first element

  • Last(): IGESSolid_VertexList
    Returns

    last element

  • ChangeLast(): IGESSolid_VertexList
    Returns

    last element

  • Value(theIndex: number): IGESSolid_VertexList

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): IGESSolid_VertexList

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): IGESSolid_VertexList

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): IGESSolid_VertexList

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESSolid_VertexList): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_NCollection_HSequence_handle_StepElement_CurveElementPurposeMember

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_NCollection_HSequence_handle_StepElement_SurfaceElementPurposeMember

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_Standard_Persistent

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Standard_Persistent): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Standard_Persistent): NCollection_Array1_handle_Standard_Persistent

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Standard_Persistent): NCollection_Array1_handle_Standard_Persistent

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Standard_Persistent): NCollection_Array1_handle_Standard_Persistent

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Standard_Persistent
    Returns

    first element

  • ChangeFirst(): Standard_Persistent
    Returns

    first element

  • Last(): Standard_Persistent
    Returns

    last element

  • ChangeLast(): Standard_Persistent
    Returns

    last element

  • Value(theIndex: number): Standard_Persistent

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Standard_Persistent

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Standard_Persistent

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Standard_Persistent

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Standard_Persistent): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_Standard_Transient

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: Standard_Transient): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_Standard_Transient): NCollection_Array1_handle_Standard_Transient

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_Standard_Transient): NCollection_Array1_handle_Standard_Transient

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_Standard_Transient): NCollection_Array1_handle_Standard_Transient

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): Standard_Transient
    Returns

    first element

  • ChangeFirst(): Standard_Transient
    Returns

    first element

  • Last(): Standard_Transient
    Returns

    last element

  • ChangeLast(): Standard_Transient
    Returns

    last element

  • Value(theIndex: number): Standard_Transient

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): Standard_Transient

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): Standard_Transient

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): Standard_Transient

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Standard_Transient): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_StepBasic_Approval

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: StepBasic_Approval): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_StepBasic_Approval): NCollection_Array1_handle_StepBasic_Approval

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_StepBasic_Approval): NCollection_Array1_handle_StepBasic_Approval

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_StepBasic_Approval): NCollection_Array1_handle_StepBasic_Approval

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): StepBasic_Approval
    Returns

    first element

  • ChangeFirst(): StepBasic_Approval
    Returns

    first element

  • Last(): StepBasic_Approval
    Returns

    last element

  • ChangeLast(): StepBasic_Approval
    Returns

    last element

  • Value(theIndex: number): StepBasic_Approval

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): StepBasic_Approval

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): StepBasic_Approval

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): StepBasic_Approval

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepBasic_Approval): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_StepBasic_DerivedUnitElement

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepBasic_Document

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: StepBasic_Document): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_StepBasic_Document): NCollection_Array1_handle_StepBasic_Document

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_StepBasic_Document): NCollection_Array1_handle_StepBasic_Document

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_StepBasic_Document): NCollection_Array1_handle_StepBasic_Document

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): StepBasic_Document
    Returns

    first element

  • ChangeFirst(): StepBasic_Document
    Returns

    first element

  • Last(): StepBasic_Document
    Returns

    last element

  • ChangeLast(): StepBasic_Document
    Returns

    last element

  • Value(theIndex: number): StepBasic_Document

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): StepBasic_Document

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): StepBasic_Document

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): StepBasic_Document

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepBasic_Document): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_StepBasic_NamedUnit

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: StepBasic_NamedUnit): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_StepBasic_NamedUnit): NCollection_Array1_handle_StepBasic_NamedUnit

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_StepBasic_NamedUnit): NCollection_Array1_handle_StepBasic_NamedUnit

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_StepBasic_NamedUnit): NCollection_Array1_handle_StepBasic_NamedUnit

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): StepBasic_NamedUnit
    Returns

    first element

  • ChangeFirst(): StepBasic_NamedUnit
    Returns

    first element

  • Last(): StepBasic_NamedUnit
    Returns

    last element

  • ChangeLast(): StepBasic_NamedUnit
    Returns

    last element

  • Value(theIndex: number): StepBasic_NamedUnit

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): StepBasic_NamedUnit

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): StepBasic_NamedUnit

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): StepBasic_NamedUnit

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepBasic_NamedUnit): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_StepBasic_Organization

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepBasic_Person

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: StepBasic_Person): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_StepBasic_Person): NCollection_Array1_handle_StepBasic_Person

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_StepBasic_Person): NCollection_Array1_handle_StepBasic_Person

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_StepBasic_Person): NCollection_Array1_handle_StepBasic_Person

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): StepBasic_Person
    Returns

    first element

  • ChangeFirst(): StepBasic_Person
    Returns

    first element

  • Last(): StepBasic_Person
    Returns

    last element

  • ChangeLast(): StepBasic_Person
    Returns

    last element

  • Value(theIndex: number): StepBasic_Person

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): StepBasic_Person

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): StepBasic_Person

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): StepBasic_Person

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepBasic_Person): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_StepBasic_Product

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: StepBasic_Product): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: NCollection_Array1_handle_StepBasic_Product): NCollection_Array1_handle_StepBasic_Product

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: NCollection_Array1_handle_StepBasic_Product): NCollection_Array1_handle_StepBasic_Product

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: NCollection_Array1_handle_StepBasic_Product): NCollection_Array1_handle_StepBasic_Product

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): StepBasic_Product
    Returns

    first element

  • ChangeFirst(): StepBasic_Product
    Returns

    first element

  • Last(): StepBasic_Product
    Returns

    last element

  • ChangeLast(): StepBasic_Product
    Returns

    last element

  • Value(theIndex: number): StepBasic_Product

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): StepBasic_Product

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): StepBasic_Product

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): StepBasic_Product

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepBasic_Product): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollection_Array1_handle_StepBasic_ProductContext

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepBasic_ProductDefinition

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepBasic_UncertaintyMeasureWithUnit

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepDimTol_DatumReference

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepDimTol_DatumReferenceCompartment

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepDimTol_DatumReferenceElement

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepElement_CurveElementEndReleasePacket

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepElement_CurveElementSectionDefinition

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepElement_SurfaceSection

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepElement_VolumeElementPurposeMember

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepFEA_CurveElementEndOffset

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepFEA_CurveElementEndRelease

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepFEA_CurveElementInterval

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepFEA_ElementRepresentation

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepFEA_NodeRepresentation

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepGeom_BoundaryCurve

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

NCollection_Array1_handle_StepGeom_CartesianPoint

The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays.
Examples:

Itemtab[100];//anexamplewithaCarray NCollection_Array1<Item>ttab(tab[0],1,100); NCollection_Array1<Item>tttab(ttab(10),10,20);//asliceofttab

If you want to reindex an array from 1 to Length do:

NCollection_Array1<Item>tab1(tab(tab.Lower()),1,tab.Length());

Warning: Programs client of such a class must be independent of the range of the first element. Then, a C++ for loop must be written like this

for(i=A.Lower();i<=A.Upper();i++)

Zero-based (size_t) construction mode: Use NCollection_Array1(size_t theSize) or NCollection_Array1(pointer, size_t) to create a zero-based array (Lower()==0). In this mode At()/ChangeAt() and STL iterators are the preferred access path - they address elements directly without any offset subtraction. Buffer-reuse variants do NOT own the memory and will not free it on destruction.

intaBuffer[100]; NCollection_Array1<int>aZero(100);//allocates,lower=0 NCollection_Array1<int>aWrap(aBuffer,100);//wrapsaBuffer,lower=0,notowner for(size_ti=0;i<aWrap.Size();++i) aWrap.At(i)=static_cast<int>(i);

Constructors(5)

Instance methods(23)

  • Init(theValue: StepGeom_CartesianPoint): void

    Initialise the items with theValue.

    Parameters (1)
    • theValue
  • Size(): number

    Size query.

  • Length(): number

    Length query (legacy int-returning API).

  • IsEmpty(): boolean

    Return TRUE if array has zero length.

  • Lower(): number

    Lower bound.

  • Upper(): number

    Upper bound.

  • Assign(theOther: unknown): unknown

    Replaces this array by a copy of theOther array. Bounds and length are copied from theOther. When this array wraps an external (non-owned) buffer:

    • if theOther has the same length, values are copied in place into the external buffer and ownership is unchanged;
    • if theOther has a different length, this array detaches from the external buffer and allocates a fresh owned buffer. Use CopyValues() to preserve this array's bounds.
    Parameters (1)
    • theOther
  • CopyValues(theOther: unknown): unknown

    Copies values from theOther array without changing this array bounds. This array should be pre-allocated and have the same length as theOther; otherwise exception Standard_DimensionMismatch is thrown.

    Parameters (1)
    • theOther
  • Move(theOther: unknown): unknown

    Move assignment. This array will borrow all the data from theOther. The moved object will keep pointer to the memory buffer and range, but it will not free the buffer on destruction.

    Parameters (1)
    • theOther —
      Mutated in place; read the updated value from this argument after the call.
  • First(): StepGeom_CartesianPoint
    Returns

    first element

  • ChangeFirst(): StepGeom_CartesianPoint
    Returns

    first element

  • Last(): StepGeom_CartesianPoint
    Returns

    last element

  • ChangeLast(): StepGeom_CartesianPoint
    Returns

    last element

  • Value(theIndex: number): StepGeom_CartesianPoint

    Constant value access.

    Parameters (1)
    • theIndex
  • ChangeValue(theIndex: number): StepGeom_CartesianPoint

    Variable value access.

    Parameters (1)
    • theIndex
  • At(theIndex: number): StepGeom_CartesianPoint

    0-based checked access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • ChangeAt(theIndex: number): StepGeom_CartesianPoint

    0-based checked mutable access independent of Lower()/Upper().

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepGeom_CartesianPoint): void

    Set value.

    Parameters (2)
    • theIndex
    • theItem
  • UpdateLowerBound(theLower: number): void

    Changes the lowest bound. Do not move data.

    Parameters (1)
    • theLower
  • UpdateUpperBound(theUpper: number): void

    Changes the upper bound. Do not move data.

    Parameters (1)
    • theUpper
  • Resize(theLower: number, theUpper: number, theToCopyData: boolean): void

    Resizes the array to specified bounds. No re-allocation will be done if length of array does not change, but existing values will not be discarded if theToCopyData set to FALSE.

    Parameters (3)
    • theLower —
      new lower bound of array
    • theUpper —
      new upper bound of array
    • theToCopyData —
      flag to copy existing data into new array
  • Resize(theSize: number, theToCopyData: boolean): void

    Resizes the array to theSize elements, keeping the lower bound unchanged.

    Parameters (2)
    • theSize —
      new number of elements
    • theToCopyData —
      flag to copy existing data into new array
  • IsDeletable(): boolean

NCollectionAuto

877 classes across 1 packages.

init() function

Default export of @taucad/opencascade.js — signature, options, and singleton pattern.