OpenCascade.js
PackageApiSyntheticN collection autoGenerated

Generated (page 2 of 9)

OCCT package Generated: BRepToolsWrapper, GeomToolsWrapper, NCollection_Array1_AppParCurves_ConstraintCouple,…

NCollection_Array1_handle_StepGeom_CompositeCurveSegment

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_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: StepGeom_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_StepGeom_Curve): NCollection_Array1_handle_StepGeom_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_StepGeom_Curve): NCollection_Array1_handle_StepGeom_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_StepGeom_Curve): NCollection_Array1_handle_StepGeom_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(): StepGeom_Curve
    Returns

    first element

  • ChangeFirst(): StepGeom_Curve
    Returns

    first element

  • Last(): StepGeom_Curve
    Returns

    last element

  • ChangeLast(): StepGeom_Curve
    Returns

    last element

  • Value(theIndex: number): StepGeom_Curve

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepGeom_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_StepRepr_MaterialPropertyRepresentation

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_StepRepr_PropertyDefinitionRepresentation

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_StepRepr_RepresentationItem

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_StepRepr_ShapeAspect

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: StepRepr_ShapeAspect): 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_StepRepr_ShapeAspect): NCollection_Array1_handle_StepRepr_ShapeAspect

    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_StepRepr_ShapeAspect): NCollection_Array1_handle_StepRepr_ShapeAspect

    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_StepRepr_ShapeAspect): NCollection_Array1_handle_StepRepr_ShapeAspect

    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(): StepRepr_ShapeAspect
    Returns

    first element

  • ChangeFirst(): StepRepr_ShapeAspect
    Returns

    first element

  • Last(): StepRepr_ShapeAspect
    Returns

    last element

  • ChangeLast(): StepRepr_ShapeAspect
    Returns

    last element

  • Value(theIndex: number): StepRepr_ShapeAspect

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepRepr_ShapeAspect): 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_StepShape_ConnectedEdgeSet

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_StepShape_ConnectedFaceSet

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_StepShape_Edge

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: StepShape_Edge): 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_StepShape_Edge): NCollection_Array1_handle_StepShape_Edge

    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_StepShape_Edge): NCollection_Array1_handle_StepShape_Edge

    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_StepShape_Edge): NCollection_Array1_handle_StepShape_Edge

    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(): StepShape_Edge
    Returns

    first element

  • ChangeFirst(): StepShape_Edge
    Returns

    first element

  • Last(): StepShape_Edge
    Returns

    last element

  • ChangeLast(): StepShape_Edge
    Returns

    last element

  • Value(theIndex: number): StepShape_Edge

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepShape_Edge): 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_StepShape_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: StepShape_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_StepShape_Face): NCollection_Array1_handle_StepShape_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_StepShape_Face): NCollection_Array1_handle_StepShape_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_StepShape_Face): NCollection_Array1_handle_StepShape_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(): StepShape_Face
    Returns

    first element

  • ChangeFirst(): StepShape_Face
    Returns

    first element

  • Last(): StepShape_Face
    Returns

    last element

  • ChangeLast(): StepShape_Face
    Returns

    last element

  • Value(theIndex: number): StepShape_Face

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepShape_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_StepShape_FaceBound

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: StepShape_FaceBound): 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_StepShape_FaceBound): NCollection_Array1_handle_StepShape_FaceBound

    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_StepShape_FaceBound): NCollection_Array1_handle_StepShape_FaceBound

    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_StepShape_FaceBound): NCollection_Array1_handle_StepShape_FaceBound

    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(): StepShape_FaceBound
    Returns

    first element

  • ChangeFirst(): StepShape_FaceBound
    Returns

    first element

  • Last(): StepShape_FaceBound
    Returns

    last element

  • ChangeLast(): StepShape_FaceBound
    Returns

    last element

  • Value(theIndex: number): StepShape_FaceBound

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepShape_FaceBound): 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_StepShape_OrientedClosedShell

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_StepShape_OrientedEdge

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_StepVisual_CurveStyleFontPattern

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_StepVisual_PresentationStyleAssignment

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_StepVisual_TessellatedItem

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_StepVisual_TessellatedStructuredItem

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_Storage_CallBack

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: Storage_CallBack): 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_Storage_CallBack): NCollection_Array1_handle_Storage_CallBack

    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_Storage_CallBack): NCollection_Array1_handle_Storage_CallBack

    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_Storage_CallBack): NCollection_Array1_handle_Storage_CallBack

    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(): Storage_CallBack
    Returns

    first element

  • ChangeFirst(): Storage_CallBack
    Returns

    first element

  • Last(): Storage_CallBack
    Returns

    last element

  • ChangeLast(): Storage_CallBack
    Returns

    last element

  • Value(theIndex: number): Storage_CallBack

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Storage_CallBack): 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_Storage_Schema

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: Storage_Schema): 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_Storage_Schema): NCollection_Array1_handle_Storage_Schema

    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_Storage_Schema): NCollection_Array1_handle_Storage_Schema

    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_Storage_Schema): NCollection_Array1_handle_Storage_Schema

    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(): Storage_Schema
    Returns

    first element

  • ChangeFirst(): Storage_Schema
    Returns

    first element

  • Last(): Storage_Schema
    Returns

    last element

  • ChangeLast(): Storage_Schema
    Returns

    last element

  • Value(theIndex: number): Storage_Schema

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Storage_Schema): 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_TCollection_HAsciiString

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_TDF_Attribute

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: TDF_Attribute): 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_TDF_Attribute): NCollection_Array1_handle_TDF_Attribute

    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_TDF_Attribute): NCollection_Array1_handle_TDF_Attribute

    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_TDF_Attribute): NCollection_Array1_handle_TDF_Attribute

    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(): TDF_Attribute
    Returns

    first element

  • ChangeFirst(): TDF_Attribute
    Returns

    first element

  • Last(): TDF_Attribute
    Returns

    last element

  • ChangeLast(): TDF_Attribute
    Returns

    last element

  • Value(theIndex: number): TDF_Attribute

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: TDF_Attribute): 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_HLRAlgo_PolyHidingData

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_PolyHidingData): 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_HLRAlgo_PolyHidingData): NCollection_Array1_HLRAlgo_PolyHidingData

    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_HLRAlgo_PolyHidingData): NCollection_Array1_HLRAlgo_PolyHidingData

    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_HLRAlgo_PolyHidingData): NCollection_Array1_HLRAlgo_PolyHidingData

    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_PolyHidingData
    Returns

    first element

  • ChangeFirst(): HLRAlgo_PolyHidingData
    Returns

    first element

  • Last(): HLRAlgo_PolyHidingData
    Returns

    last element

  • ChangeLast(): HLRAlgo_PolyHidingData
    Returns

    last element

  • Value(theIndex: number): HLRAlgo_PolyHidingData

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: HLRAlgo_PolyHidingData): 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_HLRAlgo_PolyInternalSegment

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_HLRAlgo_TriangleData

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_TriangleData): 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_HLRAlgo_TriangleData): NCollection_Array1_HLRAlgo_TriangleData

    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_HLRAlgo_TriangleData): NCollection_Array1_HLRAlgo_TriangleData

    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_HLRAlgo_TriangleData): NCollection_Array1_HLRAlgo_TriangleData

    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_TriangleData
    Returns

    first element

  • ChangeFirst(): HLRAlgo_TriangleData
    Returns

    first element

  • Last(): HLRAlgo_TriangleData
    Returns

    last element

  • ChangeLast(): HLRAlgo_TriangleData
    Returns

    last element

  • Value(theIndex: number): HLRAlgo_TriangleData

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: HLRAlgo_TriangleData): 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_HLRBRep_EdgeData

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: HLRBRep_EdgeData): 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_HLRBRep_EdgeData): NCollection_Array1_HLRBRep_EdgeData

    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_HLRBRep_EdgeData): NCollection_Array1_HLRBRep_EdgeData

    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_HLRBRep_EdgeData): NCollection_Array1_HLRBRep_EdgeData

    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(): HLRBRep_EdgeData
    Returns

    first element

  • ChangeFirst(): HLRBRep_EdgeData
    Returns

    first element

  • Last(): HLRBRep_EdgeData
    Returns

    last element

  • ChangeLast(): HLRBRep_EdgeData
    Returns

    last element

  • Value(theIndex: number): HLRBRep_EdgeData

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: HLRBRep_EdgeData): 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_HLRBRep_FaceData

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: HLRBRep_FaceData): 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_HLRBRep_FaceData): NCollection_Array1_HLRBRep_FaceData

    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_HLRBRep_FaceData): NCollection_Array1_HLRBRep_FaceData

    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_HLRBRep_FaceData): NCollection_Array1_HLRBRep_FaceData

    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(): HLRBRep_FaceData
    Returns

    first element

  • ChangeFirst(): HLRBRep_FaceData
    Returns

    first element

  • Last(): HLRBRep_FaceData
    Returns

    last element

  • ChangeLast(): HLRBRep_FaceData
    Returns

    last element

  • Value(theIndex: number): HLRBRep_FaceData

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: HLRBRep_FaceData): 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_IGESData_DirPart

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_DirPart): 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_IGESData_DirPart): NCollection_Array1_IGESData_DirPart

    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_IGESData_DirPart): NCollection_Array1_IGESData_DirPart

    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_IGESData_DirPart): NCollection_Array1_IGESData_DirPart

    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_DirPart
    Returns

    first element

  • ChangeFirst(): IGESData_DirPart
    Returns

    first element

  • Last(): IGESData_DirPart
    Returns

    last element

  • ChangeLast(): IGESData_DirPart
    Returns

    last element

  • Value(theIndex: number): IGESData_DirPart

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IGESData_DirPart): 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_int

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_int): NCollection_Array1_int

    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_int): NCollection_Array1_int

    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_int): NCollection_Array1_int

    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_Interface_FileParameter

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_IntTools_Range

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: IntTools_Range): 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_IntTools_Range): NCollection_Array1_IntTools_Range

    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_IntTools_Range): NCollection_Array1_IntTools_Range

    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_IntTools_Range): NCollection_Array1_IntTools_Range

    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(): IntTools_Range
    Returns

    first element

  • ChangeFirst(): IntTools_Range
    Returns

    first element

  • Last(): IntTools_Range
    Returns

    last element

  • ChangeLast(): IntTools_Range
    Returns

    last element

  • Value(theIndex: number): IntTools_Range

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IntTools_Range): 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_IntTools_Root

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: IntTools_Root): 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_IntTools_Root): NCollection_Array1_IntTools_Root

    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_IntTools_Root): NCollection_Array1_IntTools_Root

    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_IntTools_Root): NCollection_Array1_IntTools_Root

    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(): IntTools_Root
    Returns

    first element

  • ChangeFirst(): IntTools_Root
    Returns

    first element

  • Last(): IntTools_Root
    Returns

    last element

  • ChangeLast(): IntTools_Root
    Returns

    last element

  • Value(theIndex: number): IntTools_Root

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: IntTools_Root): 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_math_ValueAndWeight

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: math_ValueAndWeight): 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_math_ValueAndWeight): NCollection_Array1_math_ValueAndWeight

    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_math_ValueAndWeight): NCollection_Array1_math_ValueAndWeight

    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_math_ValueAndWeight): NCollection_Array1_math_ValueAndWeight

    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(): math_ValueAndWeight
    Returns

    first element

  • ChangeFirst(): math_ValueAndWeight
    Returns

    first element

  • Last(): math_ValueAndWeight
    Returns

    last element

  • ChangeLast(): math_ValueAndWeight
    Returns

    last element

  • Value(theIndex: number): math_ValueAndWeight

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: math_ValueAndWeight): 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_NCollection_Handle_Message_Msg

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: unknown): 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_NCollection_Handle_Message_Msg): NCollection_Array1_NCollection_Handle_Message_Msg

    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_NCollection_Handle_Message_Msg): NCollection_Array1_NCollection_Handle_Message_Msg

    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_NCollection_Handle_Message_Msg): NCollection_Array1_NCollection_Handle_Message_Msg

    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(): unknown
    Returns

    first element

  • ChangeFirst(): unknown
    Returns

    first element

  • Last(): unknown
    Returns

    last element

  • ChangeLast(): unknown
    Returns

    last element

  • Value(theIndex: number): unknown

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: unknown): 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_NCollection_List_int

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: NCollection_List_int): 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_NCollection_List_int): NCollection_Array1_NCollection_List_int

    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_NCollection_List_int): NCollection_Array1_NCollection_List_int

    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_NCollection_List_int): NCollection_Array1_NCollection_List_int

    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(): NCollection_List_int
    Returns

    first element

  • ChangeFirst(): NCollection_List_int
    Returns

    first element

  • Last(): NCollection_List_int
    Returns

    last element

  • ChangeLast(): NCollection_List_int
    Returns

    last element

  • Value(theIndex: number): NCollection_List_int

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: NCollection_List_int): 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_NCollection_List_TopoDS_Shape

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_NCollection_Sequence_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)

NCollection_Array1_NCollection_Sequence_int

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_NCollection_Vec3_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: unknown): 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_NCollection_Vec3_float): NCollection_Array1_NCollection_Vec3_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_NCollection_Vec3_float): NCollection_Array1_NCollection_Vec3_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_NCollection_Vec3_float): NCollection_Array1_NCollection_Vec3_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(): unknown
    Returns

    first element

  • ChangeFirst(): unknown
    Returns

    first element

  • Last(): unknown
    Returns

    last element

  • ChangeLast(): unknown
    Returns

    last element

  • Value(theIndex: number): unknown

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: unknown): 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_Plate_PinpointConstraint

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_Poly_Triangle

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: Poly_Triangle): 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_Poly_Triangle): NCollection_Array1_Poly_Triangle

    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_Poly_Triangle): NCollection_Array1_Poly_Triangle

    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_Poly_Triangle): NCollection_Array1_Poly_Triangle

    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(): Poly_Triangle
    Returns

    first element

  • ChangeFirst(): Poly_Triangle
    Returns

    first element

  • Last(): Poly_Triangle
    Returns

    last element

  • ChangeLast(): Poly_Triangle
    Returns

    last element

  • Value(theIndex: number): Poly_Triangle

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Poly_Triangle): 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_Quantity_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: Quantity_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_Quantity_Color): NCollection_Array1_Quantity_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_Quantity_Color): NCollection_Array1_Quantity_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_Quantity_Color): NCollection_Array1_Quantity_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(): Quantity_Color
    Returns

    first element

  • ChangeFirst(): Quantity_Color
    Returns

    first element

  • Last(): Quantity_Color
    Returns

    last element

  • ChangeLast(): Quantity_Color
    Returns

    last element

  • Value(theIndex: number): Quantity_Color

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: Quantity_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_std_pair_unsignedint_int

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: unknown): 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_std_pair_unsignedint_int): NCollection_Array1_std_pair_unsignedint_int

    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_std_pair_unsignedint_int): NCollection_Array1_std_pair_unsignedint_int

    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_std_pair_unsignedint_int): NCollection_Array1_std_pair_unsignedint_int

    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(): unknown
    Returns

    first element

  • ChangeFirst(): unknown
    Returns

    first element

  • Last(): unknown
    Returns

    last element

  • ChangeLast(): unknown
    Returns

    last element

  • Value(theIndex: number): unknown

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: unknown): 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_StepAP203_ApprovedItem

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: StepAP203_ApprovedItem): 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_StepAP203_ApprovedItem): NCollection_Array1_StepAP203_ApprovedItem

    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_StepAP203_ApprovedItem): NCollection_Array1_StepAP203_ApprovedItem

    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_StepAP203_ApprovedItem): NCollection_Array1_StepAP203_ApprovedItem

    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(): StepAP203_ApprovedItem
    Returns

    first element

  • ChangeFirst(): StepAP203_ApprovedItem
    Returns

    first element

  • Last(): StepAP203_ApprovedItem
    Returns

    last element

  • ChangeLast(): StepAP203_ApprovedItem
    Returns

    last element

  • Value(theIndex: number): StepAP203_ApprovedItem

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepAP203_ApprovedItem): 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_StepAP203_CertifiedItem

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_StepAP203_ChangeRequestItem

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_StepAP203_ClassifiedItem

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_StepAP203_ContractedItem

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_StepAP203_DateTimeItem

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: StepAP203_DateTimeItem): 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_StepAP203_DateTimeItem): NCollection_Array1_StepAP203_DateTimeItem

    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_StepAP203_DateTimeItem): NCollection_Array1_StepAP203_DateTimeItem

    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_StepAP203_DateTimeItem): NCollection_Array1_StepAP203_DateTimeItem

    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(): StepAP203_DateTimeItem
    Returns

    first element

  • ChangeFirst(): StepAP203_DateTimeItem
    Returns

    first element

  • Last(): StepAP203_DateTimeItem
    Returns

    last element

  • ChangeLast(): StepAP203_DateTimeItem
    Returns

    last element

  • Value(theIndex: number): StepAP203_DateTimeItem

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepAP203_DateTimeItem): 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_StepAP203_PersonOrganizationItem

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_StepAP203_SpecifiedItem

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_StepAP203_StartRequestItem

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_StepAP203_WorkItem

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: StepAP203_WorkItem): 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_StepAP203_WorkItem): NCollection_Array1_StepAP203_WorkItem

    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_StepAP203_WorkItem): NCollection_Array1_StepAP203_WorkItem

    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_StepAP203_WorkItem): NCollection_Array1_StepAP203_WorkItem

    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(): StepAP203_WorkItem
    Returns

    first element

  • ChangeFirst(): StepAP203_WorkItem
    Returns

    first element

  • Last(): StepAP203_WorkItem
    Returns

    last element

  • ChangeLast(): StepAP203_WorkItem
    Returns

    last element

  • Value(theIndex: number): StepAP203_WorkItem

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepAP203_WorkItem): 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_StepAP214_ApprovalItem

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: StepAP214_ApprovalItem): 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_StepAP214_ApprovalItem): NCollection_Array1_StepAP214_ApprovalItem

    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_StepAP214_ApprovalItem): NCollection_Array1_StepAP214_ApprovalItem

    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_StepAP214_ApprovalItem): NCollection_Array1_StepAP214_ApprovalItem

    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(): StepAP214_ApprovalItem
    Returns

    first element

  • ChangeFirst(): StepAP214_ApprovalItem
    Returns

    first element

  • Last(): StepAP214_ApprovalItem
    Returns

    last element

  • ChangeLast(): StepAP214_ApprovalItem
    Returns

    last element

  • Value(theIndex: number): StepAP214_ApprovalItem

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepAP214_ApprovalItem): 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_StepAP214_AutoDesignDateAndPersonItem

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_StepAP214_AutoDesignDateAndTimeItem

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_StepAP214_AutoDesignDatedItem

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_StepAP214_AutoDesignGeneralOrgItem

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_StepAP214_AutoDesignGroupedItem

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_StepAP214_AutoDesignPresentedItemSelect

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_StepAP214_AutoDesignReferencingItem

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_StepAP214_DateAndTimeItem

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_StepAP214_DateItem

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: StepAP214_DateItem): 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_StepAP214_DateItem): NCollection_Array1_StepAP214_DateItem

    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_StepAP214_DateItem): NCollection_Array1_StepAP214_DateItem

    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_StepAP214_DateItem): NCollection_Array1_StepAP214_DateItem

    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(): StepAP214_DateItem
    Returns

    first element

  • ChangeFirst(): StepAP214_DateItem
    Returns

    first element

  • Last(): StepAP214_DateItem
    Returns

    last element

  • ChangeLast(): StepAP214_DateItem
    Returns

    last element

  • Value(theIndex: number): StepAP214_DateItem

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepAP214_DateItem): 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_StepAP214_DocumentReferenceItem

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_StepAP214_ExternalIdentificationItem

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_StepAP214_GroupItem

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: StepAP214_GroupItem): 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_StepAP214_GroupItem): NCollection_Array1_StepAP214_GroupItem

    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_StepAP214_GroupItem): NCollection_Array1_StepAP214_GroupItem

    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_StepAP214_GroupItem): NCollection_Array1_StepAP214_GroupItem

    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(): StepAP214_GroupItem
    Returns

    first element

  • ChangeFirst(): StepAP214_GroupItem
    Returns

    first element

  • Last(): StepAP214_GroupItem
    Returns

    last element

  • ChangeLast(): StepAP214_GroupItem
    Returns

    last element

  • Value(theIndex: number): StepAP214_GroupItem

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepAP214_GroupItem): 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_StepAP214_OrganizationItem

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_StepAP214_PersonAndOrganizationItem

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_StepAP214_PresentedItemSelect

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_StepAP214_SecurityClassificationItem

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_StepData_Field

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: StepData_Field): 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_StepData_Field): NCollection_Array1_StepData_Field

    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_StepData_Field): NCollection_Array1_StepData_Field

    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_StepData_Field): NCollection_Array1_StepData_Field

    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(): StepData_Field
    Returns

    first element

  • ChangeFirst(): StepData_Field
    Returns

    first element

  • Last(): StepData_Field
    Returns

    last element

  • ChangeLast(): StepData_Field
    Returns

    last element

  • Value(theIndex: number): StepData_Field

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepData_Field): 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_StepDimTol_DatumReferenceModifier

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_StepDimTol_DatumSystemOrReference

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_StepDimTol_GeometricToleranceModifier

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_StepDimTol_ToleranceZoneTarget

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: StepDimTol_ToleranceZoneTarget): 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(): StepDimTol_ToleranceZoneTarget
    Returns

    first element

  • ChangeFirst(): StepDimTol_ToleranceZoneTarget
    Returns

    first element

  • Last(): StepDimTol_ToleranceZoneTarget
    Returns

    last element

  • ChangeLast(): StepDimTol_ToleranceZoneTarget
    Returns

    last element

  • Value(theIndex: number): StepDimTol_ToleranceZoneTarget

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepDimTol_ToleranceZoneTarget): 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_StepElement_MeasureOrUnspecifiedValue

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_StepElement_VolumeElementPurpose

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_StepFEA_DegreeOfFreedom

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_StepGeom_PcurveOrSurface

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_StepGeom_SurfaceBoundary

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_StepGeom_TrimmingSelect

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_StepShape_GeometricSetSelect

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_StepShape_ShapeDimensionRepresentationItem

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_StepShape_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: StepShape_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_StepShape_Shell): NCollection_Array1_StepShape_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_StepShape_Shell): NCollection_Array1_StepShape_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_StepShape_Shell): NCollection_Array1_StepShape_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(): StepShape_Shell
    Returns

    first element

  • ChangeFirst(): StepShape_Shell
    Returns

    first element

  • Last(): StepShape_Shell
    Returns

    last element

  • ChangeLast(): StepShape_Shell
    Returns

    last element

  • Value(theIndex: number): StepShape_Shell

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepShape_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_StepShape_ValueQualifier

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_StepVisual_AnnotationPlaneElement

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_StepVisual_BoxCharacteristicSelect

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_StepVisual_CameraModelD3MultiClippingInterectionSelect

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_StepVisual_CameraModelD3MultiClippingUnionSelect

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_StepVisual_DirectionCountSelect

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_StepVisual_DraughtingCalloutElement

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_StepVisual_FillStyleSelect

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_StepVisual_InvisibleItem

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_StepVisual_LayeredItem

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: StepVisual_LayeredItem): 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_StepVisual_LayeredItem): NCollection_Array1_StepVisual_LayeredItem

    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_StepVisual_LayeredItem): NCollection_Array1_StepVisual_LayeredItem

    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_StepVisual_LayeredItem): NCollection_Array1_StepVisual_LayeredItem

    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(): StepVisual_LayeredItem
    Returns

    first element

  • ChangeFirst(): StepVisual_LayeredItem
    Returns

    first element

  • Last(): StepVisual_LayeredItem
    Returns

    last element

  • ChangeLast(): StepVisual_LayeredItem
    Returns

    last element

  • Value(theIndex: number): StepVisual_LayeredItem

    Constant value access.

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

    Variable value access.

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

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

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

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

    Parameters (1)
    • theIndex —
      0-based index in [0, Size()-1]
  • SetValue(theIndex: number, theItem: StepVisual_LayeredItem): 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_StepVisual_PresentationStyleSelect

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_StepVisual_RenderingPropertiesSelect

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_StepVisual_StyleContextSelect

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_StepVisual_SurfaceStyleElementSelect

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_StepVisual_TessellatedEdgeOrVertex

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_StepVisual_TextOrCharacter

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_TCollection_AsciiString

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)