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

    public partial class PersonTable : Seshat.Table<Person>
    {
        public List<string> name;
        
        public List<int> age;
        
        public List<float> weight;
        
        public PersonTable()
        {
            name = new List<string>();
            AbstractColumns.Add(name);
            DefaultTypes.Add(default(string));
            ColumnMultiplicities.Add(1);

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

            weight = new List<float>();
            AbstractColumns.Add(weight);
            DefaultTypes.Add(default(float));
            ColumnMultiplicities.Add(1);
        }
        
        public virtual void CopyBuffersTo(ref PersonTable targetTable)
        {
            targetTable.UpdateCapacity(RowCount - targetTable.RowCount);
            targetTable.name.Clear();
            targetTable.name.InsertRange(0, name);
            targetTable.age.Clear();
            targetTable.age.InsertRange(0, age);
            targetTable.weight.Clear();
            targetTable.weight.InsertRange(0, weight);
        }
        
        public class Defaults
        {
            public static string name
            {
                get
                {
                    return default(string);
                }
            }
            
            public static int age
            {
                get
                {
                    return default(int);
                }
            }
            
            public static float weight
            {
                get
                {
                    return default(float);
                }
            }
            
            public static object DefaultsByColumnIndex(int index)
            {
                if (index == 0)
                {
                    return name;
                }
                if (index == 1)
                {
                    return age;
                }
                if (index == 2)
                {
                    return weight;
                }
                throw new Exception(String.Format("Index {{0}} out of range.", index));
            }
        }
        
        public override object GetDefaultObjectByIndex(int index)
        {
            return Defaults.DefaultsByColumnIndex(index);
        }
    }
    
    public partial class Person : Seshat.Row
    {
        public string name
        {
            get
            {
                return BackingTable.name[RowIndex];
            }
            set
            {
                BackingTable.name[RowIndex] = value;
            }
        }
        
        public int age
        {
            get
            {
                return BackingTable.age[RowIndex];
            }
            set
            {
                BackingTable.age[RowIndex] = value;
            }
        }
        
        public float weight
        {
            get
            {
                return BackingTable.weight[RowIndex];
            }
            set
            {
                BackingTable.weight[RowIndex] = value;
            }
        }
        
        public PersonTable BackingTable
        {
            get
            {
                return GetTableAs<PersonTable>();
            }
        }
        
        public override StringMap ToStringMap()
        {
            var returnMe = new StringMap();
            returnMe.Scalar.Add("name", name.ToString());
            returnMe.Scalar.Add("age", age.ToString());
            returnMe.Scalar.Add("weight", weight.ToString());
            return returnMe;
        }
        
        public override IList<string> FromStringMap(IDictionary<string, IDictionary<string,string>> stringMap)
        {
            var failures = new List<string>();
            name = ExtractScalarFromStringMap<string>(stringMap, "name", x => string.Parse(x), () => default(string), ref failures);
            age = ExtractScalarFromStringMap<int>(stringMap, "age", x => int.Parse(x), () => default(int), ref failures);
            weight = ExtractScalarFromStringMap<float>(stringMap, "weight", x => float.Parse(x), () => default(float), ref failures);
            return failures;
        }
    }
}