taggedPointer to char array on heap

[Ali Çehreli via Digitalmars-d-learn]

On 01/10/2017 04:26 PM, Ali Çehreli wrote:
> On 01/10/2017 04:14 PM, Nordlöw wrote:
>> On Wednesday, 11 January 2017 at 00:11:47 UTC, Nordlöw wrote:
>>> If taggedPointer!char* allocated on the heap the pointer
>>
>> A taggedPointer!char* cannot use any tags, eventhough a heap-allocated
>> pointer clearly has non-byte alignment. Is there a way around this?
>
> Brute-forced with property functions:

Automated the property functions inside a new taggedAlignedPointer mixin 
template:

import std.algorithm : canFind;

mixin template taggedAlignedPointer(size_t alignment, Args...)
if ([2, 4, 8].canFind(alignment) &&
     ((Args.length - 2) % 3 == 0)) {

     import std.bitmanip : taggedPointer;
     import std.string : format;

     static if (alignment == 2) {
         alias ImplType = ubyte*;
     } else static if (alignment == 4) {
         alias ImplType = uint*;
     } else static if (alignment == 8) {
         alias ImplType = ulong*;
     } else {
         static assert(false);
     }

     alias VarType = Args[0];
     enum varName = Args[1];
     enum varImplName = varName ~ "_impl_";
     enum bitMask = (1 << alignment) - 1;

     mixin (taggedPointer!(ImplType, varImplName, Args[2..$]));

     mixin (format(q{
                 @property void %s(%s arg) {
                     import std.string : format;
                     import std.exception : enforce;
                     enforce((cast(ulong)arg & %s) == 0,
                             format("Bad pointer %%s for alignment %%s", 
arg, alignment));
                     %s = cast(%s)arg;
                 }}, varName, VarType.stringof, bitMask, varImplName, 
ImplType.stringof));

     mixin (format(q{
                 @property auto %s() {
                     return cast(%s)%s;
                 }}, varName, VarType.stringof, varImplName));
}

unittest {
     struct S {
         mixin taggedAlignedPointer!(8,
                                     char*, "p",
                                     bool, "b1", 1,
                                     bool, "b2", 1);
     }

     auto s = S();
     const str = "hello";
     s.p = str.dup.ptr;
     s.b1 = true;
     s.b2 = false;

     assert(s.p[0..str.length] == str);
}

void main() {
}

Ali