Immutable attributes – part 2

In part one of this post, I described, how to build a class containing public read-only attributes so we can imitate the FINAL attribute concept of JAVA.

Applying this in my daily development work, I came to a slight modification of this approach that uses one class per attribute. To keep the effort low, I use a template (in eclipse ADT) to quickly create such classes.

My immutable class now looks like this:

class example_for_string definition. public section. data value type string read-only. methods constructor importing value type string.
endclass. class example_for_string implementation. method constructor. me->value = value. endmethod. endclass.

In incorporate this in the local definitions of my class. Then I create a private attribute

data example_for_string type ref to example_for_string.

In the constructor (or a different method that is used to initialize the attribute), I instantiate the object with the value, that usually is an import parameter and has the same name. Depending on personal preferences, one would eventually choose to use a prefix for the importing par

me->example_for_string = new #( example_for_string ).
* alternative:
example_for_string = new #( i_example_for_string ).

To speed up the work flow, I created this template in eclipse:

class ${name} definition. public section. data value type ${type} read-only. methods constructor importing value type ${type}.
endclass.
* to local implementations
CLASS ${name} IMPLEMENTATION. METHOD constructor. me->value = value. ENDMETHOD. ENDCLASS.
* to class attributes
data ${name} type ref to ${name}.
* to implementation
me->${name} = new #( ${name} ).

I insert this template (where I have to give only the name and the type of my attribute) in the class-relevant declarations, then move the implementation to “local types” and the other two lines as indicated.