Interface ChildrenIdCardGetterInterface

The ChildrenIdCardGetterInterface interface is used to retrieve information about the children of a part instance (and not a geometric instance id), such as the metadata of the children parts, link, the list of children attached document, ....

The metadata documents and general information about the children can be retrieved by knowing the part instance id of the parent to retrieve. Such documents are usually requested after an id-card request.

The ChildrenIdCardGetterInterface interfaces are created through the DataSessionInterface.createChildrenIdCardGetter method.

/** 
 * Sample to illustrate the use of an ChildrenIdCardGetterInterface from a `part instance id`, to get the brothers of a part instance.
 */
import {
    IdCardGetterInterface, IdCardGetterInterfaceSignal, ChildrenIdCardGetterInterface,
    ChildrenIdCardGetterInterfaceSignal, PartInstanceInfoInterface, InfiniteEvent,
    ChildrenPartInstanceInfoInterface, DataSessionInterface, AncestryInstanceMetadataInterface,
    InstanceMetadataInterface, DocumentContentInterface, WorkingSetInterface
} from 'generated_files/documentation/appinfiniteapi';
// the `part instances` are retrieved by a picking for example

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;
// the `part instance id` to get information from (get its brothers)
let lPartInstanceId : number;
// the current Working set has been created previously
let lWorkingSet : WorkingSetInterface;

// what to do when the id card retrieval is over
let onIdCardReady : (pEvent, _pCallbackData) => void;

// what to do when the children id card retrieval is over
let onChildrenIdCardReady : (pEvent, _pCallbackData) => void;

// id card getter interface creation
const lIdCardGetterInterface : IdCardGetterInterface = lDataSession.createIdCardGetter();
// children id card getter interface creation
const lChildrenIdCardGetterInterface : ChildrenIdCardGetterInterface = lDataSession.createChildrenIdCardGetter();

// connect the IDCardReady signal to the handling of the metadata of the `part instance` and its genealogy 
lIdCardGetterInterface.addEventListener(IdCardGetterInterfaceSignal.IdCardReady, onIdCardReady);

// connect the GeometricInstanceConverterReady signal to the id card retrieval
lChildrenIdCardGetterInterface.addEventListener(ChildrenIdCardGetterInterfaceSignal.ChildrenIdCardReady, onChildrenIdCardReady);

// trigger the id-card retrieval
lIdCardGetterInterface.retrieveIdCard(lPartInstanceId, lWorkingSet);

// onIdCardReady will be called when data is available
onIdCardReady = (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) : void =>
{
    if (lIdCardGetterInterface.getLastError() !== undefined) {
        // do nothing in case of error
        // perhaps some GUI code ?
        return;
    }
    const lPartInstanceInfos : Array<PartInstanceInfoInterface> | undefined = lIdCardGetterInterface.getPartInstanceInfos();
    if (!lPartInstanceInfos || lPartInstanceInfos.length !== 1)
    {
        // no data (isCancelled ?)
        return;
    }
    // we required only one `part instance`, as such, only one result should be retrieved
    // iterate over the instantiation chain, but take the first chain since one `part instance` retrieved
    const lCurrentChain : PartInstanceInfoInterface = lPartInstanceInfos[0];
    // get all metadata hierarchy
    const lAllInstanceMetadata : Array<AncestryInstanceMetadataInterface> = lCurrentChain.getAncestorInstanceInfos();
    // number of items 
    const lNbAncestors : number = lAllInstanceMetadata.length;

    // the instance offset is the last one
    const lInstanceOffset : number = lNbAncestors - 1;
    if (lInstanceOffset < 1)
    {
        console.log(lPartInstanceId + ' is a leaf instance, exiting');
        return;
    }
    const lParentInstanceId : number = lAllInstanceMetadata[lInstanceOffset].getParentInstanceId();
    // this is the same as lAllInstanceMetadata[lInstanceOffset-1].getInstanceId();
    lChildrenIdCardGetterInterface.retrieveChildrenIdCard(lParentInstanceId, lWorkingSet);
};

// onChildrenIdCardReady will be called when data is available
onChildrenIdCardReady = (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) : void =>
{
    if (lChildrenIdCardGetterInterface.getLastError() !== undefined) {
        // do nothing in case of error
        // perhaps some GUI code ?
    }
    const lPartInstanceInfos : Array<ChildrenPartInstanceInfoInterface> | undefined = lChildrenIdCardGetterInterface.getPartInstanceInfos();
    if (!lPartInstanceInfos || lPartInstanceInfos.length !== 1)
    {
        // no data (isCancelled ?)
        return;
    }
    // we required only one `part instance`, as such, only one result should be retrieved
    // iterate over the instantiation chain, but take the first chain since one `part instance` retrieved
    const lChildren : ChildrenPartInstanceInfoInterface = lPartInstanceInfos[0];

    let i : number;
    // iterate over the children metadata infos
    const lAllInstanceMetadata : Array<InstanceMetadataInterface> = lChildren.getChildrenInstanceInfos();
    const lNbChildren : number = lAllInstanceMetadata.length;
    let lCurChildMetadata : InstanceMetadataInterface;

    // we should have the part instance in the list of children
    for(i = 0; i < lNbChildren; i += 1)
    {
        lCurChildMetadata = lAllInstanceMetadata[i];
        if(lCurChildMetadata.getInstanceId() === lPartInstanceId)
        {
            break;
        }
    }
    if (i === lNbChildren)
    {
        console.log('something really weird has happen, I am not in the list of children of my parent, am I the root ?');
        return;
    }
    // we get the `part` metadata of the last child of the `part instance`
    const lPartMetadataDocuments : Array<DocumentContentInterface> = lCurChildMetadata.getPartMetadataDocuments();
    if (lPartMetadataDocuments.length === 0)
    {
        console.log('this part instance has no part metadata documents');
        return;
    }
    // we get the `part` metadata of me (but should do something else even more interesting)
    // and we only care with the first document, but many documents may be attached
    const lPartMetadata : Object = lPartMetadataDocuments[0].getDocumentContent();
    // some fancy output
    console.log(JSON.stringify(lPartMetadata));
};

Copy

The list of signals the ChildrenIdCardGetterInterface may trigger is available in the ChildrenIdCardGetterInterfaceSignal enumeration.

The metadata retrieval procedure is triggered through the retrieveChildrenIdCard methods. The result is not available right away, but the event ChildrenIdCardGetterInterfaceSignal.ChildrenIdCardReady is triggered when the result of the ChildrenIdCardGetterInterface is available. The result is available through the getPartInstanceInfos function.

Warning : there may be cases when the getPartInstanceInfos is not available such as when the ChildrenIdCardGetterInterface is updating, i.e. when isRunning returns true, or when the ChildrenIdCardGetterInterface has been cancelled, i.e. when isCancelled returns true.

An ChildrenIdCardGetterInterface may be interrupted (cancelled) when the ChildrenIdCardGetterInterface is updating and cancel is called. In such cases, the ChildrenIdCardGetterInterfaceSignal.ChildrenIdCardCancelled signal is fired, and shortly after, ChildrenIdCardGetterInterfaceSignal.ChildrenIdCardReady signal is fired, but getPartInstanceInfos will return undefined. Just call retrieveChildrenIdCard with another (or the same) part instance ids to trigger a new retrieval.

If you call multiple times retrieveChildrenIdCard before receiving the ChildrenIdCardGetterInterfaceSignal.ChildrenIdCardReady, only one ChildrenIdCardGetterInterfaceSignal.ChildrenIdCardReady will be sent with the content of the last call to retrieveChildrenIdCard.

The developer may process the results of an id card retrieval with the following code :

/** 
 * Sample to illustrate the use of an ChildrenIdCardGetterInterface with the parsing of
 * PartInstanceInfoInterface to display some information about a part instance.
 */
import {
    ChildrenIdCardGetterInterface, ChildrenIdCardGetterInterfaceSignal,
    InfiniteEvent, ChildrenPartInstanceInfoInterface, DataSessionInterface,
    InstanceMetadataInterface, DocumentContentInterface, WorkingSetInterface
} from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;
// created previously
let lWorkingSet : WorkingSetInterface;
// the `part instance id` to get
let lPartInstanceId : number;
// what to do when we have retrieved id card information ?
let onChildrenIdCardReady : (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) => void;

// create an ChildrenIdCardGetter
const lChildrenIdCardGetterInterface : ChildrenIdCardGetterInterface = lDataSession.createChildrenIdCardGetter();
// what to do when result is ready ?
lChildrenIdCardGetterInterface.addEventListener(ChildrenIdCardGetterInterfaceSignal.ChildrenIdCardReady, onChildrenIdCardReady);

// onChildrenIdCardReady will be called when data is available
onChildrenIdCardReady = (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) : void =>
{
    if (lChildrenIdCardGetterInterface.getLastError() !== undefined) {
        // do nothing in case of error
        // perhaps some GUI code ?
    }
    const lPartInstanceInfos : Array<ChildrenPartInstanceInfoInterface> | undefined = lChildrenIdCardGetterInterface.getPartInstanceInfos();
    if (!lPartInstanceInfos || lPartInstanceInfos.length !== 1)
    {
        // no data (isCancelled ?)
        return;
    }
    // we required only one `part instance`, as such, only one result should be retrieved
    // iterate over the instantiation chain, but take the first chain since one `part instance` retrieved
    const lCurrentChildren : ChildrenPartInstanceInfoInterface = lPartInstanceInfos[0];

    // iterate over the children metadata infos
    const lAllInstanceMetadata : Array<InstanceMetadataInterface> = lCurrentChildren.getChildrenInstanceInfos();

    // number of items 
    const lNbChildren : number = lAllInstanceMetadata.length;
    if (lNbChildren <= 0)
    {
        console.log('this part instance is a leaf');
        return;
    }
    // take the last child
    const lChildInstanceOffset : number = lNbChildren - 1;
    const lLastChildInstanceInfos : InstanceMetadataInterface = lAllInstanceMetadata[lChildInstanceOffset];
    // we get the `part` metadata of the last child of the `part instance`
    const lPartMetadataDocuments : Array<DocumentContentInterface> = lLastChildInstanceInfos.getPartMetadataDocuments();
    if (lPartMetadataDocuments.length === 0)
    {
        console.log('this part instance has no part metadata documents');
        return;
    }
    // and we only care with the first document, but many documents may be attached
    const lPartMetadata : Object = lPartMetadataDocuments[0].getDocumentContent();
    // some fancy output
    console.log(JSON.stringify(lPartMetadata));

    // get the visibility info in order to get information about the `part instance`
    if (lLastChildInstanceInfos.isDisplayable())
    {
        console.log('the last child of the part instance is displayable');
    }
};

// trigger the retrieval
lChildrenIdCardGetterInterface.retrieveChildrenIdCard(lPartInstanceId, lWorkingSet);

Copy

or asynchronously :

/** 
 * Sample to illustrate the asynchronous use of an ChildrenIdCardGetterInterface with the parsing of
 * PartInstanceInfoInterface to display some information about a part instance.
 */
import {
    ChildrenIdCardGetterInterface, AsyncChildrenPartInstanceInfoResult,
    ChildrenPartInstanceInfoInterface, AsyncResultReason, DataSessionInterface,
    InstanceMetadataInterface, DocumentContentInterface, WorkingSetInterface
} from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;
// created previously
let lWorkingSet : WorkingSetInterface;
// the `part instance id` to get
let lPartInstanceId : number;

// create an ChildrenIdCardGetter
const lChildrenIdCardGetterInterface : ChildrenIdCardGetterInterface = lDataSession.createChildrenIdCardGetter();

const retrieveIdCard = async () : Promise<void> =>
{
    // trigger the retrieval
    const lResult : AsyncChildrenPartInstanceInfoResult = await lChildrenIdCardGetterInterface.asyncRetrieveChildrenIdCard(lPartInstanceId, lWorkingSet);

    if (lResult.reason !== AsyncResultReason.ARR_Success || lResult.value === undefined)
    {
        // do nothing in case of error
        // perhaps some GUI code ?
        return;
    }
    const lPartInstanceInfos : Array<ChildrenPartInstanceInfoInterface> = lResult.value;
    // we required only one `part instance`, as such, only one result should be retrieved
    // iterate over the instantiation chain, but take the first chain since one `part instance` retrieved
    const lCurrentChildren : ChildrenPartInstanceInfoInterface = lPartInstanceInfos[0];

    // iterate over the children metadata infos
    const lAllInstanceMetadata : Array<InstanceMetadataInterface> = lCurrentChildren.getChildrenInstanceInfos();
    // number of items 
    const lNbChildren : number = lAllInstanceMetadata.length;
    if (lNbChildren <= 0)
    {
        console.log('this part instance is a leaf');
        return;
    }
    // take the last child
    const lChildInstanceOffset : number = lNbChildren - 1;
    const lLastChildInstanceInfos : InstanceMetadataInterface = lAllInstanceMetadata[lChildInstanceOffset];
    // we get the `part` metadata of the last child of the `part instance`
    const lPartMetadataDocuments : Array<DocumentContentInterface> = lLastChildInstanceInfos.getPartMetadataDocuments();

    if (lPartMetadataDocuments.length === 0)
    {
        console.log('this part instance has no part metadata documents');
        return;
    }
    // and we only care with the first document, but many documents may be attached
    const lPartMetadata : Object = lPartMetadataDocuments[0].getDocumentContent();
    // some fancy output
    console.log(JSON.stringify(lPartMetadata));

    // get the visibility info in order to get information about the `part instance`
    if (lLastChildInstanceInfos.isDisplayable())
    {
        console.log('the last child of the part instance is displayable');
    }
};

retrieveIdCard();

Copy

Please make sure the destination browser supports promises before using async calls.

See

• ChildrenIdCardGetterInterfaceSignal
• ChildrenPartInstanceInfoInterface
• InstanceMetadataInterface