Loading Units and Elements

3 minutes to read Download PDF Edit

After finding your unit or element you have to obtain it in its fully-loaded form to be able to change it, or to analyze the information which is not available in just the interface. Changing an element in interface form will result in an exception being thrown.

Each element (whether in interface or full form) has an isLoaded property and load and asLoaded functions. The isLoaded property indicates whether this element is fully loaded already. In practice you should never need to test its value, but simply make sure that you always load a unit/element first.

The load interface loads the element or unit fully. This process is asynchronous, so the fully-loaded object will be passed to the callback passed to the load function. In javascript terms, the fully-loaded object is actually the very same instance as the interface, but it is passed into the callback as parameter nonetheless, for convenience. The parameter is upcast to the full, non-interface type so that type system (e.g., that of TypeScript or your smart IDE) allows access to all members. load always fetches the complete unit, even if you only called it on a specific element. Load always returns units from the local cache if they have already been loaded before.

Since a unit might already have been loaded before, you are also allowed to use asLoaded on an element/unit without arguments in which case it just acts as an upcast from the interface type to the full type. But beware: if the unit that contains that element was not loaded before, an exception will be thrown.

The following (slightly) contrived example demonstrates the behavior of load. The type information is made explicit in this example for demonstration purposes, but you can just omit this code since the TypeScript compiler will infer it. Note that this example is contrived: a normal flow would be to call load on the domainModel and work with the fully-loaded domain model inside its callback.

import {domainmodels} from "mendixmodelsdk";

// at first, only interfaces are available:
var domainModel : domainmodels.IDomainModel = model.allDomainModels()[0];
var entity1Interface : domainModels = domainModel.entities[0];

console.log(entity1Interface.isLoaded); // ==> false

entity1Interface.load((entity1 : domainmodels.Entity) => {
	// entity1 is now the fully-loaded, upcast version of entityInterface1
	console.log(entity1.isLoaded); // ==> true
	console.log(entity1Interface === entity1); // ==> true

	// loading the entity actually loaded the complete domain model unit:
	console.log(domainModel.isLoaded); // prints true
	// ... so we can upcast safely:
	var fullDomainModel : domainmodels.DomainModel = domainModel.asLoaded();

	// In fully-loaded units, all sub elements also have the fully-loaded types,
	// while in interfaces all sub objects are interfaces as well.
	var entity2 : domainmodels.Entity = fullDomainModel.entities[1];
});

Continue your learning path with Generating code from the model.