using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RaptorDB.Common;
namespace RaptorDB
{
internal class FullTextString
{
}
public interface IRowFiller
{
object FillRow(object row, object[] data);
}
internal interface IGetBytes<T>
{
byte[] GetBytes(T obj);
T GetObject(byte[] buffer, int offset, int count);
}
internal class RDBDataType<T>
{
public static IGetBytes<T> ByteHandler()
{
Type type = typeof(T);
if (type == typeof(int)) return (IGetBytes<T>)new int_handler<T>();
else if (type == typeof(uint)) return (IGetBytes<T>)new uint_handler<T>();
else if (type == typeof(long)) return (IGetBytes<T>)new long_handler<T>();
else if (type == typeof(Guid)) return (IGetBytes<T>)new guid_handler<T>();
else if (type == typeof(string)) return (IGetBytes<T>)new string_handler<T>();
else if (type == typeof(DateTime)) return (IGetBytes<T>)new datetime_handler<T>();
else if (type == typeof(decimal)) return (IGetBytes<T>)new decimal_handler<T>();
else if (type == typeof(short)) return (IGetBytes<T>)new short_handler<T>();
else if (type == typeof(float)) return (IGetBytes<T>)new float_handler<T>();
else if (type == typeof(byte)) return (IGetBytes<T>)new byte_handler<T>();
else if (type == typeof(double)) return (IGetBytes<T>)new double_handler<T>();
return null;
}
public static byte GetByteSize(byte keysize)
{
byte size = 4;
Type t = typeof(T);
if (t == typeof(int)) size = 4;
if (t == typeof(uint)) size = 4;
if (t == typeof(long)) size = 8;
if (t == typeof(Guid)) size = 16;
if (t == typeof(DateTime)) size = 8;
if (t == typeof(decimal)) size = 16;
if (t == typeof(float)) size = 4;
if (t == typeof(short)) size = 2;
if (t == typeof(string)) size = keysize;
if (t == typeof(byte)) size = 1;
if (t == typeof(double)) size = 8;
return size;
}
internal static object GetEmpty()
{
Type t = typeof(T);
if (t == typeof(string))
return "";
return default(T);
}
}
#region [ handlers ]
internal class double_handler<T> : IGetBytes<double>
{
public byte[] GetBytes(double obj)
{
return BitConverter.GetBytes(obj);
}
public double GetObject(byte[] buffer, int offset, int count)
{
return BitConverter.ToDouble(buffer, offset);
}
}
internal class byte_handler<T> : IGetBytes<byte>
{
public byte[] GetBytes(byte obj)
{
return new byte[1] { obj };
}
public byte GetObject(byte[] buffer, int offset, int count)
{
return buffer[offset];
}
}
internal class float_handler<T> : IGetBytes<float>
{
public byte[] GetBytes(float obj)
{
return BitConverter.GetBytes(obj);
}
public float GetObject(byte[] buffer, int offset, int count)
{
return BitConverter.ToSingle(buffer, offset);
}
}
internal class decimal_handler<T> : IGetBytes<decimal>
{
public byte[] GetBytes(decimal obj)
{
byte[] b = new byte[16];
var bb = decimal.GetBits(obj);
int index = 0;
foreach (var d in bb)
{
byte[] db = Helper.GetBytes(d, false);
Buffer.BlockCopy(db, 0, b, index, 4);
index += 4;
}
return b;
}
public decimal GetObject(byte[] buffer, int offset, int count)
{
int[] i = new int[4];
i[0] = Helper.ToInt32(buffer, offset);
offset += 4;
i[1] = Helper.ToInt32(buffer, offset);
offset += 4;
i[2] = Helper.ToInt32(buffer, offset);
offset += 4;
i[3] = Helper.ToInt32(buffer, offset);
offset += 4;
return new decimal(i);
}
}
internal class short_handler<T> : IGetBytes<short>
{
public byte[] GetBytes(short obj)
{
return Helper.GetBytes(obj, false);
}
public short GetObject(byte[] buffer, int offset, int count)
{
return Helper.ToInt16(buffer, offset);
}
}
internal class string_handler<T> : IGetBytes<string>
{
public byte[] GetBytes(string obj)
{
return Helper.GetBytes(obj);
}
public string GetObject(byte[] buffer, int offset, int count)
{
return Helper.GetString(buffer, offset, (short)count);
}
}
internal class int_handler<T> : IGetBytes<int>
{
public byte[] GetBytes(int obj)
{
return Helper.GetBytes(obj, false);
}
public int GetObject(byte[] buffer, int offset, int count)
{
return Helper.ToInt32(buffer, offset);
}
}
internal class uint_handler<T> : IGetBytes<uint>
{
public byte[] GetBytes(uint obj)
{
return Helper.GetBytes(obj, false);
}
public uint GetObject(byte[] buffer, int offset, int count)
{
return (uint)Helper.ToInt32(buffer, offset);
}
}
internal class long_handler<T> : IGetBytes<long>
{
public byte[] GetBytes(long obj)
{
return Helper.GetBytes(obj, false);
}
public long GetObject(byte[] buffer, int offset, int count)
{
return Helper.ToInt64(buffer, offset);
}
}
internal class guid_handler<T> : IGetBytes<Guid>
{
public byte[] GetBytes(Guid obj)
{
return obj.ToByteArray();
}
public Guid GetObject(byte[] buffer, int offset, int count)
{
byte[] b = new byte[16];
Buffer.BlockCopy(buffer, offset, b, 0, 16);
return new Guid(b);
}
}
internal class datetime_handler<T> : IGetBytes<DateTime>
{
public byte[] GetBytes(DateTime obj)
{
return Helper.GetBytes(obj.Ticks, false);
}
public DateTime GetObject(byte[] buffer, int offset, int count)
{
long ticks = Helper.ToInt64(buffer, offset);
return new DateTime(ticks);
}
}
#endregion
}
Submit an article or tip