//ATTENTION: This file is autogenerated from a data schema.
//Any changes you make to this file directly will be lost on the next recompile.

namespace Seshat.UnitTests
{
    using System.Text;
    using System.Collections.Generic;
    using System;
    using System.Linq;
    using Seshat;

    public partial class SampleCompositeTypeTable : Seshat.Table<SampleCompositeType>
    {
        public List<int> element1;
        
        public List<string> element2;
        
        public SampleCompositeTypeTable()
        {
            element1 = new List<int>();
            AbstractColumns.Add(element1);
            DefaultTypes.Add(default(int));
            ColumnMultiplicities.Add(1);

            element2 = new List<string>();
            AbstractColumns.Add(element2);
            DefaultTypes.Add(default(string));
            ColumnMultiplicities.Add(1);
        }
        
        public virtual void CopyBuffersTo(ref SampleCompositeTypeTable targetTable)
        {
            targetTable.UpdateCapacity(RowCount - targetTable.RowCount);
            targetTable.element1.Clear();
            targetTable.element1.InsertRange(0, element1);
            targetTable.element2.Clear();
            targetTable.element2.InsertRange(0, element2);
        }
        
        public class Defaults
        {
            public static int element1
            {
                get
                {
                    return default(int);
                }
            }
            
            public static string element2
            {
                get
                {
                    return default(string);
                }
            }
            
            public static object DefaultsByColumnIndex(int index)
            {
                if (index == 0)
                {
                    return element1;
                }
                if (index == 1)
                {
                    return element2;
                }
                throw new Exception(String.Format("Index {{0}} out of range.", index));
            }
        }
        
        public override object GetDefaultObjectByIndex(int index)
        {
            return Defaults.DefaultsByColumnIndex(index);
        }
    }
    
    public partial class SampleCompositeType : Seshat.Row
    {
        public int element1
        {
            get
            {
                return BackingTable.element1[RowIndex];
            }
            set
            {
                BackingTable.element1[RowIndex] = value;
            }
        }
        
        public string element2
        {
            get
            {
                return BackingTable.element2[RowIndex];
            }
            set
            {
                BackingTable.element2[RowIndex] = value;
            }
        }
        
        public SampleCompositeTypeTable BackingTable
        {
            get
            {
                return GetTableAs<SampleCompositeTypeTable>();
            }
        }
        
        public override StringMap ToStringMap()
        {
            var returnMe = new StringMap();
            returnMe.Scalar.Add("element1", element1.ToString());
            returnMe.Scalar.Add("element2", element2.ToString());
            return returnMe;
        }
        
        public override IList<string> FromStringMap(IDictionary<string, IDictionary<string,string>> stringMap)
        {
            var failures = new List<string>();
            element1 = ExtractScalarFromStringMap<int>(stringMap, "element1", x => int.Parse(x), () => default(int), ref failures);
            element2 = ExtractScalarFromStringMap<string>(stringMap, "element2", x => x, () => default(string), ref failures);
            return failures;
        }
    }
    
    public partial class SampleClassTable : Seshat.Table<SampleClass>
    {
        public List<int> composite_element1;
        
        public List<string> composite_element2;
        
        public List<DateTime> date;
        
        public List<int> AandB_Item1;
        
        public List<string> AandB_Item2;
        
        public List<int> triples;
        
        public const int triples_ElementsPerRow = 3;
        
        public List<int> doubles;
        
        public const int doubles_ElementsPerRow = 2;
        
        public List<List<int>> collection;
        
        public List<List<int>> bakedList;
        
        public List<Dictionary<string,char>> dict;
        
        public SampleClassTable()
        {
            composite_element1 = new List<int>();
            AbstractColumns.Add(composite_element1);
            DefaultTypes.Add(default(int));
            ColumnMultiplicities.Add(1);

            composite_element2 = new List<string>();
            AbstractColumns.Add(composite_element2);
            DefaultTypes.Add(default(string));
            ColumnMultiplicities.Add(1);

            date = new List<DateTime>();
            AbstractColumns.Add(date);
            DefaultTypes.Add(default(DateTime));
            ColumnMultiplicities.Add(1);

            AandB_Item1 = new List<int>();
            AbstractColumns.Add(AandB_Item1);
            DefaultTypes.Add(default(int));
            ColumnMultiplicities.Add(1);

            AandB_Item2 = new List<string>();
            AbstractColumns.Add(AandB_Item2);
            DefaultTypes.Add(default(string));
            ColumnMultiplicities.Add(1);

            triples = new List<int>();
            AbstractColumns.Add(triples);
            DefaultTypes.Add(default(int));
            ColumnMultiplicities.Add(3);

            doubles = new List<int>();
            AbstractColumns.Add(doubles);
            DefaultTypes.Add(default(int));
            ColumnMultiplicities.Add(2);

            collection = new List<List<int>>();
            AbstractColumns.Add(collection);
            DefaultTypes.Add(new List<int>());
            ColumnMultiplicities.Add(3);

            bakedList = new List<List<int>>();
            AbstractColumns.Add(bakedList);
            DefaultTypes.Add(default(List<int>));
            ColumnMultiplicities.Add(1);

            dict = new List<Dictionary<string,char>>();
            AbstractColumns.Add(dict);
            DefaultTypes.Add(default(Dictionary<string,char>));
            ColumnMultiplicities.Add(1);
        }
        
        public virtual void CopyBuffersTo(ref SampleClassTable targetTable)
        {
            targetTable.UpdateCapacity(RowCount - targetTable.RowCount);
            targetTable.composite_element1.Clear();
            targetTable.composite_element1.InsertRange(0, composite_element1);
            targetTable.composite_element2.Clear();
            targetTable.composite_element2.InsertRange(0, composite_element2);
            targetTable.date.Clear();
            targetTable.date.InsertRange(0, date);
            targetTable.AandB_Item1.Clear();
            targetTable.AandB_Item1.InsertRange(0, AandB_Item1);
            targetTable.AandB_Item2.Clear();
            targetTable.AandB_Item2.InsertRange(0, AandB_Item2);
            targetTable.triples.Clear();
            targetTable.triples.InsertRange(0, triples);
            targetTable.doubles.Clear();
            targetTable.doubles.InsertRange(0, doubles);
            for (int i = 0; i < RowCount; i = i + 1)
            {
                targetTable.collection[i].Clear();
                targetTable.collection[i].InsertRange(0, collection[i]);
            }
            targetTable.bakedList.Clear();
            targetTable.bakedList.InsertRange(0, bakedList.Select(x => new List<int>(x)));
        }
        
        public class Defaults
        {
            public static int composite_element1
            {
                get
                {
                    return default(int);
                }
            }
            
            public static string composite_element2
            {
                get
                {
                    return default(string);
                }
            }
            
            public static DateTime date
            {
                get
                {
                    return default(DateTime);
                }
            }
            
            public static int AandB_Item1
            {
                get
                {
                    return default(int);
                }
            }
            
            public static string AandB_Item2
            {
                get
                {
                    return default(string);
                }
            }
            
            public static int triples
            {
                get
                {
                    return default(int);
                }
            }
            
            public static int doubles
            {
                get
                {
                    return default(int);
                }
            }
            
            public static List<int> collection
            {
                get
                {
                    return new List<int>();
                }
            }
            
            public static List<int> bakedList
            {
                get
                {
                    return new List<int>();
                }
            }
            
            public static Dictionary<string,char> dict
            {
                get
                {
                    return new Dictionary<string,char>();
                }
            }
            
            public static object DefaultsByColumnIndex(int index)
            {
                if (index == 0)
                {
                    return composite_element1;
                }
                if (index == 1)
                {
                    return composite_element2;
                }
                if (index == 2)
                {
                    return date;
                }
                if (index == 3)
                {
                    return AandB_Item1;
                }
                if (index == 4)
                {
                    return AandB_Item2;
                }
                if (index == 5)
                {
                    return triples;
                }
                if (index == 6)
                {
                    return doubles;
                }
                if (index == 7)
                {
                    return collection;
                }
                if (index == 8)
                {
                    return bakedList;
                }
                if (index == 9)
                {
                    return dict;
                }
                throw new Exception(String.Format("Index {{0}} out of range.", index));
            }
        }
        
        public override object GetDefaultObjectByIndex(int index)
        {
            return Defaults.DefaultsByColumnIndex(index);
        }
    }
    
    public partial class SampleClass : Seshat.Row
    {
        public int composite_element1
        {
            get
            {
                return BackingTable.composite_element1[RowIndex];
            }
            set
            {
                BackingTable.composite_element1[RowIndex] = value;
            }
        }
        
        public string composite_element2
        {
            get
            {
                return BackingTable.composite_element2[RowIndex];
            }
            set
            {
                BackingTable.composite_element2[RowIndex] = value;
            }
        }
        
        public SampleCompositeType composite
        {
            get
            {
                var element1 = composite_element1;
                var element2 = composite_element2;
                return new SampleCompositeType(){element1 = element1, element2 = element2};
            }
            set
            {
                composite_element1 = value.element1;
                composite_element2 = value.element2;
            }
        }
        
        public DateTime date
        {
            get
            {
                return BackingTable.date[RowIndex];
            }
            set
            {
                BackingTable.date[RowIndex] = value;
            }
        }
        
        public int AandB_Item1
        {
            get
            {
                return BackingTable.AandB_Item1[RowIndex];
            }
            set
            {
                BackingTable.AandB_Item1[RowIndex] = value;
            }
        }
        
        public string AandB_Item2
        {
            get
            {
                return BackingTable.AandB_Item2[RowIndex];
            }
            set
            {
                BackingTable.AandB_Item2[RowIndex] = value;
            }
        }
        
        public Tuple<int,string> AandB
        {
            get
            {
                var Item1 = AandB_Item1;
                var Item2 = AandB_Item2;
                return new Tuple<int,string>(Item1, Item2);
            }
            set
            {
                AandB_Item1 = value.Item1;
                AandB_Item2 = value.Item2;
            }
        }
        
        public IList<int> triplesAsList
        {
            get
            {
                return new ListSegment<int>(BackingTable.triples, (3), RowIndex * (3));
            }
            set
            {
                for (int i = 0; i < Math.Min(3, value.Count); i = i + 1)
                {
                    BackingTable.triples[(3) * RowIndex + i] = value[i];
                }
            }
        }
        
        public IList<int> triples
        {
            get
            {
                var list = triplesAsList;
                return list;
            }
            set
            {
                for (int i = 0; i < 3; i = i + 1)
                {
                    var list = value;
                    BackingTable.triples[(3) * (RowIndex) + i] = list[i];
                }
            }
        }
        
        public IList<int> doublesAsList
        {
            get
            {
                return new ListSegment<int>(BackingTable.doubles, (2), RowIndex * (2));
            }
            set
            {
                for (int i = 0; i < Math.Min(2, value.Count); i = i + 1)
                {
                    BackingTable.doubles[(2) * RowIndex + i] = value[i];
                }
            }
        }
        
        public int[] doubles
        {
            get
            {
                var list = doublesAsList;
                return new int[2] { list[0], list[1] };
            }
            set
            {
                for (int i = 0; i < 2; i = i + 1)
                {
                    var list = new int[2] { value[0], value[1] };
                    BackingTable.doubles[(2) * (RowIndex) + i] = list[i];
                }
            }
        }
        
        public List<int> collection
        {
            get
            {
                return BackingTable.collection[RowIndex];
            }
            set
            {
                BackingTable.collection[RowIndex] = value;
            }
        }
        
        public List<int> bakedList
        {
            get
            {
                return BackingTable.bakedList[RowIndex];
            }
            set
            {
                BackingTable.bakedList[RowIndex] = value;
            }
        }
        
        public Dictionary<string,char> dict
        {
            get
            {
                return BackingTable.dict[RowIndex];
            }
            set
            {
                BackingTable.dict[RowIndex] = value;
            }
        }
        
        public SampleClassTable BackingTable
        {
            get
            {
                return GetTableAs<SampleClassTable>();
            }
        }
        
        public override StringMap ToStringMap()
        {
            var returnMe = new StringMap();
            returnMe.Scalar.Add("composite_element1", composite_element1.ToString());
            returnMe.Scalar.Add("composite_element2", composite_element2.ToString());
            returnMe.Scalar.Add("date", date.ToString("dd/MM/yyyy HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture) + "<comment>Hi!");
            returnMe.Scalar.Add("AandB_Item1", AandB_Item1.ToString());
            returnMe.Scalar.Add("AandB_Item2", AandB_Item2.ToString());
            returnMe.List.Add("triples", triplesAsList.Select(x => x.ToString()).ToArray());
            returnMe.List.Add("doubles", doublesAsList.Select(x => x.ToString()).ToArray());
            returnMe.List.Add("collection", collection.Select(x => x.ToString()).ToArray());
            returnMe.List.Add("bakedList", bakedList.ConvertAll<string>(x => x.ToString()));
            returnMe.Map.Add("dict", dict.ToDictionary(x => x.Key, x => x.Value.ToString()));
            return returnMe;
        }
        
        public override IList<string> FromStringMap(IDictionary<string, IDictionary<string,string>> stringMap)
        {
            var failures = new List<string>();
            composite_element1 = ExtractScalarFromStringMap<int>(stringMap, "composite_element1", x => int.Parse(x), () => default(int), ref failures);
            composite_element2 = ExtractScalarFromStringMap<string>(stringMap, "composite_element2", x => x, () => default(string), ref failures);
            date = ExtractScalarFromStringMap<DateTime>(stringMap, "date", x => DateTime.ParseExact(x, "dd/MM/yyyy HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture), () => default(DateTime), ref failures);
            AandB_Item1 = ExtractScalarFromStringMap<int>(stringMap, "AandB_Item1", x => int.Parse(x), () => default(int), ref failures);
            AandB_Item2 = ExtractScalarFromStringMap<string>(stringMap, "AandB_Item2", x => x, () => default(string), ref failures);
            triplesAsList = ExtractListFromStringMap<List<int>>(stringMap, "triples", list => new List<int>(list.Select(x => int.Parse(x))), () => new List<int>(), ref failures);
            doublesAsList = ExtractListFromStringMap<List<int>>(stringMap, "doubles", list => new List<int>(list.Select(x => int.Parse(x))), () => new List<int>(), ref failures);
            collection = ExtractListFromStringMap<List<int>>(stringMap, "collection", list => new List<int>(list.Select(x => int.Parse(x))), () => new List<int>(), ref failures);
            bakedList = ExtractListFromStringMap<List<int>>(stringMap, "bakedList", list => list.Select(x => int.Parse(x)).ToList(), () => new List<int>(), ref failures);
            dict = ExtractMapFromStringMap<Dictionary<string,char>>(stringMap, "dict", map => map.Count > -1 ? map.ToDictionary(x => x.Key, x => char.Parse(x.Value)) : null, () => new Dictionary<string,char>(), ref failures);
            return failures;
        }
    }
}