Class DataModel

Represents an entity-relationship data model.

This model is:

Created using Data.createModel.
Stored in Data.models.
Composed of DataObjects, Relationships, PropertySets, and Properties.
Capable of importing and exporting various file formats.
Supports traversal and search of the data structure.
Can be built programmatically.

For detailed usage, refer to @xeokit/sdk/data.

Hierarchy (View Summary)

Component
- DataModel

Properties

`Optional`author

author?: string

The model author, if available.

built

built: boolean

Indicates if this DataModel has been built.

Set true by DataModel.build.
Subscribe to updates using DataModel.onBuilt and Data.onModelCreated.

`Optional`createdAt

createdAt?: string

The date the model was created, if available.

`Optional`creatingApplication

creatingApplication?: string

The application that created the model, if available.

`Readonly`data

data: Data

The Data that contains this DataModel.

destroyed

destroyed: boolean

True once this Component has been destroyed.

Don't use this Component if this is true.

`Protected`dirty

dirty: boolean

`Readonly`id

id: string

Unique ID of this DataModel.

DataModels are stored against this ID in Data.models.

`Optional`name

name?: string

The model name, if available.

objects

objects: { [key: string]: DataObject }

The DataObjects in this DataModel, mapped to DataObject.id.

DataObjects have globally-unique IDs and will also be stored in Data.objects.

objectsByType

objectsByType: { [key: string]: { [key: string]: DataObject } }

The DataObjects in this DataModel, mapped to DataObject.type, sub-mapped to DataObject.id.

`Optional`projectId

projectId?: string | number

The project ID, if available.

`Readonly`propertySets

propertySets: { [key: string]: PropertySet }

ThePropertySets in this DataModel, mapped toPropertySet.id.

PropertySets have globally-unique IDs and will also be stored in Data.propertySets.

relationships

relationships: Relationship[]

The Relationships in this DataModel.

The Relationships can be between DataObjects in different DataModels, but always within the same Data.

`Optional`revisionId

revisionId?: string | number

The revision ID, if available.

rootObjects

rootObjects: { [key: string]: DataObject }

The root DataObjects in this DataModel, mapped to DataObject.id.

This is the set of DataObjects in this DataModel that are not the related participant in any Relationships, where they have no incoming Relationships and their DataObject.relating property is empty.

`Optional`schema

schema?: string

The model schema version, if available.

`Readonly`typeCounts

typeCounts: { [key: string]: number }

The count of each type of DataObject in this DataModel, mapped to DataObject.type.

Methods

build

build(): Promise<DataModel>
Finalizes this DataModel, making it ready for use.
- Triggers the following events to notify subscribers:
  - DataModel.onBuilt
  - Data.onModelCreated
- Sets DataModel.built to true.
- Can only be called once per DataModel.
- Once built, no additional components can be created within this DataModel.
Usage Example
```
dataModel.onBuilt.subscribe(() => {
    // The DataModel is built and ready for use
});

data.onModelCreated.subscribe((dataModel) => {
    // Another way to listen for DataModel readiness
});

const result = dataModel.build();

if (result instanceof SDKError) {
    console.error(result.message);
} else {
    // Success
}
```
See @xeokit/sdk/data for more details.
Returns Promise<DataModel>
Throws
SDKError if:
- The DataModel has already been built.
- The DataModel has been destroyed.
- Defined in packages/sdk/src/data/DataModel.ts:471

`Protected`clean

clean(): void
Forces this component to action any deferred state updates.

Returns void
Inherited from Component.clean
- Defined in packages/sdk/src/core/Component.ts:119

`Protected`cleanIfDirty

cleanIfDirty(): void
Gives this component an opportunity to action any defered state updates.

Returns void
Inherited from Component.cleanIfDirty
- Defined in packages/sdk/src/core/Component.ts:109

createObject

createObject(dataObjectParams: DataObjectParams): SDKError | DataObject

Creates a new DataObject and registers it within the DataModel and Data.

The new DataObject is stored in DataModel.objects and Data.objects.
Triggers an event via Data.onObjectCreated.
DataObject IDs are globally unique. If a DataObject with the given ID already exists in the same Data, it will be reused and shared across DataModels rather than creating a duplicate.
This behavior enables xeokit to support federated data models.

Usage Example

const myDataObject = dataModel.createObject({
    id: "myDataObject",
    type: BasicEntity, // @xeokit/basictypes!basicTypes
    name: "My Object",
    propertySetIds: ["myPropertySet"]
});

const myDataObject2 = dataModel.createObject({
    id: "myDataObject2",
    name: "My Other Object",
    type: BasicEntity,
    propertySetIds: ["myPropertySet"]
});

if (myDataObject instanceof SDKError) {
    console.error(myDataObject.message);
} else if (myDataObject2 instanceof SDKError) {
    console.error(myDataObject2.message);
} else {
    // Success
    const gotMyDataObject = dataModel.objects["myDataObject"];
    const gotMyDataObjectAgain = data.objects["myDataObject"];
}

See @xeokit/sdk/data for more details.

Parameters

dataObjectParams: DataObjectParams
Configuration parameters for the new DataObject.

Returns SDKError | DataObject

DataObject on success.

createPropertySet

createPropertySet(propertySetCfg: PropertySetParams): SDKError | PropertySet

Creates a new PropertySet and registers it within the DataModel and Data.

The new PropertySet is stored in DataModel.propertySets and Data.propertySets.
PropertySet IDs are globally unique. If a PropertySet with the given ID already exists in the same Data, it will be reused and shared across DataModels instead of creating a duplicate.
A PropertySet ID must be unique within a single DataModel but can be shared between multiple DataModels.

Usage Example

const propertySet = dataModel.createPropertySet({
    id: "myPropertySet",
    name: "My properties",
    properties: [
        {
            name: "Weight",
            value: 5,
            type: "",
            valueType: "",
            description: "Weight of a thing"
        },
        {
            name: "Height",
            value: 12,
            type: "",
            valueType: "",
            description: "Height of a thing"
        }
    ]
});

if (propertySet instanceof SDKError) {
    console.error(propertySet.message);
} else {
    // PropertySet successfully created
}

See @xeokit/sdk/data for more details.

Parameters

propertySetCfg: PropertySetParams
Configuration parameters for the new PropertySet.

Returns SDKError | PropertySet

PropertySet on success.

createRelationship

createRelationship(
relationshipParams: RelationshipParams,
): SDKError | Relationship
Creates a new Relationship between two existing DataObjects.
- A Relationship consists of a relating DataObject and a related DataObject.
- The relating and related DataObjects can belong to different DataModels, provided both DataModels exist within the same Data. This enables xeokit to support federated models.
- The created Relationship is stored in:
  - DataModel.relationships,
  - DataObject.related on the relating DataObject, and
  - DataObject.relating on the related DataObject.
Usage Example
```
const myRelationship = dataModel.createRelationship({
    type: BasicAggregation,  // @xeokit/basictypes!basicTypes
    relatingObjectId: "myDataObject",
    relatedObjectId: "myDataObject2"
});

if (myRelationship instanceof SDKError) {
    console.error(myRelationship.message);
} else {
    // Success
    const myDataObject = dataModel.objects["myDataObject"];
    const myDataObject2 = dataModel.objects["myDataObject2"];

    const gotMyRelationship = myDataObject.related[BasicAggregation][0];
    const gotMyRelationshipAgain = myDataObject2.relating[BasicAggregation][0];
}
```
See @xeokit/sdk/data for more details.
Parameters
- relationshipParams: RelationshipParams
  Configuration parameters for the new Relationship.
Returns SDKError | Relationship
Relationship on success.
- Defined in packages/sdk/src/data/DataModel.ts:407

destroy

destroy(): void | SDKError
Destroys this DataModel.

This method performs the following actions:
- Fires an event via DataModel.onDestroyed and Data.onModelDestroyed.
- Can only be called once on a DataModel.
- After destruction, no more components can be created in the DataModel.
- It is safe to call this method even if the DataModel has not yet been built.
For detailed usage, refer to @xeokit/sdk/data.
Returns void | SDKError
void
- If the operation is successful.
Overrides Component.destroy
- Defined in packages/sdk/src/data/DataModel.ts:611

`Protected`error

error(message: string): void
Protected
Logs an error for this component to the JavaScript console.

The console message will have this format: [ERROR] [<component type> =<component id>: <message>
Parameters
- message: string
  The error message to log
Returns void
Inherited from Component.error
- Defined in packages/sdk/src/core/Component.ts:95

fromParams

fromParams(dataModelParams: DataModelContentParams): void | SDKError
Adds components from the specified DataModelParams to the data model.

For detailed usage, refer to @xeokit/sdk/data.
Parameters
- dataModelParams: DataModelContentParams
  The parameters to configure and populate the data model.
Returns void | SDKError
void
- If the operation is successful.
- Defined in packages/sdk/src/data/DataModel.ts:502

`Protected`log

log(message: string): void
Protected
Logs a message for this component.

The message will have this format: [LOG] [<component type> <component id>: <message>
Parameters
- message: string
  The message to log
Returns void
Inherited from Component.log
- Defined in packages/sdk/src/core/Component.ts:71

`Protected`setDirty

setDirty(): void
Flags this component as having a defered state updates it needs to perform.

Returns void
Inherited from Component.setDirty
- Defined in packages/sdk/src/core/Component.ts:102

toParams

toParams(): SDKError | DataModelParams
Gets this DataModel as a DataModelParams.

Returns SDKError | DataModelParams
- Defined in packages/sdk/src/data/DataModel.ts:529

`Protected`warn

warn(message: string): void
Protected
Logs a warning for this component to the JavaScript console.

The console message will have this format: [WARN] [<component type> =<component id>: <message>
Parameters
- message: string
  The warning message to log
Returns void
Inherited from Component.warn
- Defined in packages/sdk/src/core/Component.ts:83

Events

`Readonly`onBuilt

onBuilt: EventEmitter<DataModel, null>

Emits an event when the DataModel has been built.

The DataModel is built using DataModel.build.
DataModel.built indicates if the DataModel is currently built.
Don't create anything more in this DataModel once it's built.

onDestroyed

onDestroyed: EventEmitter<Component, null>

Emits an event when the Component has been destroyed.

Class DataModel

Hierarchy (View Summary)

Index

Properties

Methods

Events

Properties

Optionalauthor

built

OptionalcreatedAt

OptionalcreatingApplication

Readonlydata

destroyed

Protecteddirty

Readonlyid

Optionalname

objects

objectsByType

OptionalprojectId

ReadonlypropertySets

relationships

OptionalrevisionId

rootObjects

Optionalschema

ReadonlytypeCounts

Methods

build

Usage Example

Returns Promise<DataModel>

Throws

Protectedclean

Returns void

ProtectedcleanIfDirty

Returns void

createObject

Usage Example

Parameters

Returns SDKError | DataObject

createPropertySet

Usage Example

Parameters

Returns SDKError | PropertySet

createRelationship

Usage Example

Parameters

Returns SDKError | Relationship

destroy

Returns void | SDKError

Protectederror

Parameters

Returns void

fromParams

Parameters

Returns void | SDKError

Protectedlog

Parameters

Returns void

ProtectedsetDirty

Returns void

toParams

Returns SDKError | DataModelParams

Protectedwarn

Parameters

Returns void

Events

ReadonlyonBuilt

onDestroyed

Settings

On This Page

`Optional`author

`Optional`createdAt

`Optional`creatingApplication

`Readonly`data

`Protected`dirty

`Readonly`id

`Optional`name

`Optional`projectId

`Readonly`propertySets

`Optional`revisionId

`Optional`schema

`Readonly`typeCounts

`Protected`clean

`Protected`cleanIfDirty

`Protected`error

`Protected`log

`Protected`setDirty

`Protected`warn

`Readonly`onBuilt