Interface FilterItemInterface

The FilterItemInterface interface is the base interface used to filter part instances.

NO FilterItemInterface are created per se. Instead, interfaces that inherit FilterItemInterface are created. The FilterItemInterface is a kind of "abstract interface".

The FilterItemInterface serves to elect a list of part instances based on a criterion (or a list of criteria), for example (others can be found in Filters examples):

Find all part instances whose size is lower than 3 cms
Find all part instances that overlaps a given 3D cube
Find all part instances that have a metadata "type" equal to "electrical" (electrical part instances)
Find all part instances that have a metadata "mounted" to true (mounted part instances).

Each example is made possible by the creation of a specific interface that inherits FilterItemInterface.

A FilterItemInterface is not usable as is, it must be included in a "working set" object : the WorkingSetInterface. The WorkingSetInterface interface allows the computation of the FilterItemInterfaces, and allows grouping them with set operators (intersection, union, exclusion). See WorkingSetInterface for more details, but keep in mind that WorkingSetInterfaces may rely on others WorkingSetInterface to work (see Working Sets).

When a FilterItemInterface is modified, there is no automatic update of the content of a WorkingSetInterface : indeed, you may want to modify a lot of FilterItemInterface, WorkingSetInterfaces before getting the expected result. Moreover, WorkingSetInterfaces may depend on others WorkingSetInterfaces that could lead to massive dependency graphs. For this reason, WorkingSetInterfaces, and FilterItemInterfaces are not updated through a dedicated function on each interface but with the global DataSessionInterface.update function.
The dependency graph of WorkingSetInterfaces and FilterItemInterfaces is handled by the DataSessionInterface, this also prevent too many requests to be sent to the server for nothing.
To sum up : modify your FilterItemInterfaces, WorkingSetInterfaces without taking into account any dependency that may have between them, and when you want the server to compute the result, remember to call DataSessionInterface.update.

DO NOT create interfaces that inherits FilterItemInterface before the DMU is loaded, such filters will be silently discarded.

Discard existing interfaces that inherits FilterItemInterface before loading a new DataSessionInterface (FilterItemInterface.dispose).

The same FilterItemInterface cannot be used at the same time in multiple WorkingSetInterface, FilterSetInterface, FilterCompoundInterface : calling WorkingSetInterface.insertFilter, FilterSetInterface.insertFilter or FilterCompoundInterface.insertFilter on a FilterItemInterface that is already included will return false.
Warning : only FilterAttributeInterface, FilterRangeInterface, FilterHasFieldInterface and FilterBooleanInterface can be included in a FilterCompoundInterface.

Each FilterItemInterface is assigned a unique identifier upon creation, but may be overridden by the application : in that case, it is the application maintainer responsibility to ensure the uniqueness of such ids.

The combination of the FilterItemInterfaces in a WorkingSetInterface, FilterSetInterface, FilterCompoundInterface may be a union, intersection, or exclusion (GroupOperator). Each FilterItemInterface stores a combination mode that tells its way to combine itself with the first enabled FORMER FilterItemInterface in the parent list.
The FilterItemInterface operator of the first enabled FilterItemInterface in a parent list (WorkingSetInterface, FilterSetInterface, FilterCompoundInterface) is always ignored, but a warning is outputted in the console when the GroupOperator is different that GroupOperator.GO_UNION.
The FilterSetInterface allows to gather filters together and to create an operator precedence with GroupOperator. It is a sort of "parenthesis" FilterItemInterface.

A FilterItemInterface may be :

enabled/disabled : tells if this FilterItemInterface contributes to the filtering of the enclosing WorkingSetInterface, FilterSetInterface, FilterCompoundInterface. Warning, changing the enabled status of a FilterItemInterface without knowing its successor may result in unexpected results, since the successor GroupOperator will be used with the first enabled FilterItemInterface that precedes the disabled one.
normal/inverted : tells if the result of the FilterItemInterface may be "inverted". When "inverted", a FilterItemInterface "elects" all other part instances leaves minus the one in the "normal" FilterItemInterface (in a FilterCompoundInterface, the meaning of the "inverted" state is different).

The content of a FilterItemInterface is provided by toJSON and can be restored by fromJSON.

Each filter has a depth contribution. For implementation reasons, the depth contribution of each FilterItemInterface included inside a WorkingSetInterface is limited. The depth contribution is available through getDepthContribution.

This depth contribution cannot be more than 6.

Please see Available Filters for a list of available FilterItemInterfaces.

/** 
 * Sample to illustrate the use of an intersection of 
 * FilterAABBInterface and FilterAttributeInterface.
 */
import {
    AABB, AttributesDictionaryInterface, AttributeInfoInterface, AttributeType, DataSessionInterface,
    WorkingSetInterface,
    FilterAABBInterface, FilterAttributeInterface, GroupOperator, WorkingSetDataRetrieval, WorkingSetBehavior,
} from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;

// MAKE SURE the attributes "CompletionStatus"
const lAttributeDictionary : AttributesDictionaryInterface = lDataSession.getAttributesDictionary();
const lAttributeInfo : AttributeInfoInterface | undefined = lAttributeDictionary.getAttributeInfo('CompletionStatus');
// make sure the attribute is a string one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_STRING));

// create the resolution chain : 
// create a Working set "unconfigured"
// first create WorkingSetInterface "unconfigured"
// we want to get geometric instances result
// if nothing is set, this working set should include all parts ('unconfigured')
const lConfCtx : WorkingSetInterface = lDataSession.createWorkingSet(
    WorkingSetDataRetrieval.R_OnlyGeometricInstances,
    WorkingSetBehavior.B_DiscardConfigurationsIfEmptyBit | WorkingSetBehavior.B_DiscardFiltersIfEmptyBit | WorkingSetBehavior.B_DiscardDependenciesIfEmptyBit
);

// and create the Working set and bind it to the unconfigured WorkingSetInterface
const lConfVisibilityCtx: WorkingSetInterface = lDataSession.createWorkingSet(
    WorkingSetDataRetrieval.R_Nothing,
    WorkingSetBehavior.B_DiscardConfigurationsIfEmptyBit | WorkingSetBehavior.B_DiscardFiltersIfEmptyBit
);
lConfVisibilityCtx.insertWorkingSetDependency(0, lConfCtx, GroupOperator.GO_INTERSECTION);

// the AABB to use
const lABB : AABB = new AABB();
lABB.mCenter.x = 3;
lABB.mCenter.y = 3;
lABB.mCenter.z = 3;

lABB.mHalfExtent.x = 10;
lABB.mHalfExtent.y = 10;
lABB.mHalfExtent.z = 10;

// create a Filter Solver
const lFilterSolver : WorkingSetInterface = lDataSession.createWorkingSet(
    WorkingSetDataRetrieval.R_OnlyGeometricInstances,
    WorkingSetBehavior.B_DiscardConfigurationsIfEmptyBit
);
// we want to get geometric instances result
lFilterSolver.setRetrieveDataMode(WorkingSetDataRetrieval.R_OnlyGeometricInstances);
// create a box filter
const lFilterAABB : FilterAABBInterface = lDataSession.createFilterAABB();
// useless, GroupOperator.GO_UNION is the default operator when creating a new filter
// lFilterAABB.setFilterOperator(GroupOperator.GO_UNION);

lFilterAABB.setAABB(lABB);

// create an FilterAttributeInterface
const lFilterAttributes : FilterAttributeInterface = lDataSession.createFilterAttribute();
// completion status to done
lFilterAttributes.setAttributeName('CompletionStatus');
lFilterAttributes.setExactValues(['done']);
// no n/a
lFilterAttributes.setNaValueChecked(false);

// intersection is the way to go since intersection of box and instances that have the field "CompletionStatus"
// to "done"
// only change the operator of the filters except the first
lFilterAttributes.setFilterOperator(GroupOperator.GO_INTERSECTION);

// and add the filters
// push back (-1) the AABB filter
lFilterSolver.insertFilter(-1, lFilterAABB);
// push back (-1) the FilterAttributeInterface, as it is the second one, its operator is used and therefore
// intersection is used
lFilterSolver.insertFilter(-1, lFilterAttributes);

// set the conf context to use => unconfigured for this example
lFilterSolver.insertWorkingSetDependency(0, lConfVisibilityCtx, GroupOperator.GO_UNION);
// and tell the DataSessionInterface to update the modified WorkingSetInterfaces
lDataSession.update();

Filters are created by the DataSessionInterface.

Metadata/Filters

See

interface FilterItemInterface {
    addEventListener(pType, pListener, pObject): string;
    addEventListener(pType, pListener): string;
    areSignalsBlocked(): boolean;
    blockSignals(pBlock): void;
    dispose(): void;
    fromJSON(pFilterData): boolean;
    getDepthContribution(): number;
    getFilterId(): string;
    getFilterOperator(): GroupOperator;
    getFilterType(): FilterType;
    getInfiniteObjectType(): InfiniteObjectType;
    getLastError(): InfiniteError;
    getParentFilter(): FilterSetInterface;
    getParentFilterId(): string;
    hasEventListener(pType, pListener): boolean;
    hasEventListenerById(pId): boolean;
    isDisposed(): boolean;
    isEnabled(): boolean;
    isInverted(): boolean;
    removeAllEventListeners(): boolean;
    removeEventListener(pType, pListener, pObject): boolean;
    removeEventListener(pType, pListener): boolean;
    removeEventListenerById(pId): boolean;
    setEnabled(pEnabled): void;
    setFilterId(pFilterId): void;
    setFilterOperator(pFilterOperator): void;
    setInverted(pInverted): void;
    toJSON(pKey?): Object;
}

Hierarchy (view full)

InfiniteObjectDispatcherInterface
- FilterItemInterface

Methods

addEventListener

addEventListener(pType, pListener, pObject): string
Adds a listener to an event type.

When an event of the type pType fires, the callback pListener will be called. This function returns a unique string id that may be used in removeEventListenerById to allow simple listener removal. It is possible to add an object that will be included in the callback to avoid creating too many closures. Calling twice addEventListener with the same parameters results in the second call to be ignored, only unique pairs callback / object are allowed, in order to avoid calling multiple times the same thing.
Parameters
- pType: string
  in
  The type of the event pListener will be called upon.
- pListener: tListenerCallback
  in
  The listener function that fires when the given event type occurs.
- pObject: Object
  in
  The optional object the callback will be called with when the given event fires.
Returns string
The id of the inserted callback (actually an UUID).

Inherited from InfiniteObjectDispatcherInterface.addEventListener
addEventListener(pType, pListener): string
Adds a listener to an event type.

When an event of the type pType fires, the callback pListener will be called. This function returns a unique string id that may be used in removeEventListenerById to allow simple listener removal.
Parameters
- pType: string
  in
  The type of the event pListener will be called upon.
- pListener: tListenerCallback
  in
  The listener function that fires when the given event type occurs.
Returns string
The id of the inserted callback (actually an UUID).

Inherited from InfiniteObjectDispatcherInterface.addEventListener

areSignalsBlocked

areSignalsBlocked(): boolean
Tells if signals sent by the object are blocked or not.

If signals are blocked, no signal will be emitted nor buffered, such signal will be lost.

Returns boolean
true if signals are blocked.

Inherited from InfiniteObjectDispatcherInterface.areSignalsBlocked

blockSignals

blockSignals(pBlock): void
Blocks / Unblocks all signals sent by the object.

If signals are blocked, no signal will be emitted nor buffered, such signal will be lost.
Parameters
- pBlock: boolean
  in
  If set to true, all further signals will be silently discarded.
Returns void
Inherited from InfiniteObjectDispatcherInterface.blockSignals

dispose

dispose(): void
Gets rid of this object.

After this call, this object can no longer be used.

If the object is an InfiniteObjectDispatcherInterface, then the InfiniteObjectDispatcherInterfaceSignal.ObjectDisposed signal is emitted.

Further uses of the object (with the exception of isDisposed, getInfiniteObjectType and application id retrieval) will log a message with LogLevel.LL_UsingDisposedObject.

Returns void
See
Inherited from InfiniteObjectDispatcherInterface.dispose

fromJSON

fromJSON(pFilterData): boolean

Sets the content of the FilterItemInterface from a former call to toJSON.

Use addEventListener on the event FilterItemInterfaceSignal.FilterDataChanged to know when the FilterItemInterface internal data changed.

{
    "$defs": {
        "all": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "all",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "id"
            ],
            "title": "Filter all definition",
            "type": "object"
        },
        "attribute": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "containsValues": {
                    "description": "Elects all the `part instances` having the attribute whose name set with attribute in their `joined attribute set` that have a value that contains at least one of the values in the given string array",
                    "items": {
                        "type": "string"
                    },
                    "type": "array"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "exactValues": {
                    "description": "Elects all the `part instances` having the attribute whose name set with `attribute` in their `joined attribute set` that have a value exactly included in the given string array.",
                    "items": {
                        "type": "string"
                    },
                    "type": "array"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "na": {
                    "description": "Include `part instances` with the `N/A` value",
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "attribute",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "enabled",
                "operator",
                "inverted",
                "exactValues",
                "containsValues",
                "na",
                "attribute",
                "id"
            ],
            "title": "Filter attribute definition",
            "type": "object"
        },
        "boolean": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "boolean",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "value": {
                    "default": false,
                    "description": "Boolean value of the filter",
                    "example": false,
                    "type": "boolean"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "attribute",
                "value",
                "id"
            ],
            "title": "Filter boolean definition",
            "type": "object"
        },
        "box": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "max": {
                    "description": "Define the coordinates [x,y,z] of the max point of the AABB",
                    "items": {
                        "type": "number"
                    },
                    "maxItems": 3,
                    "minItems": 3,
                    "type": "array"
                },
                "min": {
                    "description": "Define the coordinates [x,y,z] of the min point of the AABB",
                    "items": {
                        "type": "number"
                    },
                    "maxItems": 3,
                    "minItems": 3,
                    "type": "array"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "overlap": {
                    "description": "Specify if AABB test is included or overlap",
                    "example": true,
                    "type": "boolean"
                },
                "precision": {
                    "description": "Numeric precision will be subtracted/added to min/max point of AABB",
                    "type": "number"
                },
                "type": {
                    "const": "box",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "inverted",
                "enabled",
                "min",
                "max",
                "overlap",
                "precision",
                "id"
            ],
            "title": "Filter box definition",
            "type": "object"
        },
        "compound": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "subfilters": {
                    "description": "list of metadata sub filters",
                    "items": {
                        "$ref": "#/$defs/compoundfilters"
                    },
                    "type": "array"
                },
                "type": {
                    "const": "compound",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "subfilters",
                "id"
            ],
            "title": "Filter compound definition",
            "type": "object"
        },
        "compoundfilters": {
            "oneOf": [
                {
                    "$ref": "#/$defs/boolean"
                },
                {
                    "$ref": "#/$defs/hasfield"
                },
                {
                    "$ref": "#/$defs/attribute"
                },
                {
                    "$ref": "#/$defs/range"
                }
            ]
        },
        "diagonal": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "rangeitems": {
                    "description": "List of range item",
                    "items": {
                        "$ref": "#/$defs/rangeitem"
                    },
                    "type": "array"
                },
                "type": {
                    "const": "diagonal",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "rangeitems",
                "id"
            ],
            "title": "Filter diagonal definition",
            "type": "object"
        },
        "filter": {
            "oneOf": [
                {
                    "$ref": "#/$defs/box"
                },
                {
                    "$ref": "#/$defs/all"
                },
                {
                    "$ref": "#/$defs/attribute"
                },
                {
                    "$ref": "#/$defs/boolean"
                },
                {
                    "$ref": "#/$defs/literal"
                },
                {
                    "$ref": "#/$defs/compound"
                },
                {
                    "$ref": "#/$defs/diagonal"
                },
                {
                    "$ref": "#/$defs/hasfield"
                },
                {
                    "$ref": "#/$defs/partinstanceidlist"
                },
                {
                    "$ref": "#/$defs/range"
                },
                {
                    "$ref": "#/$defs/filterset"
                }
            ]
        },
        "filterset": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "subfilters": {
                    "description": "List of sub filters",
                    "items": {
                        "oneOf": [
                            {
                                "$ref": "#/$defs/box"
                            },
                            {
                                "$ref": "#/$defs/all"
                            },
                            {
                                "$ref": "#/$defs/attribute"
                            },
                            {
                                "$ref": "#/$defs/boolean"
                            },
                            {
                                "$ref": "#/$defs/literal"
                            },
                            {
                                "$ref": "#/$defs/compound"
                            },
                            {
                                "$ref": "#/$defs/diagonal"
                            },
                            {
                                "$ref": "#/$defs/hasfield"
                            },
                            {
                                "$ref": "#/$defs/partinstanceidlist"
                            },
                            {
                                "$ref": "#/$defs/range"
                            },
                            {
                                "$ref": "#/$defs/filterset"
                            }
                        ]
                    },
                    "type": "array"
                },
                "type": {
                    "const": "set",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "enabled",
                "operator",
                "inverted",
                "subfilters",
                "id"
            ],
            "title": "Filter set definition",
            "type": "object"
        },
        "hasfield": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "hasfield",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "attribute",
                "id"
            ],
            "title": "Filter Has field definition",
            "type": "object"
        },
        "literal": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "query": {
                    "description": "Sets the query string in the 3djuump infinite literal and search query language",
                    "example": ":PartNumber=='bolt'",
                    "type": "string"
                },
                "type": {
                    "const": "literal",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "query",
                "id"
            ],
            "title": "Filter literal definition",
            "type": "object"
        },
        "partinstanceidlist": {
            "additionalProperties": false,
            "properties": {
                "buildid": {
                    "description": "Id of the build use to create the part list instance",
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "list": {
                    "description": "List of part instance ids",
                    "items": {
                        "type": "number"
                    },
                    "type": "array"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "partinstanceidlist",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "buildid",
                "list",
                "id"
            ],
            "title": "Filter Part instance list definition",
            "type": "object"
        },
        "range": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "rangeitems": {
                    "description": "List of range item",
                    "items": {
                        "$ref": "#/$defs/rangeitem"
                    },
                    "type": "array"
                },
                "type": {
                    "const": "range",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "attribute",
                "rangeitems",
                "id"
            ],
            "title": "Filter range definition",
            "type": "object"
        },
        "rangeitem": {
            "additionalProperties": false,
            "properties": {
                "includedLower": {
                    "description": "Sets if the lower bound value should be included or excluded",
                    "type": "boolean"
                },
                "includedUpper": {
                    "description": "Sets if the upper bound value should be included or excluded",
                    "type": "boolean"
                },
                "lower": {
                    "description": "Lower bound of the range item",
                    "type": "number"
                },
                "upper": {
                    "description": "Upper bound of the range item",
                    "type": "number"
                }
            },
            "required": [
                "includedLower",
                "includedUpper"
            ],
            "title": "Range item definition",
            "type": "object"
        }
    },
    "$ref": "#/$defs/filter",
    "$schema": "https://json-schema.org/draft-07/schema#"
}

This schema may evolve in the future.

Parameters

pFilterData: string | Object
in
Internal FilterItemInterface data to set.

Returns boolean

true if the data is set.

See

toJSON

getDepthContribution

getDepthContribution(): number
Gets the depth contribution of the FilterItemInterface.

This value is usually one.

Returns number
The depth contribution of the FilterItemInterface.

getFilterId

getFilterId(): string
Gets the identifier of the FilterItemInterface.

Returns string
The identifier of the FilterItemInterface.

getFilterOperator

getFilterOperator(): GroupOperator
Gets the operator to apply with this FilterItemInterface and its closest enabled predecessor in its parent container.

The FilterItemInterface operator of the first enabled FilterItemInterface in a parent list (WorkingSetInterface, FilterSetInterface, FilterCompoundInterface) is always ignored, but a warning is outputted in the console when the GroupOperator is different that GroupOperator.GO_UNION.

A FilterItemInterface has the GroupOperator.GO_UNION operator by default.

Returns GroupOperator
The operator to combine this FilterItemInterface and its first enabled predecessor.

See
GroupOperator

getFilterType

getFilterType(): FilterType
Gets the type of the FilterItemInterface.

Returns FilterType
The FilterItemInterface type.

See
FilterType

getInfiniteObjectType

getInfiniteObjectType(): InfiniteObjectType
Tells the type of the given interface.

Returns InfiniteObjectType
The type of the given interface.

Inherited from InfiniteObjectDispatcherInterface.getInfiniteObjectType

getLastError

getLastError(): InfiniteError
Gets the last error returned after the update of the WorkingSetInterface this filter belongs to.

This helps get the filter that is in error if the WorkingSetInterface is in error.

The error message is updated If the containing WorkingSetInterface is modified and DataSessionInterface.update is called.

Returns InfiniteError
An InfiniteError containing the last error if any, or undefined if no error occurred.

getParentFilter

getParentFilter(): FilterSetInterface
Gets the parent container that contains this FilterItemInterface (getFilterId()).

Such a container may be a FilterSetInterface or a FilterCompoundInterface. Returns an empty string if the FilterItemInterface is not included in a parent container or directly inside a WorkingSetInterface.

Returns FilterSetInterface
The parent container if any.

getParentFilterId

getParentFilterId(): string
Gets the identifier of the parent container that contains this FilterItemInterface (getFilterId()).

Such a container may be a FilterSetInterface or a FilterCompoundInterface. Returns an empty string if the FilterItemInterface is not included in a parent container or directly inside a WorkingSetInterface.

Returns string
The identifier of the parent container.

hasEventListener

hasEventListener(pType, pListener): boolean
Tells if the EventDispatcher has such a callback registered for the given event type.
Parameters
- pType: string
  in
  The type of the event to test.
- pListener: tListenerCallback
  in
  The listener function that gets tested.
Returns boolean
true if such a listener is installed for the given type of event.

Inherited from InfiniteObjectDispatcherInterface.hasEventListener

hasEventListenerById

hasEventListenerById(pId): boolean
Tells if the EventDispatcher has such a callback registered for the given callback id.
Parameters
- pId: string
  in
  The id of the callback to test.
Returns boolean
true if such a listener is installed for the given callback id.

Inherited from InfiniteObjectDispatcherInterface.hasEventListenerById

isDisposed

isDisposed(): boolean
Tells if this object has been gotten rid off.

Returns boolean
true if dispose has been called on this object.

Inherited from InfiniteObjectDispatcherInterface.isDisposed

isEnabled

isEnabled(): boolean
Tells if the FilterItemInterface is enabled.

If disabled, this FilterItemInterface is completely ignored during all the computations (the behavior is the same as if it had not been created).

A FilterItemInterface is enabled by default.

Returns boolean
true if the FilterItemInterface is enabled.

isInverted

isInverted(): boolean
Tells if the FilterItemInterface is "inverted".

When "inverted", a FilterItemInterface elects all the part instances that were not selected if it was not inverted.

A FilterItemInterface is not "inverted" by default.

Returns boolean
true if such a FilterItemInterface is "inverted".

removeAllEventListeners

removeAllEventListeners(): boolean
Removes all the event listeners.

Returns boolean
true if all the callbacks were removed else false.

Inherited from InfiniteObjectDispatcherInterface.removeAllEventListeners

removeEventListener

removeEventListener(pType, pListener, pObject): boolean
Removes a listener from an event type.

If no such listener is found, then the function returns false and does nothing. You must use the exact parameters that were used in addEventListener to actually remove the listener.
Parameters
- pType: string
  in
  The type of the listener that gets removed.
- pListener: tListenerCallback
  The listener function that gets removed.
- pObject: Object
  The listener object that was used when addEventListener was called.
Returns boolean
true if the callback was removed else false.

Inherited from InfiniteObjectDispatcherInterface.removeEventListener
removeEventListener(pType, pListener): boolean
Removes a listener from an event type.

If no such listener is found, then the function returns false and does nothing. You must use the exact parameters that were used in addEventListener to actually remove the listener.
Parameters
- pType: string
  in
  The type of the listener that gets removed.
- pListener: tListenerCallback
  The listener function that gets removed.
Returns boolean
true if the callback was removed else false.

Inherited from InfiniteObjectDispatcherInterface.removeEventListener

removeEventListenerById

removeEventListenerById(pId): boolean
Removes a listener by its id.

If no such listener is found, then the function returns false and does nothing. You must use the return value of addEventListener to actually remove the listener.
Parameters
- pId: string
  in
  The id returned by the call to addEventListener that you want to remove.
Returns boolean
true if the callback was removed else false.

Inherited from InfiniteObjectDispatcherInterface.removeEventListenerById

setEnabled

setEnabled(pEnabled): void
Sets the FilterItemInterface enabled/disabled status.

If disabled, this FilterItemInterface is completely ignored during all the computations (the behavior is the same as if it had not been created). Use addEventListener on the event FilterItemInterfaceSignal.FilterEnabledChanged to know when the FilterItemInterface has changed its enabled status. Modifying a disabled FilterItemInterface will not trigger any change in the containing FilterSetInterface / WorkingSetInterface.

A FilterItemInterface is enabled by default.
Parameters
- pEnabled: boolean
  in
  If true, the given FilterItemInterface is enabled.
Returns void

setFilterId

setFilterId(pFilterId): void
Sets the identifier of the FilterItemInterface.

Make sure the id is unique across the application.
Parameters
- pFilterId: string
  in
  The new identifier of the FilterItemInterface.
Returns void

setFilterOperator

setFilterOperator(pFilterOperator): void
Sets the operator to apply with this FilterItemInterface and its closest enabled predecessor in its parent container.

The FilterItemInterface operator of the first enabled FilterItemInterface in a parent list (WorkingSetInterface, FilterSetInterface, FilterCompoundInterface) is always ignored, but a warning is outputted in the console when the GroupOperator is different that GroupOperator.GO_UNION. Use addEventListener on the event FilterItemInterfaceSignal.FilterInvertedChanged to know when the FilterItemInterface operator changed.

A FilterItemInterface has the GroupOperator.GO_UNION operator by default.
Parameters
- pFilterOperator: GroupOperator
  in
  The operator to combine this FilterItemInterface and its first enabled predecessor.
Returns void
See
GroupOperator

setInverted

setInverted(pInverted): void
Sets the "inverted" status of the FilterItemInterface.

When "inverted", a FilterItemInterface elects all the part instances that were not selected if it was not inverted. Use addEventListener on the event FilterItemInterfaceSignal.FilterInvertedChanged to know when the FilterItemInterface has changed its "inverted" status.

A FilterItemInterface is not "inverted" by default.
Parameters
- pInverted: boolean
  in
  If true, such a FilterItemInterface will be "inverted".
Returns void

toJSON

toJSON(pKey?): Object
Gets a deep copy of the internal data of the FilterItemInterface.

Please refer to JSON.stringify.
Parameters
- Optional pKey: any
  in
  Unused.
Returns Object
The internal FilterItemInterface data.

See
fromJSON

Interface FilterItemInterface

See

Hierarchy (view full)

Index

Methods

Methods

addEventListener

Parameters

Returns string

Parameters

Returns string

areSignalsBlocked

Returns boolean

blockSignals

Parameters

Returns void

dispose

Returns void

See

fromJSON

Parameters

Returns boolean

See

getDepthContribution

Returns number

getFilterId

Returns string

getFilterOperator

Returns GroupOperator

See

getFilterType

Returns FilterType

See

getInfiniteObjectType

Returns InfiniteObjectType

getLastError

Returns InfiniteError

getParentFilter

Returns FilterSetInterface

getParentFilterId

Returns string

hasEventListener

Parameters

Returns boolean

hasEventListenerById

Parameters

Returns boolean

isDisposed

Returns boolean

isEnabled

Returns boolean

isInverted

Returns boolean

removeAllEventListeners

Returns boolean

removeEventListener

Parameters

Returns boolean

Parameters

Returns boolean

removeEventListenerById

Parameters

Returns boolean

setEnabled

Parameters

Returns void

setFilterId

Parameters

Returns void

setFilterOperator

Parameters

Returns void

See

setInverted

Parameters

Returns void

toJSON

Parameters

Returns Object

See