Re: Properties

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 28.11.10 22:22, Shark8 wrote:
> It probably would
> have looked something like this:
> 
> Type String_Data_Object( String_Data : Access String ) is
>          Limited Tagged; --Forward declared.
> 
> Type PS_String( Data_Object : Access String_Data_Object ) is
>            New PostScript_Object with record
>     Start, Stop : Positive; -- String'First/'Last equiv.
>     The_String  : Separate String;
> end record;
>     For PS_String.The_String.Read Use
>                  Data_Object.String_Data.All( Start..Stop );
>     For PS_String.The_String.Write Use
>                  Data_Object.String_Data.All( Start..Stop );

To the extend I have understood the approach,
you can do this with current Ada. Just make
The_String aware of its surroundings (not sure
I got the String_Data_Object involved as should):

   type PS_String;

   type PostScript_String (Referred : access PS_String;
                           Capacity : Positive) is
      record
         Data : String (1 .. Capacity);
      end record;


   type PS_String( Data_Object : access String_Data_Object;
                   Capacity : Positive) is limited
        new PostScript_Object with record
           Start, Stop : Positive; -- String'First/'Last equiv.



           The_String  : PostScript_String (PS_String'Access, Capacity);
      end record;

Then you can define a user defined 'Write attribute
for PostScript_String that does use Start and Stop
from PS_String to select a range from the string's data:

  procedure Write_PostScript_String
     (Stream : access Ada.Streams.Root_Stream_Type'Class;
      Object : PostScript_String)
   is
      Link : PS_String renames Object.Referred.all; -- the surroundings
   begin
      String'Write(Stream, Object.Data (Link.Start .. Link.Stop));
   end Write_PostScript_String;



>> 2 - What if a property of an object needs to refer to two or more
>> of its components?
>>
>> Say, a property's public view perhaps being much better presented
>> as a Point rather than as forcing two Coordinate properties (even
>> though Coordinates may have been chosen for internal representation
>> in a record).
> 
> That's kinda easy:
> -- for referring to multiple fields.

I think I meant the other way around, as in the Get_XY
example:

> Type Point is Record
>  X, Y : Integer
> End Record;
> 
> Type Point_3D is
>  X, Y, Z : Integer;
>  Parallel_Projected : Separate Point;

   For Parallel_Projected'Read Use ???;

> end record;

Suppose clients of your private Point_3D should be able
to see a property whose computation (result is Point) involves
both components X and Y under the hood.  Call it the Shadow
property, maybe.

More generally, I might have

  type R is private;

  function Spatial_Needs (Item : R) return Area_N;

private
  type R is record
    X1, X2, ..., Xm : Distance;
    Y1, Y2, ..., Yn : Something;
    ...
  end record;

Spatial_Needs is computed from X1, X2, X5, X12, and
Z3 to Z6.  Will standardized properties help provide for this?



>> 3 - Is there anything in properties that helps with order of
>> component access?  (Just an idea.)
> 
> I'm not sure I know what you mean by this... do you mean the order as
> in how Ada automatically orders the internals of a record when piping
> them to a stream?

Something new, and probably not simple: the type's operations
can be called in a specific order only. For example, do not
call property p3 before both p1 and p2 have been set.


>> As an alternative, I'd suggest an option to remove definitions
>> of full views of types from the specs.
> 
> Hm, I'm not sure I see what use that would be.

Somewhat like the pointer-to-implementation approach.
The full type definition is in the body of a package
(or in some representation part of a package which
is separate from both the spec and the body), for example.
Every read/write of one or more components is done through
some primitive operation. A user of the type has no idea
what the component parts of an object might be.