The following code shows an example of createXXX methods generated to cover the set of entities defined in the tutorial:

public interface CapacityPlanning extends DbDomCollector {
  Activity createActivity();
  GeneIssue createGeneIssue();
  GeneParameter createGeneParameter();
  Precedence createPrecedence();
  Requirement createRequirement();
  Resource createResource();
  ResourceCapacity createResourceCapacity();
  ResourceUsagePerDay createResourceUsagePerDay();
  Schedule createSchedule();
  SolutionSummary createSolutionSummary();
  ...
}

To create a resource, one would declare the following:

Resource res1 = coll.createResource();

Each instance is linked with its collector which can be accessed using the getCollector() method.

res1.getCollector() == coll; // TRUE

The following code shows an example of createXXX methods generated to cover the set of entities defined in the tutorial:

class CapacityPlanning(DbDomCollector):
  def create_activity(self) -> Acticity:
    pass
  def create_gene_issue(self) -> GeneIssue:
    pass
  def create_gene_parameter(self) -> GeneParameter:
    pass
  def create_precedence(self) -> Precedence:
    pass
  def create_requirement(self) -> Requirement:
    pass
  def create_resource(self) -> Resource:
    pass
  def create_resource_capacity(self) -> ResourceCapacity:
    pass
  def create_resource_usage_per_day(self) -> ResourceUsagePerDay:
    pass
  def create_schedule(self) -> Schedule:
    pass
  def create_solution_summary(self) -> SolutionSummary:
    pass

To create a resource, one would declare the following:

Resource res1 = coll.createResource();

Each instance is linked with its collector which can be accessed using the getCollector() method.

res1.getCollector() == coll; // TRUE

In Java, the JDL declaration translates in the following Resource and ResourceCapacity interfaces:

public interface Resource extends DbDomObject {
  ResourceCapacity getCapacity();
  CapacityPlanning getCollector();
  String getId();
  String getName();
  void setCapacity(ResourceCapacity obj);
  void setId(String value);
  void setName(String value);
}

public interface ResourceCapacity extends DbDomObject {
  CapacityPlanning getCollector();
  int getQuantity();
  Resource getResource();
  boolean isSetQuantity();
  void setQuantity(int value);
  void setResource(Resource obj);
  void unsetQuantity();
}

For example, to set the attributes of an instance, one would call

  Resource res1 = coll.createResource();
  res1.setId( "MyFirstResourceId" );
  res1.setName( "MyFirstResourceName" );

Relationships are managed in a similar way:

  ResourceCapacity capa1 = coll.createResourceCapacity();
  capa1.setQuantity(1);
  capa1.setResource(res1); // this automatically calls Resource.setResourceCapacity()
  res1.getResourceCapacity() == capa1; // true

  ResourceCapacity capa2 = coll.createResourceCapacity();
  capa2.setQuantity(2);
  res1.setResourceCapacity(capa2); // this automatically update the inverted relationships
  res1.getResourceCapacity() == capa2; // true
  capa1.getResource() == null; // true
  capa2.getResource() == res1; // true

In Python, the JDL declaration translates in the following Resource and ResourceCapacity interfaces:

class Resource(DbDomObject):
    def get_capacity(self) -> ResourceCapacity:
        pass
    def get_id(self) -> str:
        pass
    def get_name(self) -> str:
        pass
    def set_capacity(self, capacity: ResourceCapacity | None):
        pass
    def set_id(self, id_: str):
        pass
    def set_name(self, name: str | None):
        pass

class ResourceCapacity(DbDomObject, IndexKey):
    def get_quantity(self) -> int:
        pass
    def get_resource(self) -> Resource:
        pass
    def set_quantity(self, quantity: int | None):
        pass
    def set_resource(self, resource: Resource | None):
        pass

For example, to set the attributes of an instance, one would call

  res1 = coll.create_resource()
  res1.set_id( "MyFirstResourceId" )
  res1.set_name( "MyFirstResourceName" )

Relationships are managed in a similar way:

  capa1 = coll.create_resource_capacity()
  capa1.set_quantity(1)
  capa1.set_resource(res1) # this automatically calls Resource.set_resource_capacity()
  res1.get_resource_capacity() == capa1 # true

  capa2 = coll.create_resource_capacity()
  capa2.set_quantity(2)
  res1.set_resource_capacity(capa2) # this automatically update the inverted relationships
  res1.get_resource_capacity() == capa2 # true
  capa1.get_resource() == None # true
  capa2.get_resource() == res1 # true

Here are some examples of use of the API in Java:

  Resource res1 = coll.createResource(); // res1 is added to the collector instances
  1 == coll.getResource().size(); // is true

  res1.setId( "MyFirstResourceId" );    // res1 primary key is complete so can be accessed with getFromResource
  res1 == coll.getFromResource( "MyFirstResourceId" ); // is true

Instances can also be accessed through the list of all known instances.

public interface CapacityPlanning extends DbDomCollector {
  List<Resource> getResource();
  List<ResourceCapacity> getResourceCapacity();
  ...
}

Entities that are declared as single.row are accessed as singletons: the following JDL declaration

entity SolutionSummary {
  // DOM [single.row] : [true]
  start Instant,
  end Instant,
  timespan Integer
}

Will cause the following API to be generated:

public interface CapacityPlanning extends DbDomCollector {
  SolutionSummary getSolutionSummary();
  void setSolutionSummary(SolutionSummary value);
  ...
}

Here are some examples of use of the API in Python:

  res1 = coll.create_resource() # res1 is added to the collector instances
  1 == len(coll.get_all_resource()) # is True
  res1.set_id( "MyFirstResourceId" )    # res1 primary key is complete so can be accessed with find_resource_by_business_key
  res1 == coll.find_resource_by_business_key( "MyFirstResourceId" ) # is True

Instances can also be accessed through the list of all known instances.

class CapacityPlanning(DbDomCollector):
  def get_all_resource(self) -> FrozenSet[Resource]:
    pass
  def get_all_resource_capacity(self) -> FrozenSet[ResourceCapacity]:
    pass

Entities that are declared as single.row are accessed as singletons: the following JDL declaration

entity SolutionSummary {
  // DOM [single.row] : [true]
  start Instant,
  end Instant,
  timespan Integer
}

Will cause the following API to be generated:

class CapacityPlanning(DbDomCollector):
  def find_solution_summary(self) -> SolutionSummary | None:
    pass
  def set_solution_summary(self, solution_summary: SolutionSummary) -> SolutionSummary | None:
    pass