Interface FilterRangeInterface

The FilterRangeInterface interface is a FilterItemInterface to elect part instances that have a numeric/date metadata inside or that intersects a fixed set of ranges.

The filter range interface works on metadata of type :

AttributeType.ATTR_NUMBER : number.
AttributeType.ATTR_DATE : date.
AttributeType.ATTR_NUMBER_RANGE : number range.
AttributeType.ATTR_DATE_RANGE : date range.

The type of the metadata is given by the AttributeInfoInterface.getAttributeType from the AttributesDictionaryInterface once the DMU is loaded.

This interface allows to create range items FilterRangeItemInterface to allow the creation of an union of ranges, to be tested against a value or another range (be it numeric or a date).

The API only exposes numbers. Indeed, date types must be converted to a number : dates must be expressed as number of milliseconds since January 1, 1970, 00:00:00 UTC, dates must be converted with the use of the getTime functions, and created or modified with the Date constructor from a number (the number of milliseconds since January 1, 1970, 00:00:00 UTC) or with the setTime function. Negative values are accepted.

Suppose the user wants to get all part instances that are created between yesterday and the current date time. The relevant part instances have the metadata CreationDate with the AttributeType.ATTR_DATE type :

/** 
 * Sample to illustrate how to use a FilterRangeInterface with dates.
 */
import {
    WorkingSetInterface,
    AttributesDictionaryInterface, AttributeInfoInterface,
    AttributeType, FilterRangeItemInterface,
    tListenerCallback, FilterRangeInterface, DataSessionInterface,
    WorkingSetInterfaceSignal,
    WorkingSetDataRetrieval,
    GroupOperator,
    WorkingSetBehavior
} from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;
// we will try to find all `part instances` that have
// a "CreationDate" between today and yesterday
const lPartInstanceName : string = 'CreationDate';

// what to do when result has been computed ?
let onResultReady : tListenerCallback;

/* MAKE SURE the attribute "CreationDate" is relevant */
const lAttributeDictionary : AttributesDictionaryInterface = lDataSession.getAttributesDictionary();
const lAttributeInfo : AttributeInfoInterface | undefined = lAttributeDictionary.getAttributeInfo(lPartInstanceName);
// make sure the attribute is a date one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_DATE));

/* WORKING SETS */
// 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);

/* SOLVER */
// create the solver to retrieve the result
// we want to get geometric instances result
const lGlobalSolver : WorkingSetInterface = lDataSession.createWorkingSet(
    WorkingSetDataRetrieval.R_OnlyGeometricInstances,
    WorkingSetBehavior.B_DiscardConfigurationsIfEmptyBit
);
lGlobalSolver.insertWorkingSetDependency(0, lConfVisibilityCtx, GroupOperator.GO_UNION);
// bind the solver to custom implementation when the result is ready
lGlobalSolver.addEventListener(WorkingSetInterfaceSignal.WorkingSetReady, onResultReady);

/* RANGE FILTER */
// create the today time
const lToday : Date = new Date();
// yesterday is today minus 24 hours
const lYesterday : Date = new Date();
// 1000 ms in a sec, 3600 secs in an hour, 24 hours in a day 
const lMillisecondsInADay : number = 24 * 3600 * 1000;
lYesterday.setTime(lToday.getTime() - lMillisecondsInADay);
// we may have used lYesterday = new Date(lToday.getTime() - lMillisecondsInADay);

// create a range filter
const lRangeFilter : FilterRangeInterface = lDataSession.createFilterRange();
// useless, GroupOperator.GO_UNION is the default operator when creating a new filter
// lRangeFilter.setFilterOperator(GroupOperator.GO_UNION);

// on the given attribute
lRangeFilter.setAttributeName(lPartInstanceName);
// and add a range to test ([yesterday, today] included)
const lRangeFilterContent : FilterRangeItemInterface = lRangeFilter.createFilterRangeItem();
// include lower bound
lRangeFilterContent.setIncludedLower(true);
// include upper bound
lRangeFilterContent.setIncludedUpper(true);
// set the lower bound as yesterday (Dates must be expressed as number of milliseconds since January 1, 1970, 00:00:00 UTC)
lRangeFilterContent.setLowerBound(lYesterday.getTime());
// set the upper bound to today (Dates must be expressed as number of milliseconds since January 1, 1970, 00:00:00 UTC)
lRangeFilterContent.setUpperBound(lToday.getTime());

// add the filter to the solver
lGlobalSolver.insertFilter(0, lRangeFilter);
// and go => make the DataSessionInterface compute the result
lDataSession.update();

This interface MUST be used in a WorkingSetInterface, (see Working Sets).

Metadata/Filters

See

FilterRangeItemInterface

interface FilterRangeInterface {
    addEventListener(pType, pListener, pObject): string;
    addEventListener(pType, pListener): string;
    areSignalsBlocked(): boolean;
    blockSignals(pBlock): void;
    createFilterRangeItem(): FilterRangeItemInterface;
    dispose(): void;
    forceRevalidation(pCacheTimeIntervalInMSec): boolean;
    fromJSON(pFilterData): boolean;
    getAttributeName(): string;
    getDepthContribution(): number;
    getFilterId(): string;
    getFilterOperator(): GroupOperator;
    getFilterType(): FilterType;
    getInfiniteObjectType(): InfiniteObjectType;
    getLastError(): InfiniteError;
    getParentFilter(): FilterSetInterface;
    getParentFilterId(): string;
    getRangeItem(pRangeIndex): FilterRangeItemInterface;
    getRangeItems(): FilterRangeItemInterface[];
    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;
    removeRangeItem(pRangeIndex): boolean;
    setAttributeName(pAttributeName): boolean;
    setEnabled(pEnabled): void;
    setFilterId(pFilterId): void;
    setFilterOperator(pFilterOperator): void;
    setInverted(pInverted): void;
    toJSON(pKey?): Object;
}

Hierarchy (view full)

FilterItemInterface
- FilterRangeInterface

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 FilterItemInterface.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 FilterItemInterface.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 FilterItemInterface.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 FilterItemInterface.blockSignals

createFilterRangeItem

createFilterRangeItem(): FilterRangeItemInterface
Creates and adds a new range item into the list of range items of the object.

Returns FilterRangeItemInterface
The newly created filter range item.

See
FilterRangeItemInterface

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 FilterItemInterface.dispose

forceRevalidation

forceRevalidation(pCacheTimeIntervalInMSec): boolean
Forces a recomputation of the filter.

The 3djuump infinite backend is using a cache system to speedup the computations. This call, in case a metadata is updated, forces the backend to recompute the content of the filter and may refresh the result, in case the metadata has been updated till the last call.

If the data cached is older than the given time interval in seconds, then the cache will be invalidated, and the result of the filter will be computed again. This does not mean the result of the filter will be updated in any case.

pCacheTimeIntervalInMSec MUST be superior or equal to 10000 (10 seconds).
Parameters
- pCacheTimeIntervalInMSec: number
  in
  The time interval in milliseconds the cache will be considered outdated.
Returns boolean
true if the call was successful.

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

getAttributeName

getAttributeName(): string
Gets the name of the attribute to filter with.

Returns string
The name of the attribute to filter with.

getDepthContribution

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

This value is usually one.

Returns number
The depth contribution of the FilterItemInterface.

Inherited from FilterItemInterface.getDepthContribution

getFilterId

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

Returns string
The identifier of the FilterItemInterface.

Inherited from FilterItemInterface.getFilterId

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

Inherited from FilterItemInterface.getFilterOperator

getFilterType

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

Returns FilterType
The FilterItemInterface type.

See
FilterType

Inherited from FilterItemInterface.getFilterType

getInfiniteObjectType

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

Returns InfiniteObjectType
The type of the given interface.

Inherited from FilterItemInterface.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.

Inherited from FilterItemInterface.getLastError

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.

Inherited from FilterItemInterface.getParentFilter

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.

Inherited from FilterItemInterface.getParentFilterId

getRangeItem

getRangeItem(pRangeIndex): FilterRangeItemInterface
Gets the range item at index pRangeIndex.

If pRangeIndex is negative or superior or equal to the number of range items, this function does nothing and returns undefined.
Parameters
- pRangeIndex: number
  in
  Index of the range item to get.
Returns FilterRangeItemInterface
The given FilterRangeItemInterface (this is the actual data held by the FilterRangeInterface, and not a copy) if pRangeIndex is valid else return undefined.

getRangeItems

getRangeItems(): FilterRangeItemInterface[]
Gets the list of all range items.

This function should not be used to add or remove range items, the FilterRangeInterface will not see the modifications if the array is modified.

However, modifying items inside the array is allowed.

Returns FilterRangeItemInterface[]
warning
all range items inside the FilterRangeInterface.

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

Inherited from FilterItemInterface.isEnabled

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

Inherited from FilterItemInterface.isInverted

removeAllEventListeners

removeAllEventListeners(): boolean
Removes all the event listeners.

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

Inherited from FilterItemInterface.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 FilterItemInterface.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 FilterItemInterface.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 FilterItemInterface.removeEventListenerById

removeRangeItem

removeRangeItem(pRangeIndex): boolean
Removes the range item at the position pRangeIndex.

If pRangeIndex is negative or superior or equal to the number of range items, this function does nothing and returns false. Returns true if the item is effectively removed.
Parameters
- pRangeIndex: number
  in
  Index of the range item to remove.
Returns boolean
true if the item was removed else return false.

setAttributeName

setAttributeName(pAttributeName): boolean
Sets the name of the attribute to filter with.

Using an unknown attribute name or an invalid attribute type (only AttributeType.ATTR_NUMBER, AttributeType.ATTR_DATE, AttributeType.ATTR_NUMBER_RANGE and AttributeType.ATTR_DATE_RANGE types are accepted) will return false and leaves the FilterRangeInterface unchanged.

Setting the same attribute name will return true and leave the FilterRangeInterface unchanged.

Setting a valid and new attribute name will clear the ranges that may have previously created by createFilterRangeItem.

A FilterRangeInterface has an empty (invalid) attribute name by default. An (invalid) empty attribute name can also bet set.

Use EventDispatcherInterface.addEventListener on the event FilterItemInterfaceSignal.FilterDataChanged to know when the filter data is changed.
Parameters
- pAttributeName: string
  in
  The name of the attribute to filter.
Returns boolean
true if pAttributeName refers to an existing and valid attribute.

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
Inherited from FilterItemInterface.setEnabled

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
Inherited from FilterItemInterface.setFilterId

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

Inherited from FilterItemInterface.setFilterOperator

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
Inherited from FilterItemInterface.setInverted

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

Inherited from FilterItemInterface.toJSON

Interface FilterRangeInterface

See

Hierarchy (view full)

Index

Methods

Methods

addEventListener

Parameters

Returns string

Parameters

Returns string

areSignalsBlocked

Returns boolean

blockSignals

Parameters

Returns void

createFilterRangeItem

Returns FilterRangeItemInterface

See

dispose

Returns void

See

forceRevalidation

Parameters

Returns boolean

fromJSON

Parameters

Returns boolean

See

getAttributeName

Returns string

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

getRangeItem

Parameters

Returns FilterRangeItemInterface

getRangeItems

Returns FilterRangeItemInterface[]

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

removeRangeItem

Parameters

Returns boolean

setAttributeName