Duplicating multidimensional array

[Ali Çehreli]

On 05/29/2013 10:22 AM, Joseph Rushton Wakeling wrote:

 > I've been having some trouble trying to work out how to effectively
 > duplicate a multidimensional array in a way that preserves type 
qualifiers.

Templates preserve type qualifiers. So, as long as the return type is 
the same as the parameter type, then the type qualifiers should be 
preserved:

T foo(T)(T x)
{
     // ...
}

 >     immutable int[][] x = [[10, 0, 0, 0],
 >                            [0, 10, 0, 0],
 >                            [0, 0, 10, 0],
 >                            [0, 0, 0, 10]];
 >     int[][] y = multidup(x);

As long as it is a conversion, std.conv.to handles that case for you:

import std.conv;
// ...
	int[][] y = x.to!(int[][]);

Done! :)

Unfortunately, std.conv.to is not a general copy tool. It does not do 
anything when converting to the same type. In other words, when the 
target type is the same as the source type it is a no-op, not a copy.

What do you think about the following recursive template solution? I 
have tested it only with arrays of int. :/

import std.stdio;
import std.traits;
import std.conv;

// This is for one-dimensional arrays
T multidup(T : E[], E)(T arr)
     if (!isArray!E)
{
     T result;

     static if (is (E == immutable)) {
         // No need to copy immutable elements
         result = arr;

     } else {
         // Otherwise, we must make a copy
         result = arr.dup;
     }

     return result;
}

// This is for array of array types
T multidup(T : E[], E)(T arr)
     if(isArray!E)
{
     T result;

     static if (is (E == immutable)) {
         // No need to go deeper than an immutable layer
         result == arr;

     } else {
         foreach(row; arr) {
             result ~= multidup(row);
         }
     }

     return result;
}

unittest
{
     {
         int[] a = [ 1, 2, 3 ];
         auto b = multidup(a);
         assert(typeid(b) is typeid(a));
         assert(a == b);
     }

     {
         immutable(int[]) a = [ 1, 2 ];
         auto b = multidup(a);
         assert(typeid(b) == typeid(immutable(int)[]));
         assert(a == b);
         assert(a.ptr == b.ptr);
     }

     {
         immutable(int)[] a = [ 1, 2, 3 ];
         auto b = multidup(a);
         assert(typeid(b) == typeid(a));
         assert(a == b);
         assert(a.ptr == b.ptr);
         // assert(a[0].ptr == b[0].ptr);
     }

     {
         immutable(int)[][] a = [ [ 1, 2, 3 ],
                                  [ 4, 5, 6 ],
                                  [ 7, 8, 9 ] ];
         auto b = multidup(a);
         assert(typeid(b) == typeid(a));
         assert(a == b);
         assert(a.ptr != b.ptr);
         foreach (i; 0 .. a.length) {
             assert(a[i].ptr == b[i].ptr);
         }
     }

     {
         alias Elem = const(int[])[];
         const(int[])[][]a = [ [ [ 1, 2, 3 ],
                                 [ 4, 5, 6 ],
                                 [ 7, 8, 9 ] ],

                               [ [ 1, 2, 3 ],
                                 [ 4, 5, 6 ],
                                 [ 7, 8, 9 ] ] ];

         auto b = multidup(a);
         assert(typeid(b) == typeid(a));
         assert(a == b);
         assert(a.ptr != b.ptr);
         foreach (i; 0 .. a.length) {
             assert(a[i].ptr != b[i].ptr);
         }
     }
}

void main()
{}

Is it usable in your situation?

Ali