Ada_Code_GenerationAda Code Generation

A class in Rhapsody is represented as an Ada package, and produces a package specification and an optional package body in Ada. The name of the Ada package is the name of the class.

A simple class in Rhapsody.

    --++ class class_name
    package class_name is
    
        type class_name_t;
        type class_name_acc_t is access all class_name_t;
        type class_name_wide_acc_t is access all class_name_t'class;
        
        type class_name_t is tagged null record;
        
    private
     
    end class_name;
       

The generated Ada code for a simple class.

The name of the generated file is class_name.ads .

In addition, three new types are declared in the public part of the package specification - a tagged record type, and two optional access to that type.

The access types can be generated in different way. Some properties control these types generation.

• Ada_CG::Class::RecordTypeName : this property controls the name of the tagged record type.
• Ada_CG::Class::AccessTypeName : this property controls the name of the class access type.
• Ada_CG::Class::ClassWideAccessTypeName : this property controls the name of the class wide access type.
• Ada_CG::Class::GenerateAccessType : the GenerateAccessType property determines which access types are generated for the class. The possible values are as follows:
  • None - Access types are not generated.
  • Standard - An access type is generated.

    type class_name_acc_t is access class_name_t;
                      

  • General - General access types are generated.

    type class_name_acc_t is access all class_name_t;
                      

• Ada_CG::Class::GenerateClassWideAccessType : This property determines which Wide access types are generated for the class. The possible values are:
  • None - wide access types are not generated
  • Standard - a standard wide access type is generated

    type class_name_wide_acc_t is access class_name_t'class;
                      

  • General - general wide access types are generated

    type class_name_wide_acc_t is access all class_name_t'class;
                      

  • Constant - constant wide access types are generated

    type class_name_wide_acc_t is access constant class_name_t'class;
                          

The definition of this record type appears in the public part of the specification package where the record type is declared, but it could also appear in the private part by setting the “Ada_CG.Class.Visibility” property.

Controlling the location of the record type definition.

When a class inherits from another class, the record type for the subclass is an extension of the record type of the parent class.

Inheritance in Rhapsody.

    with Superclass;
    
    --++ class Subclass
    package Subclass is
    
      type Subclass_t is new Superclass.Superclass_t with private;
    
      type Subclass_acc_t is access Subclass_t;
    
    --Public Fields/Variables accessors ---------
      function get_my_Boolean (this : in Subclass_t) return Boolean;
        pragma inline (get_my_Boolean);

      procedure set_my_Boolean (this : in Subclass_t; value : in Boolean);
        pragma inline (set_my_Boolean);
    
    private
    
       type Subclass_t is new Superclass.Superclass_t with
       record
    
         -- Fields --
         my_Boolean : Boolean;    --++ attribute my_Boolean
    
       end record;
    
    end Subclass;
    
       

The package specification for a specialized class.

Notice that a “With” statement has been generated for the superclass in the package specification of the subclass.

A non-abstract class can have initialization code that is executed during elaboration of the associated package. In order to generate such code, you’ll need to edit the Ada_CG::Class::InitializationCode property for that class.

Setting the initialization code property for a class

    --++ class class_name
    package body class_name is
    
    --Functions/Procedures section ---------------------
      procedure myOperation (this : in out class_name_t) is
       begin
          null;
          --+[ operation myOperation()
    
          --+]
       end myOperation;
    
    begin
       null;
    end class_name;
       

Generated body for a class with initialization code

A static class is a class witch as only static attributes and operations. No tagged record type and no ”this” parameters are generated for this kind of class.

A Static class can be used for safety critical application.

setting IsStatic property for a class

abstract class and interface

A class can have the stereotype "abstract" or "interface". If Ada83 or Ada95 is selected, this will generate an abstract class record type. The class access type is generated in a different way than usual classes. It is a class wide access type by default.

                type object_t;
                type object_acc_t is access all object_t'Class;
                type object_t is abstract tagged null record;
               

The class access type can be generated as usual, by setting the property Ada_CG::Operation::VirtualMethodGenerationScheme to ClassWideOperations. In this case, the property Ada_CG::Class::GenerateAccessType can be used as usual.

                type object_t;
                type object_acc_t is access all object_t;
                type object_t is abstract tagged null record;
               

For Ada2005 and latest Ada version, "interface" stereotype generates an interface type. (See Ada2005 Code Generation section.)

By default, a mutator and accessor are created for each attribute.

When non-static attributes are added to a class, these attributes are added to the record type.

When non-static attributes are added to a package, these attributes are handled as static attributes.

Non-static attributes of a class.

--++ class class_name
package class_name is
    
    type class_name_t;    
    type class_name_acc_t is access all class_name_t;    

    type class_name_t is tagged    

    record

       -- Fields
        my_Boolean : Boolean;   --++ attribute my_Boolean
        my_Integer : Integer;   --++ attribute my_Integer
        
    end record;

    --Public Fields/Variables accessors ---------------
    function get_my_Boolean (this : in class_name_t) return Boolean;
      pragma inline (get_my_Boolean);
              
    procedure set_my_Boolean (this : in class_name_t; value : in Boolean);
      pragma inline (set_my_Boolean);
              
    function get_my_Integer (this : in class_name_t) return Integer;
      pragma inline (get_my_Integer);
              
    procedure set_my_Integer (this : in class_name_t; value : in Integer);
      pragma inline (set_my_Integer);

private
              
end class_name;
       

The package specification for non-static attributes.

Because accessor and mutator methods are created, a package body file is created with the name class_name.adb .

--++ class class_name
package body class_name is
    
    --Fields/Variables accessors ---------------
    function get_my_Boolean (this : in class_name_t) return Boolean is
    begin
        return this.my_Boolean;
    end get_my_Boolean;
              
    procedure set_my_Boolean (this : in class_name_t; value : in Boolean) is
    begin
        this.my_Boolean := value;
    end set_my_Boolean;
              
    function get_my_Integer (this : in class_name_t) return Integer is
    begin
        return this.my_Integer;
    end get_my_Integer;
              
    procedure set_my_Integer (this : in class_name_t; value : in Integer) is
    begin
        this.my_Integer := value;
    end set_my_Integer;

end class_name;
       

The package body for non-static attributes.

The record type now contains the two non-static attributes that were added in Rhapsody.

In addition, the attribute accessor and mutator operations contain a ‘this’ parameter that is used to pass in an instance of the type being affected. This is true for all non-static operations that are not for singleton classes.

The accessor and mutator are generated in the public part of the package specification by default, but they can be moved to private part by clicking the “Private” radio button on the features page.

Controlling the visibility of the accessor and mutator.

Attributes marked as static do not create record elements in classes, but instead are represented as variables in the Ada package.

These variables can be defined in the public or private part of the package specification, or in the package body, depending on the setting of property “Ada_CG.Attribute.Visibility”.

Static attributes of a class.

In this example, both attributes are marked as static. However, the attribute privateStaticInt is marked as private, which means that the accessors will appear in the private part of the package specification, and its property “Ada_CG.Attribute.Visibility” is set to “Private”, forcing the variable definition to appear in the private part as well.

--++ class class_name
package class_name is
    
    type class_name_t;    
    type class_name_acc_t is access all class_name_t;    

    type class_name_t is tagged null record;

    -- Public Variables/Constants ---------------
    public_Static_Boolean : Boolean;  --++ attribute public_Static_Boolean


    --Public Fields/Variables accessors ---------------
    function get_public_Static_Boolean return Boolean;
      pragma inline (get_public_Static_Boolean);
              
    procedure set_public_Static_Boolean (value : in Boolean);
      pragma inline (set_public_Static_Boolean);
              
private

    -- Private Variables/Constants ---------------
    private_Static_Integer : Integer;  --++ attribute private_Static_Integer


    --Private Fields/Variables accessors ---------------
    function get_private_Static_Integer return Integer;
      pragma inline (get_private_Static_Integer);
              
    procedure set_private_Static_Integer (value : in Integer);
      pragma inline (set_private_Static_Integer);
              
              
end class_name;
       

The package specification for static attributes.

--++ class class_name
package body class_name is
    
    --Fields/Variables accessors ---------------
    function get_private_Static_Integer return Integer is
    begin
        return private_Static_Integer;
    end get_private_Static_Integer;
              
    procedure set_private_Static_Integer (value : in Integer) is
    begin
        private_Static_Integer := value;
    end set_private_Static_Integer;

    function get_public_Static_Boolean return Boolean is
    begin
        return public_Static_Boolean;
    end get_my_Boolean;
              
    procedure set_public_Static_Boolean (value : in Boolean) is
    begin
        public_Static_Boolean := value;
    end set_public_Static_Boolean;
              
end class_name;
       

The package body for static attributes.

In Ada, declaration order is important. For example, a type declaration might depend on a constant that has to be declared before being used.

In order to provide some degree of control over the declaration order of attributes, the Ada_CG.Attribute.DeclarationPosition property can be used. The table below summarize the different values that this property can take and its effects on the attribute it is being applied.

Table 1 Ada_CG.Attribute.DeclarationPosition property values description

A few special cases:

• if the attributes have their Ada_CG.Attribute.Visibility property set to “Body”
• If the attributes are defined on a package
• If the Ada_CG.Class.Visibility property of the class they are defined in has a different setting

These attributes then have no actual class record around which they can be positioned. In such cases, they are generated around a “virtual” class record location that gives a declaration order as close as possible to the one that would exist if there was a class record definition in the section the attributes are being generated into.

Static attributes of a class with overridden declarationPosition property

Setting the DeclarationPosition for a static attribute to BeforeClassRecord

Setting the DeclarationPosition for a static attribute to AfterClassRecord

--++ class class_name
package class_name is
    
    type class_name_t;    
    type class_name_acc_t is access all class_name_t;    

    -- Public Variables/Constants ---------------
    public_Static_Boolean_Before_Record : Boolean;  --++ attribute public_Static_Boolean_Before_Record

    type class_name_t is tagged null record;

    -- Public Variables/Constants ---------------
    public_Static_Integer_After_Record : Integer;  --++ attribute public_Static_Integer_After_Record

    --Public Fields/Variables accessors ---------------
              
private

              
end class_name;
       

Generated code for static attributes with overridden DeclarationPosition property

The attribute definitions can be entered directly in the “Ada declaration” field instead of choosing a predefined type. In this case, it might be necessary to set the two properties “Ada_CG.Attribute.AccessorGenerate” and “Ada_CG.Attribute.MutatorGenerate” to false so that the default accessors are not generated.

Non-static attribute definition.

Static attribute definition.

--++ class class_name
package class_name is
    
    type class_name_t;    
    type class_name_acc_t is access all class_name_t;    

    type class_name_t is tagged

    record

      -- Fields --
      -- This is a string attribute
      my_String : Integer := "testtest";  --++ attribute my_String

    end record;

    -- Public Variables/Constants ---------------
    -- This is a public string variable
    my_Static_String : String (1..8) := "stpublic";  --++ attribute my_Static_String

    --Public Fields/Variables accessors ---------------
              
private

              
end class_name;
       

The package specification for non-predefined type attributes.

Access to attributes can be guarded by setting the “isGuarded” property. There are two possible settings. One setting is “all” which guards both the accessor and mutator of the attribute. The other setting is “mutator” which will only guard the mutator.

Guarding an Attribute.

When an attribute is guarded, a mutex is used to synchronize access to the attribute. Depending on the value of the “Ada_CG.<Class|Package>.UseAda83Framework property of the attribute owner, an Ada83 task based Mutex or an Ada95 protected object based Mutex will be used.

By setting a class instance attribute or a struct attribute stereotype to <<Discriminant>>, it is possible to generate a discriminated record type.

Modeling a class with a <<Discriminant>> attribute

Defining an unconstrained array type

Setting an attribute stereotype to <<Discriminant>>

Defining an attribute with a type definition based on the class record type discriminant

--++ class class_0
package class_0 is
    
    type class_0_t (
      Size : Integer  --++ attribute Size
    );    
    type class_0_acc_t is access all class_0_t;    

    --Public types -------------------------------------
    type Int_Array is array(Integer range <>) of Integer;

    type class_0_t (
      Size : Integer  --++ attribute Size
    )is tagged

    record

      -- Fields --
      My_Int_Array : Int_Array(1..Size);  --++ attribute My_Int_Array

    end record;

private

              
end class_0;
       

Generated code for a class with a discriminant

Note that no setter is generated for attributes with a <<Discriminant>> stereotype, no matter the setting of its Ada_CG.Attribute.MutatorGenerate property.

If the attribute is a <<Discriminant>> non-static attribute and it has an initial value and it is defined as a <<Discriminant>> attribute in at least one of its parent classes then the attribute may be generated as a constraint on the parent discriminant, as a new discriminant hiding the one from the parent or as both.

This behavior is controlled by using the “Ada_CG.Attribute.RedefiningDiscriminantPolicy “ and “Ada_CG.Attribute.ParentDiscriminantValue” properties.

Class with overriding and redefining discriminant

Overriding discriminant

Overriding and redefining discriminant

Redefining discriminant

With Base_Class;
    
--++ Class Derived_Class
package Derived_Class is
    
    type Derived_Class_t (
      overridden_and_redefined : Integer;  --++ attribute overridden_and_redefined
      redefined : Integer  --++ attribute redefined
    );    
    type Derived_Class_acc_t is access all Derived_Class_t;    

    type Derived_Class_t (
      overridden_and_redefined : Integer;  --++ attribute overridden_and_redefined
      redefined : Integer  --++ attribute redefined
    ) is new Base_Class.Base_Class_t(
      overridden => 10, --++ attribute overridden
      overridden_and_redefined => 100 --++ attribute overridden_and_redefined
    )With null record;

private

end Derived_Class;
       

The deferred constant is defined in the private part of a package. And a partial declaration is also made in public part. In order to generate a deferred constant, several conditions must be matched.

• The attribute must be constant.
• If the attribute belongs to a class, it must be static.
• The attribute must have a default value.
• The property Ada_CG::Attribute::DeferredInitializationPosition must be different than "None".
• The property Ada_CG::Attribute::DeclarationPosition must be set with the same value than the property Ada_CG::Attribute::DeferredInitializationPosition.

--++ package Default::Complex_Numbers
package Complex_Numbers is

  --Public types -------------------------------
  --++ Type Forward_Complex
  type Complex is private;

  -- Public Variables/Constants ----------------
  I : constant Complex;

private

  --Private types ------------------------------
  --++ Type Complex
  type Complex is 

  record

    -- Fields --
    Rl : Float;  --++ attribute Rl
    Im : Float;  --++ attribute Im

  end record;

  -- Public Deferred Constants Initialization -
  I : constant Complex := (0.0, 1.0);  --++ attribute I

end Complex_Numbers;
   

An operation can be made guarded by setting the “Concurrency” property to guarded .

Making an Operation Guarded.

When an operation is guarded, a mutex is used to synchronize access to the operation. Depending on the value of the “Ada_CG.<Class|Package>.UseAda83Framework property of the operation owner, an Ada83 task based Mutex or an Ada95 protected object based Mutex will be used.

The mechanism for supporting template operations and their instantiations is very similar to the one available for template classes and their instantiation.

Modeling a template operation and a template operation instantiation

features of a template operation

setting up template parameters for a template operation

--++ package Generic_Op_Pkg
package Generic_Op_Pkg is
    
    --Public Functions/Procedures section -------
    --++ operation Generic_Function(Integer)
    generic
        gen_param : Integer;
    function Generic_Function (
      regular_param : in Integer
    ) return Integer;
    
    

private
       
end Generic_Op_Pkg;
       

generated code for a template operation specification

--++ package Generic_Op_Pkg
package body Generic_Op_Pkg is
    
    --Functions/Procedures section -------
    function Generic_Function (
      regular_param : in Integer
    ) return Integer is
       --+[ operation myOperation(Integer, Boolean).Variables
       
       --+]
    begin
       return 0;
       --+[ operation myOperation(Integer, Boolean)
       
       --+]
    end Generic_Function;

       
end Generic_Op_Pkg;
       

generated code for a template operation implementation

features of a template operation instantiation

setting up template arguments for a template operation instantiation

--++ package Generic_Op_Instantiation_Pkg
package Generic_Op_Instantiation_Pkg is
    
    --Public Functions/Procedures section -------
    --++ operation Generic_Function_Instantiation(Integer)
    function Generic_Function_Instantiation is new Generic_Op_Pkg.Generic_Function(
      gen_param => 8
    );

private
       
end Generic_Op_Instantiation_Pkg;
       

generated code for a template operation instantiation

Ada95 introduced the concept of access parameters. In order to set the mode of a parameter to be “access”, as opposed to “in”, “out”, or “in out”, first the package in which is defined the operation has to generate Ada95 code (and not Ada83), second you will need to edit the properties of the parameter to set the AsAccess property to true.

Making a parameter passing mode "access"

You can also choose to pass the this parameter as an access mode parameter for a non-static operation, to do this you need to edit the properties of the operation to set the ThisByAccess property to true.

Making an operation this parameter passing mode "access"

type class_name_t;
type class_name_acc_t is access all class_name_t;
    
type class_name_t is tagged null record;

    --Public Functions/Procedures section -------
    --++ operation myOperation(Integer, Boolean)
    function myOperation (this : access class_name_t;
        arg1 : access Integer;
        arg2 : in Boolean
     ) return Integer;
       

Operation using access mode parameters

In order to specify whether a parameter is to be passed class-wide or not, you will need to set its “ClassWide” property to true.

Dependencies stereotyped as <<Usage>> in Rhapsody create “With” statements in the generated Ada packages. If the “Ada_CG.Dependency.CreateUseStatement” property is set to “Use”, a “Use” statement will also be created for the target package.If it is set to “UseType”, a “Use Type” statement will also be created for the target type. By default, the “With” and “Use” statements will appear in the package specification. They can be moved to the package body by setting the “CG.Dependency.UsageType” property to “Implementation”.

<<Usage>> dependencies in Rhapsody Developer for Ada.

An implementation dependency.

Creating a "Use" statement.

With actor_3;
With class_0;
With package_0;
Use class_0;

--++ class class_1
package class_1 is
    
type class_1_t;
type class_1_acc_t is access all class_1_t;

type class_1_t is tagged null record;

    --Public Functions/Procedures section -------
    --++ operation Message_0()
    function message_0 (this : in out class_1_t);

private

end class_1;
       

The package specification for dependencies.

With package_0.class_2;

--++ class class_1
package body class_1 is
    
type class_1_t;
type class_1_acc_t is access all class_1_t;

type class_1_t is tagged null record;

    --Functions/Procedures section -------
    function message_0 (this : in out class_1_t) is
    begin
       null;
       --+[ operation Message_0()
       
       --+]
    end message_0;

end class_1;
       

The package body for dependencies.

Note that elaboration pragmas can be generated for the supplier class or package of the dependency in the client class or package by setting the appropriate properties on the dependency:

• Ada_CG.Dependency.GeneratePragmaElaborate
• Ada_CG.Dependency.GeneratePragmaElaborateAll

Dependencies stereotyped as <<Renames> in Rhapsody create “renames” statements in the generated Ada packages.

Valid <<Renames>> dependencies can be modelized between any two model elements of the same kind among the following ones:

• Packages
• Classes
• Operations
• Attributes
• • Defined on a package
  • Defined on a class with a static modifier

Be aware that using this feature on classes limits what you can do with the renaming class. More specifically :

• You cannot derive other classes from
• Adding attributes or operations to it has no effect on the generated code

Note that for operations:

• Signatures have to be compatible
• It is possible to have a “renaming as spec” or a “renaming as body” behavior depending on the setting of the “CG.Dependency.UsageType” property (Specification or Implementation).

Only <<renames>> dependencies between classes and packages can be drawn on the Object Model Diagrams of Rhapsody. In order to model <<renames>> dependencies between two attributes or two operations, one has to use the context menu in the Rhapsody browser.

When working with Ada 95, classes and packages are also used as the namespace for classes and packages contained within them. This containment is used to create child packages. In Ada 83, this containment does not have any effect.

Packages and classes used as namespaces.

--++ class class_1::class_2
package my_Package.my_Sub_Package.class_1.class_2 is

    type class_2_t;
    type class_2_acc_t is access all class_2_t;

    type class_2_t is tagged null record;

private

end my_Package.my_Sub_Package.class_1.class_2;
       

The package specification for class_2.

The resulting files including the namespaces.

In this example, the Ada package name is prefixed by the parent names. For example, class_2 is contained in class_1 , which is found in my_Sub_Package , which itself if located inside of my_Package . Therefore the package name for class_2 is my_Package.my_Sub_Package.class_1.class_2 . This package will be found in the configuration directory in my_Package/my_Sub_Package/class_1 .

Also notice that class_0 is located in the “Default” package, and therefore is not considered as a child package.

Child packages are in the namespace of their parent, but they are defined in separate files. Nested packages are not only in the namespace of their parent, but they are also defined in the same files as their parent.

Example of a nested package and a nested class.

In order to generate nested packages, one has to set the Ada_CG.Package.IsNested property for a package or the Ada_CG.Class.IsNested property for a class.

Setting a class to be generated as a nested package.

Setting a package to be generated as a nested package.

To determine in which section of the parent package the specification of the nested package will be generated, one can use the Ada_CG.Package.NestingVisibility property for a package, or the Ada_CG.Class.NestingVisibility property for a class.

Controlling the location of the specification of a nested package

Note that any package or class defined inside of a package or class that is itself nested will be generated as a nested package too.

Packages and classes can be defined as private via the use of the Ada_CG.Package.IsPrivate property for packages and Ada_CG.Class.IsPrivate property for classes.

Example of a private package and a private class.

Setting a class to be generated as a private package

Setting a package to be generated as a private package

--++ class Private_Child_Class
private package Parent_Pkg.Private_Child_Class is

    type Private_Child_Class_t;
    type Private_Child_Class_acc_t is access all Private_Child_Class_t;

    type Private_Child_Class_t is tagged null record;

private

end Parent_Pkg.Private_Child_Class;
       

Specification of a private class

--++ package Parent_Pkg::Private_Child_Package
private package Parent_Pkg.Private_Child_Package is

private

end Parent_Pkg.Private_Child_Package;
       

Specification of a private package

Note that a nested class or package cannot be private.

Via the use of appropriate tags, different pragmas can be generated for a class or a package

Example of a class and a package with elaboration pragmas

Enabling generation of elaboration pragmas on a class

Enabling generation of elaboration pragmas on a package

--++ class Class_With_Elaboration_Pragmas
package Class_With_Elaboration_Pragmas is

    pragma elaborate_body;
    pragma preelaborate;
    pragma pure;

    type Class_With_Elaboration_Pragmas_t;
    type Class_With_Elaboration_Pragmas_acc_t is access all Class_With_Elaboration_Pragmas_t;

    type Class_With_Elaboration_Pragmas_t is tagged null record;

private

end Class_With_Elaboration_Pragmas;
       

Specification of a class with elaboration pragmas

--++ package Default::Pkg_With_Elaboration_Pragmas
package Pkg_With_Elaboration_Pragmas is

    pragma elaborate_body;
    pragma preelaborate;
    pragma pure;

private

end Pkg_With_Elaboration_Pragmas;
       

Specification of a package with elaboration pragmas

Please read the section on <<Usage>> dependencies to see how to generate “elaborate” and “elaborate_all” pragmas.

Note that other pragmas can be generated for a class or a package via the use of the following properties:

• For a class
• • Ada_CG.Class.SpecificationPragmas
  • Ada_CG.Class.SpecificationPragmasInContextClause
  • Ada_CG.Class.ImplementationPragmas
  • Ada_CG.Class.ImplementationPragmasInContextClause
• For a package
• • Ada_CG.Package.SpecificationPragmas
  • Ada_CG.Package.SpecificationPragmasInContextClause
  • Ada_CG.Package.ImplementationPragmas
  • Ada_CG.Package.ImplementationPragmasInContextClause

Any class or package that is defined within a package stereotyped as <<Container>> will not include the package in its namespace.

In the following example, Package_1 is stereotyped <<Container>>.

A Sample <<Container>> Package.

In this example, every package is generated, but the namespaces for Class_A, Package_2, and Class_B do not include Package_1.

Types can be created in either packages or classes.

Types defined in Rhapsody.

The definition of the type is taken in different way.

• language
• Enum
• Structure
• Typedef

The definition of the type is taken from the “Ada declaration” field,. In the declaration, a “%s” can be inserted to represent the name of the type.

The declaration of a private type on a class.

The declaration of a public type on a class.

The declaration of a private type on a package.

The declaration of a public type on a package.

A type definition can appear in the public or private portion of the resulting package specification, or in the package body.

Controlling the visibility of a type.

--++ class class_1
package class_1 is

    type class_1_t;
    type class_1_acc_t is access all class_1_t;

    --Public types ------------------------
    -- This is the declaration of my type.
    type my_Type is new Integer range 0..5;

    type class_1_t is tagged null record;

private

    --Private types ------------------------
    -- Definition of my private type.
    subtype my_Private_Type is Integer range 1..5;

end class_1;
       

The package specification for a class with types.

--++ package package_1
package package_1 is

    --Public types ------------------------
    -- The declaration of the public type.
    type public_Type is  (one, two, three);

private

    --Private types ------------------------
    -- Declaration of the private type.
    type private_Type is new Positive;

end package_1;
       

The package specification for a package with types.

In order to provide some degree of control over the declaration order of types, the Ada_CG.Type.DeclarationPosition property can be used. Its behavior is very similar to the one of the Ada_CG.Attribute.DeclarationPosition property for attributes, with the following exceptions:

• There is no “default” value for this property on types
• If an attribute and a type have a similar value for their respective declarationPosition properties, then the attribute will be generated before the type declaration.

The typedef declaration will generate a new kind of type

        Type Type_0 is new Boolean;

If the "Reference" box is checked, an access type is created

        Type Type_0 is access Boolean;

The property Ada_CG.Type.AccessKind allow refining the the kind of access type

        Type Type_0 is access all Boolean; -- Ada_CG.Type.AccessKind = General 
        Type Type_1 is access constant Boolean; -- Ada_CG.Type.AccessKind = Constant

A type can be also defined with a class with a stereotype. This enables to have more visibility on type relations. The stereotypes are defined in the profile AdaCodeGenerator.

Main stereotype is “Type”. It is applicable on a class. This stereotype has a tag “IsSubtype”. If this tag is set to true, then the class will define a subtype.

Any type has a reference to another Ada type. This reference is represented by a dependency with the stereotype “New”. The dependency can be set to a Rhapsody type or a Rhapsody typed class.

Basic use cases:

Definition of a type

Representation of a typed class

           -- Public Types -------------------------- 
           type Integer_32 is new Integer;

Definition of a subtype

Representation of a subtype

The generated code of a subtype is:

           -- Public Types -------------------------- 
           subtype A_SubType is Integer;

Some other stereotypes are derived from “Type”

• RangeType : allow defining range type
• ArrayType : allow defining array type
• VariantRecordType : allow defining variant record type

A representation clause can be added on any type by updating the tag representationClauses.

Representation clause definition.

       -- Public Types -------------------------- 
       type RR is 

       record

           -- Fields --
           Code : Opcode;  --++ attribute Code
           R1 : Register;  --++ attribute R1
           R2 : Register;  --++ attribute R2

       end record;

       for RR'Alignement use 2;  
    
       for RR use
       record
           Code at 0 range 0 .. 7;
           R1 at 1 range 0 .. 3;
           R2 at 1 range 4 .. 7;
       end record;
   

Creating a template class in Rhapsody results in the generation of a generic Ada package. The arguments become the generic parameters.

In this example, arg1 is an Integer argument and arg2 is a Boolean argument.

Definition of a template class.

    --++ class generic_Class 
    generic
        arg1 : Integer;
        arg2 : Boolean;
    package generic_Class is
    
        type generic_Class_t;
        type generic_Class_acc_t is access all generic_Class_t;

        type generic_Class_t is tagged null record;
        
    private
    
    end generic_Class;
       

Package specification for a generic package.

An instantiation of this generic package is created by using an instantiation class in Rhapsody.

An instantiation of a template class.

The generated result is an instantiation of the generic package using the supplied arguments.

    with generic_Class;

    --++ class generic_Instantiation 
    package generic_Instantiation is new generic_Class(arg1 => 5, arg2 => true);
       

The generated Ada package for a generic instantiation.

Note that it is possible to have a template class inherit from another template class.

Inheritance between template classes

With generic_Parent;

--++ class generic_Child
generic
    with package  generic_Parent_Instantiation is new generic_Parent(<>);
    arg_3 : Character;
package generic_Child is

    type generic_Child_t;
    type generic_Child_acc_t is access all generic_Child_t;

    type generic_Child_t is new generic_Parent_Instantiation.generic_Parent_t with null record;

private

end generic_Child;
       

generated code for a template class derived from another template class

In order to fully benefit from the facilities offered by template inheritance, an efficient way to instantiate the whole class hierarchy is needed.

Modeling instantiation of a template inheritance hierarchy

Note that to specify that a derived class instantiation depends on a parent class instantiation, we use a <<Parent_Instantiation>> dependency from the derived class instantiation to the base class instantiation. This approach allows for reusing of the same parent class instantiation by several derived class instantiations

With generic_Parent;

--++ class generic_Parent_Instantiation
package generic_Parent_Instantiation is new generic_Parent(arg1 => 5, arg2 => true);
       

generated code for a base template instantiation class

With generic_Child;
With generic_Parent_Instantiation;

--++ class generic_Child_Instantiation_1
package generic_Child_Instantiation_1 is new generic_Child(
   generic_Parent_Instantiation => generic_Parent_Instantiation,
   arg3 => 'a'
);
       

generated code for a derived template instantiation class

With generic_Child;
With generic_Parent_Instantiation;

--++ class generic_Child_Instantiation_2
package generic_Child_Instantiation_2 is new generic_Child(
   generic_Parent_Instantiation => generic_Parent_Instantiation,
   arg3 => 'b'
);
       

generate code for another derived template instantiation class

Note that if the derived template class is an (Ada) child package of the base class, the generated code will slightly differ to accommodate the special visibility that the child has upon its parent

Modeling template inheritance hierarchy across (Ada) children packages

--++ class generic_Parent::generic_Child
generic
    arg3 : Character;
package generic_Parent.generic_Child is

   type generic_Child_t;
   type generic_Child_t is access all generic_Child_t;

   type generic_Child_t is new generic_Parent.generic_Parent_t with null record; 

private

end generic_Parent.generic_Child;
       

Generated code for a derived template class that is a child package of its base class

With generic_Parent.generic_Child;
With generic_Parent_Instantiation;

--++ class generic_Child_Instantiation_1
package generic_Child_Instantiation_1 is new generic_Parent_Instantiation.generic_Child(
   arg3 => 'a'
);
       

Generated code for the instantiation of a derived template class that is a child package of its base class

Starting with Rhapsody Developer for Ada rev 8.1.4, the ada task representation changes. Before, two stereotypes were used to create ada task: <<AdaTask>> and <<AdaTaskType>> .

Now these stereotypes are deprecated and have been renamed <<D_AdaTask>> and <<D_AdaTaskType>>. The old names are used for another purpose.

Two new stereotypes, <<AdaSingleTask>> and <<AdaTaskType>>, have been created in order to be able to create Ada task types or Ada single tasks inside classes.

The legacy task representation is style available and is explained in the first part. A second part will detail how we can represent simple Ada task type and Ada single task in a Rhapsody model.

Protected objects are represented in Rhapsody by a class stereotyped as <<AdaProtectedObject>> or <<AdaProtectedType>> . The result is the creation of an Ada package containing a protected type. The <<AdaProtectedObject>> stereotype should be used for singleton tasks.

Protected objects in Rhapsody.

For <<AdaProtectedObject>> and <<AdaProtectedType>> classes, the Ada_CG.Class.Visibility property has to be set to “Private”

Setting the record type visibility to “Private” for an <<AdaProtectedType>> class

By default, all operations in the class do not represent entries. In order to generate a protected object entry, one has to apply the <<entry>> stereotype to an operation.

Applying the <<entry>> stereotype to a protected object operation

By default, the guard for a protected entry will be set to true, however one can define its own guard by setting the “Ada_CG.Operation.EntryCondition” property to the appropriate boolean expression.

Setting the guard for a protected object/type entry

--++ class Protected_Object_Class
package Protected_Object_Class is 

   type Protected_Object_Class_t is tagged limited private;
   type Protected_Object_Class_acc_t is access all Protected_Object_Class_t;

   --Public Functions/Procedures section ------------
   ----++ operation entry_default_guard()
   procedure entry_default_guard (this : in out Protected_Object_Class_t);

   ----++ operation regular_function()
   function regular_function (this : in Protected_Object_Class_t) return Integer;

   ----++ operation regular_operation()
   procedure regular_operation (this : in out Protected_Object_Class_t);

private

   --protected type declaration
   
   protected Protected_Object_Class_protected is
      entry entry_default_guard (this : in out Protected_Object_Class_t);
      procedure regular_operation (this : in out Protected_Object_Class_t);
      function regular_function (this : in Protected_Object_Class_t) return Integer;

   private

   end Protected_Object_Class_protected;

   type Protected_Object_Class_t is tagged limited null record;

end Protected_Object_Class;
       

Protected object specification.

--++ class Protected_Object_Class
package body Protected_Object_Class is 


   --Functions/Procedures section ------------
   procedure entry_default_guard (this : in out Protected_Object_Class_t) is
   begin
     Protected_Object_Class_protected.entry_default_guard (this);
   procedure entry_default_guard;

   procedure regular_operation (this : in out Protected_Object_Class_t) is
   begin
     Protected_Object_Class_protected.regular_operation (this);
   procedure regular_operation;

   function regular_function (this : in Protected_Object_Class_t) return Integer is
   begin
     Protected_Object_Class_protected.regular_function (this);
   procedure regular_function;
   
   --Protected Object/Type Implementation
   protected body Protected_Object_Class_protected is
      entry entry_default_guard (this : in out Protected_Object_Class_t) when true is
      begin
         null;
         --+[ operation entry_default_guard()
         
         --+]
      end entry_default_guard;
      
      procedure regular_operation (this : in out Protected_Object_Class_t) is
            --+[ operation regular_operation().Variables
         
            --+]
      begin
         null;
         --+[ operation regular_operation()
         
         --+]
      end regular_operation;
      
      function regular_function (this : in Protected_Object_Class_t) return Integer is
            --+[ operation regular_function().Variables
         
            --+]
      begin
         return 0;
         --+[ operation regular_function()
         
         --+]
      end regular_function;

   end Protected_Object_Class_protected;

end Protected_Object_Class;
       

Protected object body.

--++ class Protected_Type_Class
package Protected_Type_Class is 

   type Protected_Type_Class_t is tagged limited private;
   type Protected_Type_Class_acc_t is access all Protected_Type_Class_t;

   --Public Variables/Constants
   static_attribute : Integer; --++ attribute static_attribute

   --Public Functions/Procedures section ------------
   --++ operation entry_function()
   function entry_function (this : in Protected_Type_Class_t) return Integer;

   --++ operation entry_true_or_false()
   procedure entry_true_or_false (this : in out Protected_Type_Class_t);

   --Public Fields/Variables accessors ------------
   function get_attribute_0 (this : in Protected_Type_Class_t) return Integer;
      pragma  inline (get_attribute_0 );

   procedure set_attribute_0 (this : in out Protected_Type_Class_t; value : in Integer);
      pragma  inline (set_attribute_0 );

   function get_static_attribute (this : in Protected_Type_Class_t) return Integer;
      pragma  inline (get_static_attribute );

   procedure set_static_attribute (this : in out Protected_Type_Class_t; value : in Integer);
      pragma  inline (set_static_attribute );

   procedure Initialize (this : in out Protected_Type_Class_t);

   procedure Finalize (this : in out Protected_Type_Class_t);

private

   --protected type declaration
   
   protected Protected_Type_Class_protected is
   
      entry entry_true_or_false (this : in out Protected_Type_Class_t);
      function entry_function (this : in Protected_Type_Class_t) return Integer;
      function get_attribute_0 (this : in Protected_Type_Class_t) return Integer;
      procedure set_attribute_0 (this : in out Protected_Type_Class_t; value : in Integer);

   private

      -- Fields --
      attribute_0 : Integer; --++ attribute attribute_0

   end Protected_Type_Class_protected;

   type Protected_Type_Class_protected_acc is access Protected_Type_Class_protected;

   type Protected_Type_Class_t is tagged limited
   
   record
     my_Protected_Type_Class_protected : Protected_Type_Class_protected_acc;

   end record;

end Protected_Type_Class;
       

Protected type specification.

With UNCHECKED_DEALLOCATION;

--++ class Protected_Type_Class
package body Protected_Type_Class is 

   --Functions/Procedures section ------------
   procedure entry_true_or_false (this : in Protected_Type_Class_t) is
   begin
      this.my_Protected_Type_Class_protected.entry_true_or_false (this);
   end entry_true_or_false;

   --Fields/Variables accessors ------------
   function get_attribute_0 (this : in Protected_Type_Class_t) return Integer is
   begin
      return this.my_Protected_Type_Class_protected.get_attribute_0 (this);
   end get_attribute_0;

   procedure set_attribute_0 (this : in out Protected_Type_Class_t; value : in Integer) is
   begin
     this.my_Protected_Type_Class_protected.set_attribute_0 (this, value);
   end set_attribute_0;

   --Protected Object/Type Implementation
   protected body Protected_Type_Class_protected is
      entry entry_true_or_false (this : in out Protected_Type_Class_t) when true or false is
      begin
         null;
         --+[ operation entry_true_or_false()
         
         --+]
      end entry_true_or_false; 
      
      function get_attribute_0 (this : in Protected_Type_Class_t) return Integer is
      begin
         return attribute_0;
      end get_attribute_0; 

      procedure set_attribute_0 (this : in out Protected_Type_Class_t; value : in Integer) is
      begin
        attribute_0 := value;
      end set_attribute_0;

   end Protected_Type_Class_protected;

   procedure Initialize (this : in out Protected_Type_Class_t) is
   begin 
      this.my_Protected_Type_Class_protected := new Protected_Type_Class_protected;
   end Initialize; 

   procedure Finalize (this : in out Protected_Type_Class_t) is
      procedure FREE is new UNCHECKED_DEALLOCATION(
         Protected_Type_Class_protected,
         Protected_Type_Class_protected_acc
      );
   begin
      FREE(this.my_Protected_Type_Class_protected);
   end Finalize; 
   
end Protected_Type_Class;
       

Protected type body.

The protected type generates the constructor and destructor as well, which create the task instance and destroy it.

When the singleton class is generated using the Ada 95 rules, the non-static attributes are held in a record in the same manner as a normal class.

--++ class My_Singleton
package My_Singleton is 

   type My_Singleton_t;
   type My_Singleton_acc_t is access all My_Singleton_t;

   type My_Singleton_t is tagged limited 
   
   record;

   -- Fields --
      my_Int : Integer;  --++ attribute my_Int
   
   end record;

   --Public Variables/Constants
   my_Static_Int : Integer; --++ attribute my_Static_Int

   --Public Functions/Procedures section ------------
   --++ operation my_Operation()
   procedure my_Operation;

   --++ operation my_Static_Operation()
   procedure my_Static_Operation;

   --Public Fields/Variables accessors ------------
   function get_my_Int return Integer;
      pragma  inline (get_my_Int);

   procedure set_my_Int (value : in Integer);
      pragma  inline (set_my_Int);

   function get_my_Static_Int return Integer;
      pragma  inline (get_my_Static_Int);

   procedure set_my_Static_Int (value : in Integer);
      pragma  inline (set_my_Static_Int);

private

end My_Singleton;
       

The package specification for a singleton class in Ada 95.

--++ class My_Singleton
package body My_Singleton is 

   -- Singleton storage
   My_Singleton_unique_instance : aliased My_Singleton_t;

   -- short names for singleton attributes
  
   attribute_0 : Integer renames My_Singleton_unique_instance.attribute_0;

   --Functions/Procedures section ------------
   procedure my_Operation is 
         --+[ operation my_Operation().Variables
   
         --+]
   begin
      null; 
      --+[ operation my_Operation()
   
      --+]
   end my_Operation;

   procedure my_Static_Operation is 
         --+[ operation my_Static_Operation().Variables
   
         --+]
   begin
      null; 
      --+[ operation my_Static_Operation()
   
      --+]
   end my_Static_Operation;
   
   --Fields/Variables accessors ----------------
   function get_my_Int return Integer is
   begin
     return My_Singleton_unique_instance.my_Int;
   end get_my_Int;

   procedure set_my_Int (value : in Integer) is
   begin 
     My_Singleton_unique_instance.my_Int := value;
   end set_my_Int;

   function get_my_Static_Int return Integer is
   begin
     return My_Singleton_unique_instance.my_Static_Int;
   end get_my_Static_Int;
   
   procedure set_my_Static_Int (value : in Integer) is
   begin
     My_Singleton_unique_instance.my_Static_Int := value;
   end set_my_Static_Int;

private

end My_Singleton;
       

The package body for a singleton class in Ada 95.

Changing the “DefaultComponent” component to be an Ada 83 package changes the generation of the singleton class so that the rules for Ada 83 are followed. In this case, all attributes are considered static attributes and a record type is not created for the class nor is a variable for the singleton instance created in the package body.

Changing the component to generate Ada 83 code.

--++ class My_Singleton
package My_Singleton is 

   my_Int : Integer;  --++ attribute my_Int

   --Public Variables/Constants
   my_Static_Int : Integer; --++ attribute my_Static_Int

   --Public Functions/Procedures section ------------
   --++ operation my_Operation()
   procedure my_Operation;

   --++ operation my_Static_Operation()
   procedure my_Static_Operation;

   --Public Fields/Variables accessors ------------
   function get_my_Int return Integer;
      pragma  inline (get_my_Int);

   procedure set_my_Int (value : in Integer);
      pragma  inline (set_my_Int);

   function get_my_Static_Int return Integer;
      pragma  inline (get_my_Static_Int);

   procedure set_my_Static_Int (value : in Integer);
      pragma  inline (set_my_Static_Int);

private

end My_Singleton;
       

The package specification for a singleton class in Ada 83.

--++ class My_Singleton
package body My_Singleton is 

   --Functions/Procedures section ------------
   procedure my_Operation is 
         --+[ operation my_Operation().Variables
   
         --+]
   begin
      null; 
      --+[ operation my_Operation()
   
      --+]
   end my_Operation;

   procedure my_Static_Operation is 
         --+[ operation my_Static_Operation().Variables
   
         --+]
   begin
      null; 
      --+[ operation my_Static_Operation()
   
      --+]
   end my_Static_Operation;
   
   --Fields/Variables accessors ----------------
   function get_my_Int return Integer is
   begin
     return my_Int;
   end get_my_Int;

   procedure set_my_Int (value : in Integer) is
   begin 
     my_Int := value;
   end set_my_Int;

   function get_my_Static_Int return Integer is
   begin
     return my_Static_Int;
   end get_my_Static_Int;
   
   procedure set_my_Static_Int (value : in Integer) is
   begin
     my_Static_Int := value;
   end set_my_Static_Int;

private

end My_Singleton;
       

The package body for a singleton class in Ada 83.

When the multiplicity = 1, the class will have a reference to only one instance of the target class. The following example demonstrates the generated code for each of the implementation types. Note that no accessors are generated for the “Fixed” implementation.

Class relations with multiplicity = 1.

When the multiplicity is greater than 1, the same basic concepts are followed for each implementation choice, except some data structures are created to hold the instances. In addition, new types are defined to represent the valid indices into such structures, and iterator subpackages are declared for every relation..

Unbounded relations and qualified relations (both bounded and unbounded) use data structures that rely on the Booch components.

Table 2 Nary relations methods matrix

Table 3 Nary relations Iterator package method description

Rhapsody Developer for Ada does not install Booch Components files. If needed, user must do it manually by following the procedure. See section Installation notes: Booch components .

Either the original Ada 83 version of the components can be used, or the Ada 95 version. The choice is made at the component level with the Ada_CG.Component.UseBoochComponents property.

Although only part of it is used. Here is the list of packages that may be with’ed by the generated code when using Ada 83:

1. semaphore
2. storage_manager_concurrent
3. list_single_unbounded_controlled
4. list_utilities_single
5. list_search
6. map_simple_noncached_concurrent_bounded_managed_noniterator
7. map_simple_noncached_concurrent_unbounded_managed_noniterator

Table 4 Booch 83 Components Package Dependency Matrix

Here is the list of packages that may be with’ed by the generated code when using Ada 95:

1. BC.Support.Standard_Storage
2. BC.Containers.Collections.Unbounded
3. BC.Containers.Maps.Unbounded
4. BC.Containers.Maps.Bounded

Table 5 Booch 95 Components Package Dependency Matrix

An array is created to hold the instances

Class relations with multiplicity > 1, bounded.

Unbounded relations are no longer represented as arrays of 100 elements, but as data structures relying on dynamic memory allocation.

Important note : Any legacy code using unbounded relations relying on the fact that the underlying implementation is an array of 100 elements MUST be updated, as it will either not compile or potentially lead to run-time errors.

Qualified relations are represented with maps. The unbounded form relies on dynamic memory allocation.

A qualified relation is a key based association. This means that if there is an association from A to B, where the qualifier is an attribute B.id of type Integer, the relation is key based (in this case, Integer is the key type).

Only one element can be bound for each value of the qualifier domain.

Adding an element with a key that already exists has the effect of replacing the old element with the new one.

Note : only attributes of a type that is a subtype of Integer can be used as Qualifiers.

Note : with booch 95 components, if the type of the key is a subtype of integer (or any standard type) which is defined in an other package, then user must define a new “=” function in this other package.

For example, a new subtype of integer is defined into User_Type package.

User must define a new “=” function into this package.

package User_Type is
       subtype My_Subtype_Integer is Integer range 1..1000;
       function "=" (A : in My_Subtype_Integer; B : in My_Subtype_Integer)
       return Boolean;
    private
    end User_Type;  
     
    package body User_Type is
      function "=" ( A : in My_Subtype_Integer; B : in My_Subtype_Integer )
      return Boolean is
      begin
        return standard."="(A, B);
      end "=";
    end User_Type;

Container set is selected by using the property "Ada_CG.Configuration.ContainerSet". Two kind of container set are provided

• default: this option uses legacy code generator which implements Booch components
• Ada2005Container: this option provides Ada2005 containers, using new containers' implementation.

If user needs it, he can define himself its own container, by creating new properties. This will be explained below.

Container's implementation is chosen by using the property "CG.Relation.Implementation". The values are:

• default
• StaticArray
• Bounded
• UnBounded
• BoundeQualified
• UnboundeQualified

If default value is used, the code generator will choose himself the implementation, depending of he kind of relation and its multipicity.

User has the possiblity to define other kind of implementation, if the provided ones are not suitable. The way to do it is explained below.

The type of the element stored inside the container, can be controled with the property "Ada_CG.Relation.AccessTypeUsage". This property can take the following values:

• None : the element's type stored inside the container will be a class record type
• Regular : the element's type stored inside the container will be an regular access to the class record type
• ClassWide : the element's type stored inside the container will be an class-wide access to the class record type

User has the possibility to modify or create generated code for containers. This paragraph will explain in details all the steps to create a new container set

Note that there are limitations applicable to usage of ports which are described hereafter:

• Ports contracts have to be implicit
• Multiplicities in links between ports have to be balanced
• • The number of source instances has to match the number of target instances
  • And the number of source ports has to match the number of target ports
• A port can have multiple contracts if the model is built for Ada 2005
• Fast ports are available only is the model is built for Ada 2005

RiA generates code for ports in classes and for linking instances via ports.

When a class has ports, the code generator will create an additional Ada package called <class>_port. This Ada package contains all the material to declare the class’s ports. The class contains a part of this <class>_port type.

Some functions are added in order to send some messages through ports.

Get_<Port_Name>(this : class_type) : return port_type

This function gets the instance of the port we need.

<message>(this: class_type, port : port_type)

This function sends the message “message” through the port “port” of the class “this”. One function is created for each message defined in the port’s interface. The usual way to send a message is to write:

<message>(this, Get_<Port_Name>(this));

If some parameters need to be passed with the message, then they are added after the port’s instance:

<message>(this, Get_<Port_Name>(this), param : param_type);

The procedure is the same when you want to send an event through a port. Use the gen event function with port’s name:

Gen_<event_name>(this, Get_<Port_Name>(this));

When an event is received from a port, it is possible to know which port received it. It is done with the function Is_Port of class Oxf.I_Event. Its signature is:

oxf.I_Event.is_port(event : oxf.I_event_t, port_ID : System.address)

The port_ID is given by the address of the port. You must get it like that:

<port_name>.Get_Inbound(Get_<port_name>('this)).Port_ID

Create a new model with 2 classes Class_0 and Class_1 which are parts of a class Build.

Create an interface interface_1 with one operation “message_0”.

Create port “Port_0” on Class_0.

Open features window of this port. Check behavioral check button, and add a provided interface in contract tab.

Copy this port in Class_1.

Open features window of this new port. Check reversed check button

Create a link between ports of the two classes.

Add an operation message_0() in class_0. Its implementation must be:

put_line("class_0 : message_0()");

Add an operation test() in class_1. Its implementation must be:

put_line("Class_1 : test()");
message_0(this,get_port_0(this));

Add an put_line() in class Build. Its implementation must be:

put_line("Build : test()");
class_1.test(this.itsClass_1.all)

Add a with and use clause for Ada.text_IO in all classes.

In configuration features, initialize the Build class in Initialization tab, and implement initialization code with:

Build.test(p_Build.all);

You should get a model like this one:

In this model test() function of class_1 will send message “message_0” through its port port_0.

Take the model created below.

Set Ada_CG:Component:AdaVersion Property to Ada05 in oder to build the model for Ada 2005.

In Class_0, Add a statechart with 2 states and one event “a” between the 2 states

In Class_1, Add a statechart with 2 states and one event “b” between the 2 states

Remove the contract of the 2 ports

Change the implementation of class_1.test():

gen_event(this, Default.get_a, get_port_0(this));

To send an event through a fast port you must use the function Gen_Event. Its signature is:

gen_event(this: class type, event : Oxf.Event.Event_acc_t, port : port_type);

The event must be created with the function defined in the event’s package. Its name is:

<event package>.get_<event_name>

This feature allows sending a message through one port to several ports in a single operation. It uses Booch components 95 in order to create an unbounded list of interfaces. Booch components are not provided with Rhapsody install. They must be installed manually if needed. (See Installation notes: Booch components for more information.)

Multicast generation is controlled by the property

ADA_CG::Port::Support Multicasting

This property has the following values

Never : multicast instrumentation is never used

Smart : multicast instrumentation is used only if needed (see algorithm below)

Always : multicast instrumentation is always generated

Sending a multicast message

Sending a message to a port will automatically send it to all connected interfaces. The syntax is the same than with a single interface.

Example

The port Port_0 of an instance of class Class_0 is linked to several ports of instances of various other classes( which have the same interface as port_0)

To send a message “message” through Port_0 of class_0 you must write:

message(this, get_port_0(this));

A message can be a procedure, an event or a triggered operation. Functions cannot be sent through multicast ports.

Fast ports also support multicast.

Link initialization with multiplicity

Multicast can be automatically initialized only if required and provided interface of the link belongs to class instance of multiplicity 1 and if its port has also multiplicity 1. In this case there is no ambiguity for initializing the links. Multiplicity of both ends of the link must be equal to 1.

Multiplicity equals 1 in both ends of the link (in this case multicast is not useful)

There are several instances of a class with provided interface.

Other operations on multicast ports

Some other operations can be done on a multicast Port in order to control the links between ports.

• Add a new provided interface
• Remove an existing provided interface
• Send a message to only one provided interface.

A provided interface can be disconnected from required interface. The following procedure does this.

Remove_<interface_name>(this : port_type, interface : interface_type);

Example:

declare      
        currentSourcePort   : microphone_port.port_0.port_type;      
        currentTargetPort   : loudspeaker_port.port_0.port_type;    
begin      
        currentSourcePort := microphone.get_port_0(this.itsMicrophone_0.all);      
        currentTargetPort := loudspeaker.get_port_0(this.itsLoudspeaker_0.all);     
      
        microphone_port.port_0.remove_Interface_9 (                 
                                                currentSourcePort,                 
                                                loudspeaker_port.port_0.get_Interface_9(currentTargetPort)               
                                                );    
end;

To add a new link to port, you just need to set port interface as usual.

Example:

declare
        currentSourcePort : microphone_port.port_0.port_type;
        currentTargetPort : loudspeaker_port.port_0.port_type;
begin
        currentSourcePort := microphone.get_port_0(this.itsMicrophone_0.all);
        currentTargetPort := loudspeaker.get_port_0(this.itsLoudspeaker_0.all);

        microphone_port.port_0.set_Interface_9 (
                                                currentSourcePort,
                                                loudspeaker_port.port_0.get_Interface_9(currentTargetPort)
                                                );
end;

It is possible to send a message to only one link. A message “Message” can be sent to only one provided interface:

Message(this : class_type, port : port_type, interface : interface_type);

If you are in SXF mode, then you must take care when you create active variants. The process to create active variants is a little bit complex. See the process here or here in "Simplified Execution Framework" document.

Some tags enable setting ElaborateBody, Preelaborate and Pure pragmas on classes or on packages. The use of these pragmas are described here and here.

Some properties allow setting some user defined pragmas in particular places in spec files or body files of classes or packages. These properties are described here.

Some additional tags on class, enable generating pragma atomic and pragma volatile for the class record type.

For classes which have the stereotype D_AdaTaskType, some properties allow setting pragma Priority or pragma Storage_Size. This is described here.

For user defined task (class with stereotype "AdaTaskType), a constraint with "pragma" stereotype can be defined. This is described here.

Some tags defined on attribute, can be checked to define:

• pragma atomic
• pragma volatile

Some accessor and mutator can be automaically generated for attributes. Some properties defined on attribute, allow generating pragma inline on these accessor and mutator.

• Ada_CG::Attribute::InlineAccessor
• Ada_CG::Attribute::InlineMutator

Some tags defined on type, can be checked to define:

• pragma atomic
• pragma volatile

A pragma inline can be generated if the check box "inline" is checked in general tab of operation feature.

If you need to generate other not predefined pragma, another generic representation can be used. A pragma is represented by a constraint with "pragma" stereotype. This pragma can be added on several Rhapsody elements.

• Package
• Class
• Operation
• Attribute
• Type
• AdaTaskType

To add a pragma to an element, in the browser, right click on the element, and in the menu, select Add New>AdaCodeGenegration>pragma.

Creating a pragma on a variable.

The pragma identifier is set by the Rhapsody pragma name.

The pragma parameter is set in the Rhasopdy pragma specification. It is possible to add some macro which will be replaced by some other text.

• %name: this macro will be replaced by the name of element which contains the pragma
• %recordTypeName: this macro is used only for pragma which is set on a class. It will be replaced by the name of the class record type.

Setting the pragma features.

The generated code for this pragma defined above will be:

    variable_0 : integer;
    pragma atomic(variable_0);

The pragma is generated after attribute, type and operation declaration. Pragmas defined on class and package can be generated at several places. The place where the pragma is generated is controled by two tags.

• Position: this tag can take several values
  • before_with_clause: the pragma is generated before with clause in context clause section of the file.
  • after_with_clause: the pragma is generated after with clause in context clause section of the file.
  • in_declarative_part: the pragma is generated after the declaration of the Ada package.
  • for_class_racord_type: the pragma is generated after the class record type declaration.
• Visibility: This tag can take Two values
  • Specification: the pragma is generated in specification file.
  • Body: the pragma is generated in body file.

In some cases, we should need to generated the pragma for some configuration, and not for an other configuration. The choice of the configurations for which the pragmas must be generated is done with a dependency from the pragma to the configuration. The policy is the following:

• If the pragma has no dependency, then it is always generated. This is the default case.
• If the pragma has some dependency to some configuration, then it will be generated only for these configurations.

An Ada library can be created from a project by setting the “Library” option on the component.

Setting the Component to Create a Library.

When the project is built, a library will be created in the directory specified by the configuration using the naming conventions described in the table below.

Table 6 Compilers library naming conventions

To use an Ada library from another project, two pieces of information are required in the component properties. The first is the name of the library to use. This name depends on the compiler you are using, the syntax is described in the previous table. This name is put in the “Libraries” field. If there is more than one library to list, place a carriage return between the names.

Using an Ada Library.

The location of the libraries also needs to be specified. The “Include Path” field is used to capture this information. The location of the library as well as the location of the sources for the library must be included. If there is more than one path to enter a carriage return should be used as a separator.

A “With” Clause will be created for every class selected.

The contents of the “Ada_CG.Configuration.ImplementationProlog” property on the configuration will appear just after the “With” clauses. It can be used to “With” other classes or packages as needed.

If the selected class is not a singleton, a variable will be created to hold an access to the type of the class, and initialized with a new instance. If the class implements an Initialize procedure, the new instance will be initialized as well. If the class is a singleton and implements the Initialize procedure, the procedure will be called on the class.

If there is a reactive class in the model that requires the RiADefaultActive class, the RiADefaultActive class will be initialized.

If there is both an instance of a reactive class, and an instance of the active context for this reactive class, the reactive instance will be registered on the active instance. If the reactive instance uses the RiADefaultActive class, this registration will be done as well.

The RiADefaultActive class will be started if needed

As for the configuration initial instances, the Ada_CG.Relation.ObjectInitialization (Creation, Full, None) configuration property controls their initial behavior. By default it is set to “Full”, which means instances will be initialized and their behavior will be started. If the user would like the behavior not to be started, “Creation” should be selected.

Variables declared in the “Ada_CG.Configuration.LocalVariablesDeclaration” property will appear in the declaration of the entrypoint.

Any code entered in the “Initialization Code” field on the configuration will be inserted into the entrypoint.

The contents of the “Ada_CG.Configuration.ImplementationEpilog” property on the configuration will appear just after the “end MainDefaultComponent;” line.

with RiA_Default_Active;
with class_0;
with class_1;

procedure  MainDefaultComponent is 
    start_behavior_status : Boolean;
    p_class_0 : class_0.class_0_acc_t;
    p_class_1 : class_1.class_1_acc_t;
begin 
    -- Instance Initialization 
    RiA_Default_Active.Initialize;
    p_class_0 := new  class_0.class_0_t;
    class_0.Initialize(p_class_0.all );
    p_class_1 := new  class_1.class_1_t;
    
    -- register Reactive Classes 
    RiA_Default_Active.register_context_class_0(p_class_0.all);
    
    -- Start Behavior 
    RiA_Default_Active.start;
    class_0.start_behavior(p_class_0.all , start_behavior_status);
    
    -- Initialize Package Instances
    
    -- User Initialization Code
    -- Your Configuration Initialization Code 
    
end  MainDefaultComponent;
       

Auto-generated Entrypoint.

The generated entrypoint can be viewed by selecting “Edit Configuration Main File” from the Configuration.

If animation is turned on, these instances will NOT be animated.

A child package will be created to handle the creation and initialization of any instances defined in a package. The name of the package will be <<Ada Package Name>>.RiA_Instances, where <<Ada Package Name >> is the name of the package where the instances are defined. When generating Ada83, the package name will be <<Ada Package Name>>_Instances. Each instance defined in the UML package will create global variables in this generated Ada package.

Global Instances on a Package.

Global Instance with Mulitplicity = 1.

Global Instance with Multiplicity > 1.

Variables will be created in the public part of the package specification for each instance defined. The type of variable will depend on the setting of the “CG.Relation.Implementation” property for each of the relations. If the instance is a singleton, no variable will be created. If the multiplicity is greater than 1 but not *, an array with be used of the given size. If the multiplicity is given as *, an array will be generated of size 100. The elements in this array will not be initialized.

The appropriate “With” statements will be added to the package specification for each Class instantiated.

These instances will be created in the procedure Initialize_Relations , and they will be initialized if an Initialize operation exists for their class.

Likewise, these instances will be finalized in the procedure Finalize_Relations if a Finalize operation exists for their class.

If the instances have a statechart, the start_behavior procedure will be called to start the behaviors of the instances in the Initialize_Relations procedure. The instances will be hooked up to their active context if needed as well. If the instances are active, they will be started by calling the start procedure.

with MyPackage.class_0;
with MyPackage.class_1;

package  MyPackage.RiA_Instances is

    -- Instance Declarations
    itsClass_0 : MyPackage.class_0.class_0_acc_t;
    
    type itsClass_1_card_t is new positive range 1..10;
    type itsClass_1_acc_lst_t is array(itsClass_1_card_t) of MyPackage.class_1.class_1_acc_t;
    itsClass_1 : itsClass_1_acc_lst_t;
    
    procedure Initialize_Relations;
    procedure Finalize_Relations;
    
end MyPackage.RiA_Instances;

The Instances Package Specification.

with RiA_Default_Active;

package body MyPackage.RiA_Instances is

    procedure Initialize_Relations is
      start_behavior_status : Boolean;
    begin
      -- Create the global instances
      itsClass_0 := new MyPackage.class_0.class_0_t;
      MyPackage.class_0.initialize(itsClass_0.all);
      for i in itsClass_1_card_t loop
        itsClass_1(i) := new MyPackage.class_1.class_1_t;
      end loop;
      
      -- Register the contexts
      RiA_Default_Active.register_context_class_0(itsClass_0.all);
      
      -- Start Behavior
      MyPackage.class_0.start_behavior(itClass_0.all, start_behavior_status);
      
      -- Hookup instances
      
      -- Ensure tat there is at least one statement
      null;
    end Initialize_Relations;
    
    procedure Finalize_Relations is
    begin
      MyPackage.class_0.Finalize(itsClass_0.all);
      
    end Finalize_Relations;
    
end MyPackage.RiA_Instances;
     

The Instances Package Body.

If a link is created between the instances, the relation will be initialized as well in the Initialize_Relations procedure.

Only the Initialize_Relations procedure will be called from the auto-generated entrypoint.

In object feature window, it is possible to define the object type. There are three different ways to define this type:

• user defined class: the type is selected among the classes defined in the model.
• implicit: the type is implicit. A new class will be auto generated. The class will have the name of the object. The instance name will be <<Object_Name>>_Instance.
• implicit and user defined: the type is implicit. User defines the package where the type is defined, in the property Ada_CG::Class::PackageName. A file will be generated to define this user defined Ada package.

By modifying the following properties on the project, component, configuration, package or class level the user can get Rhapsody to use custom headers and footers instead of the default ones for generated files.

• Ada_CG.File.ImplementationFooter
• Ada_CG.File.ImplementationHeader
• Ada_CG.File.SpecificationFooter
• Ada_CG.File.SpecificationHeader

Defining custom header and footer at the component level

The usual Rhapsody inheritance rules apply for these properties, which means that you can refine your settings from the project level all the way down to the class.

These four properties are independent, which means that you can use a single project level setting for say the specification header and have different configuration level settings for the implementation header.

Those properties can also be updated at class level or at operation level (for separate operation). This can be useful to set change history log for example.

If the value of a keyword is a MultiLine, each new line (except the first one) starts with the value of the ADA_CG::Configuration::DescriptionBeginLine property; each line ends with the value of the ADA_CG::Configuration::DescriptionEndLine property.

Keyword based substitution is supported inside of these headers and footers.

The following keywords are supported:

• $ProjectName - The project name.
• $ComponentName - The component name.
• $ConfigurationName - The configuration name.
• $ModelElementName - The name of the element mapped to the file. If there is more than one, this is the name of the first element.
• $FullModelElementName - The name of the element mapped to the file, including the full path. If there is more than one, this is the name of the first element.
• $CodeGeneratedDate - The generation date.
• $CodeGeneratedTime - The generation time.
• $RhapsodyVersion - The version of Rhapsody that generated the file.
• $Login - The user who generated the file.
• $CodeGeneratedFileName - The name of the generated file.
• $FullCodeGeneratedFileName - The full file name.
• $Description - the description of the class or package

Note the following:

Keyword names can be written in parentheses. For example:

• $(Name)
• If the value of a keyword is a MultiLine, each new line (except the first one) starts with the value of the ADA_CG::Configuration::DescriptionBeginLine property; each line ends with the value of the ADA_CG::Configuration::DescriptionEndLine property.

.

Inserting keywords inside user-defined header and footer

--++ package default
-- Component level Specification Header 1
-- sodius InheritedSetings DefaultComponent 6.0 Sodius
-- Component level Specification Header 2

--++ class class_0
package class_0 is

    type class_0_t;
    type class_0_acc_t is access all class_0_t;
        
    type class_0_t is tagged null record;
        
private

end class_0;
-- Component level Sepcification Footer 1
-- Component level Sepcification Footer 2
       

Example of generated code using user-defined header and footer

It is also possible to put script names inside of headers and footers so that they get evaluated at code generation time.

The name has to be framed following this convention [[scriptName]].

The script has to be applicable for the model element for which the header is being evaluated, otherwise an error message will be displayed.

Makefiles are usually generated by the Ada code generator. However they can also be created manually. This document describes all the features of custom makefiles, and gives some examples of makefile creation.

This list of macros already known by the code generator:

   -- package_3::class_7 Start
      for spec ("package_3.class_7_Interface") use "class_7_Interface.ads";
      for spec ("package_3.class_7_Port") use "class_7_Port.ads";
      for body ("package_3.class_7_Port") use "class_7_Port.adb";
      for spec ("package_3.class_7") use "class_7.ads";
      for body ("package_3.class_7") use "class_7.adb";
   -- package_3::class_7 End

      for spec (\"$FileName\") use \"$SpecRelativeFilename\";

      for body (\"$FileName\") use \"$SpecRelativeFilename\";

    -- $AdaCGRiAFullName Start

    -- $AdaCGRiAFullName End

with <component_path>\<config_name><PathDelimiter><config_name>.gpr

with <configuration_path><PathDelimiter><config_name>.gpr

This list of additional properties shows properties which are used by macro listed below:

<\”\\n\”><\”;\”>

Property LibrariesTemplate MultiLine " -largs <\"\^\"><\" -l\"><\"\\n\"><\" -l\"><\"\\r\\n\"><\" -l\"><\",\"><\" -l\">"

-largs -llib1 -llib2

ConfigurationRelativeFilename : .\Default\class_0
ConfigurationRelativeBodyFilename : .\Default\class_0.adb
ConfigurationRelativeSpecFilename : .\Default\class_0.ads
SpecRelativeFilename : class_0.ads
BodyRelativeFilename : class_0.adb
FileName : class_0
FullNameDashes : class_0("." Are replaced by "-")
AdaCGRiAFullName : Default::class_0
         

Create a new file SiteAda.prp

Add the following properties:

Subject Ada_CG
  Metaclass Configuration
    Property Environment Enum "GNAT,INTEGRITY,INTEGRITY5,MultiWin32,Multi4Win32,OBJECTADA,RAVEN_PPC,SPARK,GNATVxWorks,New_Env" "GNAT"
  end
end

Copy an environment which is as close as possible to your new one, from sodius.prp to siteAda.prp. It must be copied just before the last “end” of the file.

Then modify entry points and add some new properties which will describe your new files.

Custom makefiles can be created for several purposes. For example user needs to make a small modification of a current makefile. Or user wants to use a new compiler which is not supported by code generator. This chapter will describe how this can be done.