File "theater_seat.ef" contains a software representation of a theater seat, defining several fields, but with no collection in sections DB, LOGIC and UI, to keep the example simple. Some notes:

• Line 12 shows an example of a dynamic array of strings (purchaser);

• Line 13 shows an example of an imported type definition (customization): library entity "strings.ef" contains a fixed-size string field called description;

• Lines 16-20 define enumeration symbols and values for field type;

• Lines 22-23 define input parameters (number) and return value (type) of function cur_type;

• Lines 25-26 define a validity range for field price;

• Lines 28-29 define input parameters (type and purchaser) and return value (price) of function cur_price.

    1      theater_seat "Theater seat"
    2      | Entity representing a theater seat,
    3      | actually an example of usage of built-in types
    4      
    5      unique_id               number                  "Seat number"
    6      bool                    available               "Available"
    7      enum                    type                    "Seat type"
    8      function                cur_type                "Curr. seat type"
    9      float                   price                   "Price range"
   10      | Price range expressed in USD
   11      function                cur_price               "Curr. price"
   12      string                  purchaser[dyn]          "Purchaser"
   13      strings.description     customization           "Customization"
   14      
   15      ----------------------- DEFS
   16      type:
   17         stalls               'S'             "Stalls"
   18         pit                  'P'             "Pit"
   19         box                  'B'             "Box"
   20         gallery              'G'             "Gallery"
   21      
   22      cur_type:
   23         number -> type
   24      
   25      price:
   26         0/7000
   27      
   28      cur_price:
   29         type, purchaser -> price
   30      ----------------------- DB
   31      ----------------------- LOGIC
   32      ----------------------- UI
   33      ----------------------- ADJUST
	       

This entity embeds on line 5 an address, which is then used in collections DB.table (lines 26-27), LOGIC.class (lines 31-32) and UI.full_view (line 34). Zeroes (0) in function definitions (lines 18, 21 and 24) mean "void": functions phone_call and cell_call are in fact subroutines, or utility methods, without parameters. Lines 45 and 46 contain the LOGIC implementation of functions phone_call and cell_call.

    1      customer "Customer"
    2      | A company/organization, its address, and a contact person
    3      
    4      strings.long_string     company_name    "Company name"
    5      address                 address         "Address"
    6      person                  contact         "Contact person"
    7      function                call_customer   "Call customer"
    8      enum                    call_mode       "Call modality"
    9      function                phone_call      "Call cust. by phone"
   10      function                cell_call       "Call cust. by cell."
   11      
   12      ----------------------- DEFS
   13      call_mode:
   14         by_phone     "By phone"
   15         by_cell      "By cell"
   16      
   17      call_customer:
   18         call_mode -> 0
   19      
   20      phone_call:
   21         0 -> 0
   22      
   23      cell_call:
   24         0 -> 0
   25      ----------------------- DB
   26      table:
   27         company_name, address, contact
   28      pkey:
   29         company_name
   30      ----------------------- LOGIC
   31      class:
   32         company_name, address, contact, call_customer, phone_call, cell_call
   33      ----------------------- UI
   34      full_view:
   35      company_name
   36      address
   37      contact
   38      phone_call
   39      cell_call
   40      
   41      compact_view:
   42      company_name, contact
   43      ----------------------- ADJUST
   44      DB.table.create = "true"
   45      LOGIC.class.phone_call.code = "callCustomer(BY_PHONE);"
   46      LOGIC.class.cell_call.code = "callCustomer(BY_CELL);"
	       

The database table customer embeds the (virtual) table address, as shown on lines 6-11. In particular, line 11 is the (virtual) database table of entity country, which is embedded by address.

On the side, lines 13-17 derive from field contact, which is an embedded person, and the constraint clause of line 18 corresponds to collection customer.DB.pkey.

Finally, by project convention, database column identifiers should not contain underscores "_". Such project-wide conventions are centrally implemented in molds and can be quickly changed and applied to all generatable files of all project entities.

    1      --
    2      -- This SQL script created by somusar/SoProMach[tm]
    3      --
    4      
    5      create table customer (
    6          companyname               varchar(80)    not null,
    7          street                    varchar(80)    not null,
    8          city                      varchar(80)    not null,
    9          state                     varchar(40)        null,
   10          zip                       varchar(20)    not null,
   11          country                   varchar(40)    not null,
   12          website                   varchar(80)        null,
   13          contactlastname           varchar(40)    not null,
   14          contactfirstname          varchar(40)    not null,
   15          contactemailaddr          varchar(60)    not null,
   16          contacttelephone          varchar(40)        null,
   17          contactcellphone          varchar(40)        null,
   18          constraint pk_customer    primary key    (companyname)
   19      )
   20      ;
   21      
	       

The Java class Customer embeds on line 24 class Address, whose definition is imported on line 14. Lines 76 and 85 directly derive from section ADJUST (lines 39 and 40) of the entity file.

    1      /*
    2       * This Java class generated by somusar/SoProMach[tm].
    3       */
    4      
    5      package com.somusar.entdemo.business;
    6      
    7      /**
    8       *   Class Customer:
    9       *
   10       *   A company/organization, its address, and a contact 
   11       *   person.
   12       */
   13      
   14      import com.somusar.entdemo.location.Address;
   15      import com.somusar.entdemo.persons.Person;
   16      
   17      public class Customer {
   18      
   19          // Map enum 'Call modality' onto an int with a set of values
   20          public final int BY_PHONE           = 0; // By phone
   21          public final int BY_CELL            = 1; // By cell
   22      
   23          private String       companyName;        
   24          private Address      address;            
   25          private Person       contact;            
   26          
   27          /*
   28           *   Get methods
   29           */
   30      
   31          public String getCompanyName() {
   32              return companyName;
   33          }
   34      
   35          public Address getAddress() {
   36              return address;
   37          }
   38      
   39          public Person getContact() {
   40              return contact;
   41          }
   42      
   43          /*
   44           *   Set methods
   45           */
   46      
   47          public void setCompanyName( String companyName ) {
   48              this.companyName = companyName;
   49          }
   50      
   51          public void setAddress( Address address ) {
   52              this.address = address;
   53          }
   54      
   55          public void setContact( Person contact ) {
   56              this.contact = contact;
   57          }
   58      
   59          /**
   60           *   Method 'Call customer'
   61           */
   62      
   63          public void callCustomer (
   64                          int callMode
   65                 )
   66          {
   67              // insert your Java method code here
   68          }
   69      
   70          /**
   71           *   Method 'Call cust. by phone'
   72           */
   73      
   74          public void phoneCall ()
   75          {
   76              callCustomer(BY_PHONE);
   77          }
   78      
   79          /**
   80           *   Method 'Call cust. by cell.'
   81           */
   82      
   83          public void cellCall ()
   84          {
   85              callCustomer(BY_CELL);
   86          }
   87      
   88      }
	       

The C++ class Customer embeds on line 43 class Address whose definition is #included on line 28. Lines 97 and 106 directly derive from section ADJUST (lines 39 and 40) of the entity file.

    1      #ifndef __Customer__
    2      #define __Customer__
    3      
    4      /*
    5       *   -----------------------------------------------------------------
    6       *   Class Customer
    7       *
    8       *   A company/organization, its address, and a contact 
    9       *   person.
   10       *   -----------------------------------------------------------------
   11       * 
   12       *   [This header generated by somusar/SoProMach[tm].]
   13       */
   14      
   15      
   16      
   17      #ifndef __dummy_classes__
   18      #   define __dummy_classes__
   19      
   20      /* Dummy declarations, just for compiling.  */
   21      class Collection { char s[100]; };
   22      class Object     { char s[100]; };
   23      
   24      #endif
   25      
   26      #include <String.h>
   27      
   28      #include "location/Address.h"
   29      #include "persons/Person.h"
   30      
   31      class Customer {
   32      
   33      public:
   34      
   35          enum enumCallMode {
   36              BY_PHONE                   = 0,      // By phone
   37              BY_CELL                    = 1       // By cell
   38          };
   39      
   40      private:
   41      
   42          String               companyName;        
   43          Address              address;            
   44          Person               contact;            
   45      
   46      public:
   47      
   48          /*
   49           *   Get methods
   50           */
   51      
   52          String getCompanyName() {
   53              return companyName;
   54          }
   55      
   56          Address getAddress() {
   57              return address;
   58          }
   59      
   60          Person getContact() {
   61              return contact;
   62          }
   63      
   64          /*
   65           *   Set methods
   66           */
   67      
   68          void setCompanyName( String companyName ) {
   69              this->companyName = companyName;
   70          }
   71      
   72          void setAddress( Address address ) {
   73              this->address = address;
   74          }
   75      
   76          void setContact( Person contact ) {
   77              this->contact = contact;
   78          }
   79      
   80          /*
   81           *   Method 'Call customer'
   82           */
   83      
   84          void callCustomer (
   85                          int callMode
   86                 )
   87          {
   88              // insert your C++ method code here
   89          }
   90      
   91          /*
   92           *   Method 'Call cust. by phone'
   93           */
   94      
   95          void phoneCall ()
   96          {
   97              callCustomer(BY_PHONE);
   98          }
   99      
  100          /*
  101           *   Method 'Call cust. by cell.'
  102           */
  103      
  104          void cellCall ()
  105          {
  106              callCustomer(BY_CELL);
  107          }
  108      
  109      };
  110      
  111      #endif /* __Customer__ */
	       

Sisendel implicitly defines one collection for section CORE, namely CORE.employee (also referred to as CORE.entity), which consists of all data fields in their definition order, in this example from person to empl_id. Beyond that, this entity explicitly defines six collections, described in the following table.

Table 4 - Collections in employee

Identifier	Defined on lines	Members	Description
DB.table	22-23	empl_id person info dept position salary	Database table columns
DB.pkey	24-25	empl_id	Database table primary key
LOGIC.class	27-28	empl_id info dept position salary	Object-oriented class members
LOGIC.parent	29-30	person	Object-oriented parent class
UI.full_view	32-38	empl_id person dept position salary info	User-interface edit/view form
UI.compact_view	39-40	empl_id person position	User-interface reference view

    1      employee "Employee"
    2      | An employee, some related information, and the department s/he works in
    3      
    4      person                  person          "Person"
    5      person_info             info            "Pers. info"
    6      link department         dept            "Department"
    7      enum                    position        "Position"
    8      float                   salary          "Salary ($)"
    9      unique_id               empl_id         "Employee id."
   10      
   11      ----------------------- DEFS
   12      salary:
   13         0/1000000
   14      position:
   15         president            "President"
   16         vice_president       "Vice-president"
   17         manager              "Manager"
   18         admin                "Admin"
   19         sales_rep            "Sales rep."
   20         engineer             "Engineer"
   21      ----------------------- DB
   22      table:
   23         empl_id, person, info, dept, position, salary
   24      pkey:
   25         empl_id
   26      ----------------------- LOGIC
   27      class:
   28         empl_id, info, dept, position, salary
   29      parent:
   30         person
   31      ----------------------- UI
   32      full_view:
   33      empl_id
   34      person
   35      dept
   36      position
   37      salary
   38      info
   39      
   40      compact_view:
   41      empl_id, person, position
   42      ----------------------- ADJUST
   43      DB.table.create = "true"
	       

Lines 1-3 define three fields in terms of fields whose definition is imported from library entity strings. Lines 6 shows an example of field description comment, that can be used in molds to carry it over into the generated files. Lines 4, 7, 8 and 9 define fields as references to other entities: in this entity file it is assumed that somewhere in either the project or library tree there are three entity files respectively called "customer.ef", "employee.ef", and "department.ef".

    1      strings.name            proj_name       "Project name"
    2      strings.id              proj_id         "Project id."
    3      strings.description     descr           "Description"
    4      link customer           customer        "Customer"
    5      float                   budget          "Budget (K$)"
    6      | Project budget unit is 1,000 dollars
    7      list employee           team_members    "Team members"
    8      link employee           manager         "Proj. manager"
    9      link department         department      "Department"
   10      bool                    internal        "Internal"
   11      thing                   plan            "Proj. plan"
   12      function                cur_status      "Current proj. status"
   13      enum                    status          "Proj. status"
	       

This entity defines a set of string identifiers that should be standard across one or more projects involving one or more development teams. This approach can ensure consistency for example across all database tables, or middleware messages, or user interfaces, that make use of such common data items as user_id or email. It should be noted that:

• strings is an abstract entity, as it defines no collections at all, apart from the list of CORE fields: strings has neither a database table, nor a logic class, nor a usage interface defined for it;

• Each field has a constant cardinality, or length, as all fields are strings; for example on line 4 long_string has a cardinality of 80.

    1      strings "Project-wide strings definitions"
    2      | Various types of strings, standardized across the project
    3      
    4      string  long_string[80]         "Long string"
    5      string  mid_string[40]          "Mid string"
    6      string  short_string[20]        "Short string"
    7      string  very_long_string[255]   "Very long string"
    8      string  password[40]            "Password"
    9      string  status[2]               "Status"
   10      string  id[10]                  "Identifier"
   11      string  user_id[80]             "User id."
   12      string  name[40]                "Name"
   13      string  telephone[40]           "Tel. number"
   14      string  email[60]               "Email address"
   15      string  description[200]        "Short description"
   16      string  ssn[40]                 "Social security number"
   17      string  pathname[1024]          "Pathname"
   18      
   19      DEFS
   20      DB
   21      LOGIC
   22      UI
   23      ADJUST