Lists

Operator enabling you to add two lists and to return a third one. Adding two lists means concatenating the elements of the two lists and affecting the result to the returned list. The elements of the first list will be at the beginning of the resulting list. The order of the elements is kept. This operator works on list of objects (persistent or not) or on list of values (persistent or not). If the operation required is not feasible (for example, trying to fill a persistent list with a non persistent value), evaluation errors are raised. There is no simplification of the list (an element can be there twice after the operation).

+(List1: List, List2: List) : List

List

Let L1(List) 
						Let L2(List) 
						Let L3(List) 
						L3=L2+L1

Function used to copy the content of a list and paste it in another list.

Copy(List: List) : List

List

Function used to create a list.

List([Next: ObjectType, ..]) : List

List

let L1(List) 
						L1= List(Item1,Item2,Item3)

Method used to return a list of strings corresponding to the name of the available attributes for a given object. The generated list depends not only on the Object Type but also on the object itself. That is to say, this method may return attributes that have been added dynamically to the object, through the Parameter Explorer command or through the SetAttribute method.

When adding integer or string attributes to faces, this method returns the attributes names and the face default values: the Color, Name, UserInfoComment and the integers Layer, Transparency.

Feature.ListAttributeNames(TypeFilter: String, DynamicOnly:
 Boolean) : List

List

let x(List)
let s=""
let sfinal = ""
x = Product -> ListAttributeNames ("String",false)
for s in x
{
sfinal = sfinal + Product -> GetAttributeString (s)
}

let attributes (List)
let pad(GeometricFeature)
let faces (List)
let face (CATFace)

set pad=PartBody\Pad.1
faces = pad->GetSubElements(2) 
set face = faces[1]

/* Create 2 attributes on a pad face */
face->SetAttributeInteger("IntegerAttr",5) /* Creates an integer attribute of value 5 */
face->SetAttributeString("StringAttr","Value1") /* Creates an integer attribute of value Value1 */

/* Modify attribute values */
face->SetAttributeInteger("IntegerAttr",9) 
face->SetAttributeString("StringAttr","NewValue")

/* Read and display attribute values */
Message("IntegerAttr " , face->GetAttributeInteger("IntegerAttr")) 
Message("AttrString " , face->GetAttributeString("StringAttr"))

/* List the attributes */	
attributes=face->ListAttributeNames("String",false) 
attributes=face->ListAttributeNames("Integer",false)

Method used to add an item to the list. If the index is equal to 0, the new item is added at the end of the list. If the index is equal to 1, the new item is inserted into the list at the location indicated by the index, meaning that the item is replaced with the new one and is therefore removed from the list. It is recommended to use the InsertItem method.

List.AddItem(Object: ObjectType, Index: Integer)

let list (List) 
						list -> AddItem(PartBody\Hole.2 ,1) 
						list -> AddItem(PartBodyHole.3 ,2) 
						Message("#",list.Size())

Method used to add an item at the end of the list.

List.Append(Object: ObjectType)

Method used to apply a given expression to the objects of a list that are of a given type.In this expression, the element of the list is represented by a variable named x.

List.Apply(Type: String, Expression: String)

//Finds all rule bases and executes them 
//P being Part Feature 
/* Finding a value */  
						
let L (List)
L = P  ->  Query("Rulebase","")
L   ->   Apply ("RuleBase","x -> Update()")

Function used to compute the result of an operation performed all the elements of the list. It is available for Actions, Reactions and in Quality Rules Reuse. There are two usages for this method:

• On lists of values, it simply computes an operation on the values (+, min, max)
• On list of objects, it will compute an operation on results of expressions on the object.

List.Compute(Operation: String, Type: String, 
Expression: String, Result: UndefinedType)

List.1 ->Compute("+","","",Length.1)

List.1 -> Compute("+","Hole","x.Diameter+x.Depth",Length.1)

Method used to extract the items of a given type.

List.Extract(Type: String, TypeOutput: String,
 Expression: String) : List

List

Let L1(List) 
						Let L2(List) 
						... 
						L2=L1 -> Extract("Hole","LENGTH","y=x.Diameter+x.Depth")

Method used to filter a list of objects by extracting the objects that fulfill a Boolean expression.

List.Filter(Type: String, Condition: String) : List

List

I = (List -> Filter("Hole","x.Diameter > 3mm")).Size() 
						I = (List -> Filter("Hole","")).Size()

Method used to retrieve a value/item from the list. (Index from 1).

List.GetItem(Index: Integer) : UndefinedType

UndefinedType

Method used to return the first index of a list item. The item is searched for from the start index.

List.IndexOf(Element: ObjectType, StartIndex: Integer) : Integer

Integer

Method used to insert an item into the list.

List.InsertItem(Object: ObjectType, Index: Integer)

Method used to get the intersection of two lists of objects. Optional criteria can be used to get only objects that are in both lists and that respect the condition.

List1.Intersect(List2 : List [, Type : String, Expression : String]) : List

List

Example

Let L1, L2, L3 (List)
L3 = L1.Intersect(L2, “HOle”, “x.Diameter == 15mm”)

Note: L3 = L1.Intersect(L2) generates a result list containing {X1, X3, X6, X13, X15}. If the result is not refined using a criterion, the result is a simple intersection (with common elements) of the two lists.

Method used to find elements of a list that verifies a criterion between elements of this list and elements of another list.

List1.Junction(List2 : List, TypeList1 : String, TypeList2 : String, Expression : String) : List

List

Let L1, L2n L3 (List)
L3 = L1.Junction(L2, “Hole”, “Hole”, “x.Diameter == y.Depth AND y.Diameter > 10mm”)

Method used to empty the list.

List.RemoveAll()

Method used to modify the content of the list by extracting the duplicated elements. When the list references objects (features and parameters), it removes the duplicated reference to the objects. When the list references volatile values, it removes the equivalent values.

List.RemoveDuplicates()

Method used to remove an item from the list.Index is the location of the object to be removed in the list. The index starts at 1.

List.RemoveItem(Index: Integer)

Method used to move an element of the list referenced by its position to a new position. The position starts at 1.

List.ReorderItem(Current: Integer, Target: Integer) : UndefinedType

UndefinedType

Method used to replace an item in the list.

List.SetItem(Object: ObjectType, Index: Integer)

Method used to return the number of items contained in the list.

List.Size() : Integer

Integer

Method used to sort lists. It operates the sort based on a criteria that corresponds to an extraction (see previous method).

List.Sort(Operator: String, Type: String, TypeOutput: String, Expression: String) : List

List

NewList = HoleList  ->  Sort(">","LENGTH","LENGTH","y=x.Diameter")			

Method used to split a list in more than one list depending on criteria.

List.Split(Type : String, ReturnType : String, Expression : String) : List

List

Let L1, L3 (List) //we declare L3 as a list, but it is good to remember that L3 will be a list of lists.
L3 = L1.Split(“Hole”, “Length”, “y = x.Diameter”)

L1 = {Hole1, Hole2, Hole3, Hole4, Hole5, Hole6} 	
L3 = {ListA, ListB, ListC, ListD, ListE}

ListA = {10, 12, 8, 6}     
ListB = {Hole1, Hole5}	
ListC = {Hole2, Hole4}	    
ListD = {Hole3}	
ListE = {Hole6}

Method used to remove objects from a list depending on another list.

List1.Subtract(List2 : List [, Type : String, Expression : String]) : List

List

Example

Let L1, L2, L3 (List)
L3 = L1.Subtract(L2, “Hole”, “x.Diameter == 15mm”)

Note: The result of L3=L1.Subtract(L2) is the same as the "-" operator.