Variant[Variant]

[Jason den Dulk]

Hi

Straight off, I should ask if Variant[Variant] is a feasable 
idea. I am writing a serialization module which is trying to make 
use of this.

This is the function

   Variant unserialize(V:Variant)(ref const(char)[] str)
   {
     switch (str[0])
     {
       case 'b':
         return Variant(unserialize!(bool)(str));
       case 'i':
         return Variant(unserialize!(long)(str));
       case 'f':
         return Variant(unserialize!(double)(str));
       case 's':
         return Variant(unserialize!(string)(str));
       case 'a':
         auto len = checkLengthTypeStart(str, 'a');

         Variant[] va;
         foreach (i; 0..len)
         {
           va ~= unserialize!(Variant)(str);
         }
         return Variant(va);
       case 'o':
         auto leno = checkLengthTypeStart(str, 'o');

         Variant[Variant] vaa;
         foreach (j; 0..leno)
         {
           auto v = unserialize!(Variant)(str);
           vaa[v] = unserialize!(Variant)(str);
         }
         return Variant(vaa);
       default:
         throw new Exception(format("Unknown serialize type 
'%c'",str[0]));
     }
   }

It seems to happily unserialize what I give into a 
Variant[Variant], but I can't get access to it. Here is the 
unittest code.

   const(char)[] tcd_ss = 
"a2o3s1:ai1s1:bi2s1:ci3o3s1:di4s1:ei5s1:fi6";
   auto tcd_v = unserialize!(Variant)(tcd_ss);
   assert(tcd_v.type() == typeid(Variant[]));
   assert(tcd_v.length == 2);
   auto tcd1_v = tcd_v[0];
   assert(tcd1_v.length == 3);
   assert(tcd1_v.type() == typeid(Variant[Variant]));
   auto va = Variant("a");
   auto tcd1a_v = tcd1_v[va];  // <======= Blows up here.

By my reckoning, the key Variant("a") exists in tcd1_v. If not, 
shouldn't it give a "Range Violation" error? Instead it gives:

std.variant.VariantException at std/variant.d(1231): Variant: 
attempting to use incompatible types immutable(char)[] and 
std.variant.VariantN!(24u).VariantN
----------------
./serialize(@trusted int 
std.variant.VariantN!(24u).VariantN.handler!(std.variant.VariantN!(24u).VariantN[std.variant.VariantN!(24u).VariantN]).handler(std.variant.VariantN!(24u).VariantN.OpID, 
ubyte[24]*, void*)+0x286) [0x811cd2a]
./serialize(@trusted std.variant.VariantN!(24u).VariantN 
std.variant.VariantN!(24u).VariantN.opIndex!(std.variant.VariantN!(24u).VariantN).opIndex(std.variant.VariantN!(24u).VariantN)+0x68) 
[0x811e654]
./serialize(void serialize.__unittestL257_1()+0x1839) [0x80d296d]
./serialize(void serialize.__modtest()+0x8) [0x8120b84]
./serialize(extern (C) bool core.runtime.runModuleUnitTests().int 
__foreachbody352(ref object.ModuleInfo*)+0x24) [0x812faac]
./serialize(int rt.minfo.moduleinfos_apply(scope int delegate(ref 
object.ModuleInfo*)).int __foreachbody541(ref 
rt.sections_linux.DSO)+0x37) [0x8128057]
./serialize(int rt.sections_linux.DSO.opApply(scope int 
delegate(ref rt.sections_linux.DSO))+0x2c) [0x81282ac]
./serialize(int rt.minfo.moduleinfos_apply(scope int delegate(ref 
object.ModuleInfo*))+0x14) [0x8128004]
./serialize(runModuleUnitTests+0x87) [0x812f9b7]
./serialize(extern (C) int rt.dmain2._d_run_main(int, char**, 
extern (C) int function(char[][])*).void runAll()+0x25) 
[0x81258e5]
./serialize(extern (C) int rt.dmain2._d_run_main(int, char**, 
extern (C) int function(char[][])*).void tryExec(scope void 
delegate())+0x18) [0x8125550]
./serialize(_d_run_main+0x121) [0x8125521]
./serialize(main+0x14) [0x81253f4]
/lib/libc.so.6(__libc_start_main+0xf3) [0x429a5413]

So I ask again, is Variant[Variant] too ambitious? If not ... 
help!

Thanks in advance
Regards
Jason

P.S. The full code can be found at 
http://jaypha.com.au/serialize.d if that helps.