Adding a payload to a type

[Simen Kjærås]

On Monday, 27 May 2019 at 08:40:45 UTC, Amex wrote:
> I have some types I've declared and I'd like to magically 
> extend them and add data. The problem is I inheriting from them 
> them is bad news.
>
> Suppose, for example, I have an image type that is used in an 
> application. For a small part of the application it needs to 
> associate with each image type an xy coordinate type that adds 
> a coordinate to the image to be used by the part of the app 
> that needs to have coordinates for the image. The rest of the 
> app does not care or need the xy coordinates.
>
> Inheritance solves this problem in some sense except it 
> doesn't. If I want to add new data then it breaks.
>
> class image;
> class xy : image; // can only add an image.
> class z : ??; ?? could be xy, image, or something else
>
> Inheritance is not the correct thing to do here. I only want to 
> associate data with an object. The hierarchy does not matter.
>
>
> I could add a payload type to image but this causes problems 
> since it would have to be void or of a singular type. Mainly it 
> causes problems with the serializer I'm using since it can't 
> handle voids(I might be able to get it to work with a special 
> type but it will not be easy).
>
>
> I could, of course, add a parallel struct that somehow 
> associates the image it's extra data but to keep them in sync 
> will not be easy since it will have to persist between runs(so 
> the address could not be used).
>
> One could think of what I'm trying to do is create a tuple that 
> holds the image and any other data.
>
> tuple(tuple(image, xy), z) // the outer tuple may occur later 
> without knowing that the image has been "wrapped".
>
> How does one normally handle this? It seems like something 
> really simple to do(attach data) but it has no real 
> programmatic way to do naturally that works with oop.
>
>
> The main thing is that attaching different data should "stack" 
> and not effect the base type or break the type hierarchy. If 
> something takes an image it should take any extended object.
>
>
> I feel like the only way to do this is to create a special type 
> that can be serialized properly and is part of the base 
> class... I'll have to do it for all the classes. Hopefully 
> someone has some better ideas?

There's of course many different ways to skin a cat. Here's my 
first idea:

class Image {
     // regular image stuff
     Metadata[] metadata;

     T getMetadata(T : Metadata)() {
         foreach (e; metadata) {
             if (cast(T)e !is null) {
                 return cast(T)e;
             }
         }
         return null;
     }
}

abstract class Metadata {}

class Coordinates : Metadata {
     int x, y;
     this(int x, int y) {
         this.x = x;
         this.y = y;
     }
}

unittest {
     auto img = new Image();
     img.metadata ~= new Coordinates(1,2);

     auto coords = img.getMetadata!Coordinates;
     assert(coords.x == 1);
     assert(coords.y == 2);
}

This could easily be extended to support multiple metadata of the 
same type by adding a name field or such.

--
   Simen