325 lines
11 KiB
C#
325 lines
11 KiB
C#
// using System;
|
|
// using System.Data;
|
|
// using System.Collections;
|
|
// using System.IO;
|
|
// using System.Reflection;
|
|
// using System.Collections.Generic;
|
|
// using System.Linq;
|
|
|
|
// using BCG.Utilities.General;
|
|
|
|
// namespace BCG
|
|
// {
|
|
// /// <summary>
|
|
// /// The LookupTableSchema is an immutable schema holder. Once created it cannot be modified. It can be created
|
|
// /// either from a DataTable or from an Array of ColumnInfo. The methods through which the user can access it
|
|
// /// are the indexers (both order and name based), and the property columnInfo and columnNames, that return
|
|
// /// the respective data, sorted according to the ColumnOrder.
|
|
// /// </summary>
|
|
// [Serializable]
|
|
// public class LookupTableSchema : IBlueTableSchema
|
|
// {
|
|
// public class LookupTableSchemaSerializationHelper
|
|
// {
|
|
// public static object parse(Type t, string data)
|
|
// {
|
|
// if (t == BlueDataValidTypes.BOOL)
|
|
// return Boolean.Parse(data);
|
|
// else if (t == BlueDataValidTypes.BYTE)
|
|
// return Byte.Parse(data);
|
|
// else if (t == BlueDataValidTypes.CHAR)
|
|
// return char.Parse(data);
|
|
// else if (t == BlueDataValidTypes.DATETIME)
|
|
// return DateTime.Parse(data);
|
|
// else if (t == BlueDataValidTypes.DOUBLE)
|
|
// return Double.Parse(data);
|
|
// else if (t == BlueDataValidTypes.DECIMAL)
|
|
// return Decimal.Parse(data);
|
|
// else if (t == BlueDataValidTypes.INT)
|
|
// return int.Parse(data);
|
|
// else if (t == BlueDataValidTypes.LONG)
|
|
// return long.Parse(data);
|
|
// else if (t == BlueDataValidTypes.SBYTE)
|
|
// return SByte.Parse(data);
|
|
// else if (t == BlueDataValidTypes.STRING)
|
|
// return data;
|
|
// else if (t == BlueDataValidTypes.UINT)
|
|
// return uint.Parse(data);
|
|
// else if (t == BlueDataValidTypes.ULONG)
|
|
// return ulong.Parse(data);
|
|
// else if (t == BlueDataValidTypes.SINGLE)
|
|
// return Single.Parse(data);
|
|
// else
|
|
// throw new ApplicationException("Can not be parsed");
|
|
// }
|
|
// public static void serialize(BinaryWriter bw, Type t, object o)
|
|
// {
|
|
// if (t == BlueDataValidTypes.BOOL)
|
|
// bw.Write((bool)o);
|
|
// else if (t == BlueDataValidTypes.BYTE)
|
|
// bw.Write((byte)o);
|
|
// else if (t == BlueDataValidTypes.CHAR)
|
|
// bw.Write((char)o);
|
|
// else if (t == BlueDataValidTypes.DATETIME)
|
|
// bw.Write(((DateTime)o).Ticks);
|
|
// else if (t == BlueDataValidTypes.DOUBLE)
|
|
// bw.Write((double)o);
|
|
// else if (t == BlueDataValidTypes.DECIMAL)
|
|
// bw.Write((decimal)o);
|
|
// else if (t == BlueDataValidTypes.INT)
|
|
// bw.Write((int)o);
|
|
// else if (t == BlueDataValidTypes.LONG)
|
|
// bw.Write((long)o);
|
|
// else if (t == BlueDataValidTypes.SBYTE)
|
|
// bw.Write((sbyte)o);
|
|
// else if (t == BlueDataValidTypes.STRING)
|
|
// bw.Write(o as string);
|
|
// else if (t == BlueDataValidTypes.SINGLE)
|
|
// bw.Write((Single)o);
|
|
// else if (t == BlueDataValidTypes.BYTEARRAY)
|
|
// {
|
|
// byte[] bs = o as byte[];
|
|
// bw.Write(bs.Length);
|
|
// bw.Write(bs);
|
|
// }
|
|
// else if (t == BlueDataValidTypes.UINT)
|
|
// bw.Write((uint)o);
|
|
// else if (t == BlueDataValidTypes.ULONG)
|
|
// bw.Write((ulong)o);
|
|
// else
|
|
// throw new ApplicationException("Unsupported type");
|
|
// }
|
|
|
|
// public static object deserialize(BinaryReader br, Type t)
|
|
// {
|
|
// if (t == BlueDataValidTypes.BOOL)
|
|
// return br.ReadBoolean();
|
|
// else if (t == BlueDataValidTypes.BYTE)
|
|
// return br.ReadByte();
|
|
// else if (t == BlueDataValidTypes.CHAR)
|
|
// return br.ReadChar();
|
|
// else if (t == BlueDataValidTypes.DATETIME)
|
|
// return new DateTime(br.ReadInt64());
|
|
// else if (t == BlueDataValidTypes.DOUBLE)
|
|
// return br.ReadDouble();
|
|
// else if (t == BlueDataValidTypes.DECIMAL)
|
|
// return br.ReadDecimal();
|
|
// else if (t == BlueDataValidTypes.INT)
|
|
// return br.ReadInt32();
|
|
// else if (t == BlueDataValidTypes.LONG)
|
|
// return br.ReadInt64();
|
|
// else if (t == BlueDataValidTypes.SBYTE)
|
|
// return br.ReadSByte();
|
|
// else if (t == BlueDataValidTypes.STRING)
|
|
// return br.ReadString();
|
|
// else if (t == BlueDataValidTypes.BYTEARRAY)
|
|
// return br.ReadBytes(br.ReadInt32());
|
|
// else if (t == BlueDataValidTypes.UINT)
|
|
// return br.ReadUInt32();
|
|
// else if (t == BlueDataValidTypes.ULONG)
|
|
// return br.ReadUInt64();
|
|
// else if (t == BlueDataValidTypes.SINGLE)
|
|
// return br.ReadSingle();
|
|
// else
|
|
// throw new ApplicationException("Unsupported type");
|
|
// }
|
|
// }
|
|
|
|
// protected Hashtable myIndexByColName = new Hashtable();
|
|
// protected ColumnInfo[] myIndexByColOrder;
|
|
// private string[] myTableColNames;
|
|
// private BlueRowLookupGroup[] myLookupGroups;
|
|
// protected string myTableName;
|
|
|
|
// public LookupTableSchema() { }
|
|
|
|
|
|
// public LookupTableSchema(string tableName, ColumnInfo[] cis, BlueRowLookupGroup[] groups)
|
|
// {
|
|
// myConstruct(tableName, cis, groups);
|
|
// }
|
|
|
|
// private void myConstruct(string tableName, ColumnInfo[] cis, BlueRowLookupGroup[] groups)
|
|
// {
|
|
// myIndexByColOrder = new ColumnInfo[cis.Length];
|
|
// myTableName = tableName;
|
|
// foreach (ColumnInfo ci in cis)
|
|
// {
|
|
// myIndexByColOrder[ci.colNo] = ci;
|
|
// myIndexByColName[ci.colName] = ci;
|
|
// }
|
|
// myLookupGroups = groups;
|
|
|
|
// foreach (BlueRowLookupGroup group in groups)
|
|
// {
|
|
// group.buildEntrySchema(this);
|
|
|
|
|
|
// }
|
|
// }
|
|
|
|
|
|
|
|
|
|
// public ColumnInfo this[string colName]
|
|
// {
|
|
// get
|
|
// {
|
|
// object retVal = myIndexByColName[colName];
|
|
// return retVal != null ? retVal as ColumnInfo : null;
|
|
// }
|
|
// }
|
|
|
|
// public BlueRowLookupGroup[] lookupGroups
|
|
// {
|
|
// get { return myLookupGroups; }
|
|
|
|
// }
|
|
// public ColumnInfo this[int colNo]
|
|
// {
|
|
// get { return myIndexByColOrder[colNo]; }
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// The returned Array is sorted according to the Column No
|
|
// /// </summary>
|
|
// public string[] columnNames
|
|
// {
|
|
// get
|
|
// {
|
|
// if (myTableColNames == null)
|
|
// {
|
|
// myTableColNames = new string[myIndexByColName.Count];
|
|
// foreach (DictionaryEntry de in myIndexByColName)
|
|
// {
|
|
// ColumnInfo temp = (ColumnInfo)de.Value;
|
|
// myTableColNames[temp.colNo] = temp.colName;
|
|
// }
|
|
// }
|
|
// return myTableColNames;
|
|
// }
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// The returned Array is sorted according to the Column No
|
|
// /// </summary>
|
|
// public ColumnInfo[] columnInfo
|
|
// {
|
|
// get { return myIndexByColOrder; }
|
|
// }
|
|
|
|
// public string tableName { get { return myTableName; } }
|
|
|
|
|
|
// #region ISerializedType methods
|
|
// public void serialize(BinaryWriter bw)
|
|
// {
|
|
// bw.Write(columnNames.Length);
|
|
// bw.Write(tableName);
|
|
|
|
// //first, write the column names
|
|
// foreach (ColumnInfo ci in columnInfo)
|
|
// {
|
|
// bw.Write(ci.colName);
|
|
// bw.Write(ci.colType.ToString());
|
|
// if (ci.isConstant)
|
|
// {
|
|
// bw.Write(true);
|
|
// LookupTableSchemaSerializationHelper.serialize(bw, ci.colType, ci.colValue);
|
|
// }
|
|
// else
|
|
// {
|
|
// bw.Write(false);
|
|
// bw.Write(ci.lookupTableGroup);
|
|
// }
|
|
|
|
// }
|
|
|
|
// //this is here for error checking
|
|
// bw.Write(myLookupGroups.Length);
|
|
// //now, write the size of each lookup table group
|
|
// foreach (BlueRowLookupGroup group in myLookupGroups)
|
|
// {
|
|
// bw.Write(group.groupNumber);
|
|
// bw.Write(group.tableSize);
|
|
// bw.Write(group.groupColNames.Length);
|
|
// foreach (string colName in group.groupColNames)
|
|
// {
|
|
// //write the index of this column in the table
|
|
// bw.Write(this[colName].colNo);
|
|
|
|
// }
|
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
// }
|
|
|
|
// public void deserialze(BinaryReader br)
|
|
// {
|
|
// int numCols = br.ReadInt32();
|
|
// //these are the final output columns that will be created
|
|
// ColumnInfo[] columnInfos = new ColumnInfo[numCols];
|
|
|
|
// Dictionary<int, List<string>> colLookupGroupMap = new Dictionary<int, List<string>>();
|
|
|
|
|
|
// string tableName = br.ReadString();
|
|
// for (int colNo = 0; colNo < numCols; ++colNo)
|
|
// {
|
|
// string colName = br.ReadString();
|
|
// Type colType = TypeInstanceLoader.loadType(br.ReadString(), true);
|
|
// bool colIsConst = br.ReadBoolean();
|
|
// if (colIsConst)
|
|
// {
|
|
// columnInfos[colNo] = new ColumnInfo(colName, colNo, LookupTableSchemaSerializationHelper.deserialize(br, colType));
|
|
|
|
// }
|
|
// else
|
|
// {
|
|
// short thisColGroup = br.ReadInt16();
|
|
// columnInfos[colNo] = new ColumnInfo(colName, colNo, colType, thisColGroup);
|
|
// }
|
|
// }
|
|
|
|
// int numGroups = br.ReadInt32();
|
|
// BlueRowLookupGroup[] theGroups = new BlueRowLookupGroup[numGroups];
|
|
|
|
// for (int group = 0; group < numGroups; ++group)
|
|
// {
|
|
// short groupNo = br.ReadInt16();
|
|
// short groupSizeInBits = br.ReadInt16();
|
|
// int numColsInGroup = br.ReadInt32();
|
|
// int[] groupCols = new int[numColsInGroup];
|
|
// string[] groupColNames = new string[numColsInGroup];
|
|
// for (int col = 0; col < numColsInGroup; ++col)
|
|
// {
|
|
// groupCols[col] = br.ReadInt32();
|
|
// groupColNames[col] = columnInfos[groupCols[col]].colName;
|
|
// }
|
|
|
|
// //create the group
|
|
// theGroups[groupNo] = new BlueRowLookupGroup(groupNo, groupSizeInBits, groupColNames);
|
|
|
|
|
|
// }
|
|
|
|
|
|
// myConstruct(tableName, columnInfos, theGroups);
|
|
|
|
|
|
|
|
// }
|
|
|
|
// public int getSerializedSize()
|
|
// {
|
|
// throw new NotImplementedException("Feature for provided constant values to" +
|
|
// "non-primitive types in schema, not provided as of now");
|
|
// }
|
|
|
|
// #endregion
|
|
// }
|
|
// }
|