public static int WriteLpcValue(MemoryStream stream, LPCValue v)
{
int len = LPCValue.SaveToBuffer(mSerBuffer, 0, v);
stream.Write(mSerBuffer, 0, len);
return(len);
}
// 序列化这行数据
bool Deserialize()
{
if (mRowData == null)
{
return(true);
}
try
{
// 反序列化
int offset = 0;
for (var idx = 0; idx < mOwner.columns.Count; idx++)
{
LPCValue v;
offset += LPCValue.RestoreFromBuffer(mRowData, offset, out v);
Add(idx, v);
}
return(true);
}
catch (Exception e)
{
NIDebug.Log(e.Message);
return(false);
}
finally
{
mRowData = null;
}
}
/// <summary>
/// 两个mapping相加(不改变原来的值)
/// </summary>
public static LPCValue MappingAdd(LPCMapping m1, LPCMapping m2)
{
LPCValue v = LPCValue.CreateMapping();
foreach (object k in m1.Keys)
{
if (k is string)
{
v.AsMapping [k as string] = m1 [k as string];
}
else
{
v.AsMapping [(int)k] = m1 [(int)k];
}
}
foreach (object k in m2.Keys)
{
if (k is string)
{
v.AsMapping [k as string] = m2 [k as string];
}
else
{
v.AsMapping [(int)k] = m2 [(int)k];
}
}
return(v);
}
public static LPCValue ReadLpcValue(MemoryStream stream)
{
LPCValue v;
byte[] buf = stream.GetBuffer();
int cnt = LPCValue.RestoreFromBuffer(buf, (int)stream.Position, out v);
stream.Seek(cnt, SeekOrigin.Current);
return(v);
}
// 转换成lpcvalue
public LPCValue ConvertLpc()
{
LPCMapping lpcMap = LPCMapping.Empty;
foreach (KeyValuePair <string, int> c in mOwner.columns)
{
lpcMap.Add(c.Key, properties[c.Value]);
}
return(LPCValue.Create(lpcMap));
}
private static LPCValue ParseIntType(string text)
{
int i;
if (!int.TryParse(text, out i))
{
//LogMgr.Error("无法将 " + text + " 转换为int");
i = 0;
}
return(LPCValue.Create(i));
}
/// <summary>
/// 取得一列的所有行的值, checkValid是否检查列上带*号是有效列
/// </summary>
public static LPCValue ImportToSingleColumn(string file, string field, bool checkValid)
{
LPCValue result = LPCValue.CreateArray();
LPCValue arr = ImportToArray(file, checkValid);
foreach (LPCValue v in arr.AsArray.Values)
{
result.AsArray.Add(v.AsMapping [field]);
}
return(result);
}
private static LPCValue ParseAutoType(string text)
{
if (text.Length < 1)
{
return(LPCValue.Create(text));
}
char first_char = text [0];
if (first_char == '@')
{
// alias
string alias = text.Substring(1);
if (!AliasMgr.ContainsAlias(alias))
{
//LogMgr.Error("字段没有配置别名 " + alias);
return(LPCValue.Create(text));
}
object v = AliasMgr.Get(alias);
if (v is string)
{
return(LPCValue.Create((string)v));
}
if (v is int)
{
return(LPCValue.Create((int)v));
}
throw new Exception(string.Format("Unexpected alias name: {0}", alias));
}
if ((first_char == '"') || (first_char == ':'))
{
// string or buffer
return(LPCRestoreString.RestoreFromString(text));
}
if ((first_char == '(') && (text.Length > 1))
{
char second_char = text [1];
if ((second_char == '{') || (second_char == '['))
{
// mapping or array
return(LPCRestoreString.RestoreFromString(text));
}
}
if (((first_char >= '0') && (first_char <= '9')) || (first_char == '.') || (first_char == '-'))
{
// number
return(LPCRestoreString.RestoreFromString(text));
}
return(LPCValue.Create(text));
}
private static LPCValue ParseArrayType(string text)
{
LPCValue arr = LPCValue.CreateArray();
if (text == "0")
{
return(arr);
}
arr = LPCRestoreString.RestoreFromString(text);
return(arr);
}
private static LPCValue ParseMappingType(string text)
{
LPCValue m = LPCValue.CreateMapping();
if (text == "0")
{
return(m);
}
m = LPCRestoreString.RestoreFromString(text);
return(m);
}
// 设置数据
public void Add(string columnName, LPCValue v)
{
int index = 0;
if (!mOwner.columns.TryGetValue(columnName, out index))
{
return;
}
// 重置属性
mProperties[index] = v;
}
// 根据列名获取数据
public T Query <T>(string columnName, T def = default(T))
{
// 不是获取主key值，且还没有序列化完成，立刻序列化
if (columnName != mOwner.primaryKey && mRowData != null && !Deserialize())
{
NIDebug.Log("csv序列化失败({0})", mOwner.Name);
return(def);
}
int index;
if (mOwner.columns.TryGetValue(columnName, out index))
{
LPCValue prop = mProperties[index];
// 如果是LPCValue类型
if (typeof(T) == typeof(LPCValue))
{
return((T)(object)prop);
}
// 不是string数据，直接转换
if (!prop.IsString)
{
return(prop.As <T>());
}
// 就是要string，直接返回
if (typeof(T) == typeof(string))
{
return(prop.As <T>());
}
// 如果外部不是想要string，但是却得到了一个空string
// 则表示csv表格上填写的是空值，此时返回默认值
if (prop.AsString == string.Empty)
{
return(def);
}
// 外部不是想要string，却得到了有字符的string
// 走到这儿的时候已经出错了，直接使用As借口中的异常处理即可
return(prop.As <T>());
}
else
{
NIDebug.Log("{0}.csv 没有列 {1}。", mOwner.Name, columnName);
}
// 返回默认值
return(def);
}
// 增加一列
public void AddRow(int i, CsvRow row)
{
mRows[i] = row;
LPCValue pk = row.Query <LPCValue>(mPrimaryKey);
if (pk != null)
{
bool hasRow = false;
CsvRow nrow;
if (pk.IsInt)
{
hasRow = mIntRowIndexs.TryGetValue(pk.AsInt, out nrow);
if (!hasRow)
{
mIntRowIndexs.Add(pk.AsInt, row);
}
}
else if (pk.IsString)
{
hasRow = mStrRowIndexs.TryGetValue(pk.AsString, out nrow);
if (!hasRow)
{
mStrRowIndexs.Add(pk.AsString, row);
}
}
else
{
NIDebug.Log("无法添加 {0} 为主key, 主key只能是int或string!", pk.GetDescription());
return;
}
if (hasRow)
{
// 主key对应的值已经存在，挂接到链表尾
while (nrow.next != null)
{
nrow = nrow.next;
}
nrow.next = row;
row.next = null;
}
}
else
{
NIDebug.Log("主key {0} 没有值!", mPrimaryKey);
}
}
/// <summary>
/// 转换为mapping数据，key指定为某一列的值, checkValid是否检查列上带*号是有效列
/// </summary>
public static LPCValue ImportToIndexMapping(string file, string key, bool checkValid)
{
LPCValue m = LPCValue.CreateMapping();
LPCValue arr = ImportToArray(file, checkValid);
foreach (LPCValue v in arr.AsArray.Values)
{
LPCValue k = v.AsMapping [key];
if (k.IsInt)
{
m.AsMapping.Add(k.AsInt, v);
}
else if (k.IsString)
{
m.AsMapping.Add(k.AsString, v);
}
}
return(m);
}
public static LPCValue Read(CsvParser cp)
{
List <CsvField> fields = cp.Fields;
List <Dictionary <string, string> > records = cp.Records;
LPCValue list = LPCValue.CreateArray();
foreach (Dictionary <string, string> record in records)
{
LPCValue m = LPCValue.CreateMapping();
foreach (CsvField field in fields)
{
LPCValue v = Parse(field.type, record [field.name]);
m.AsMapping.Add(field.name, v);
}
list.AsArray.Add(m);
}
return(list);
}
/// <summary>
/// 取得简单的数值对
/// </summary>
public static LPCValue ImportToSingleMapping(string file, string kField, string vField, bool checkValid)
{
LPCValue result = LPCValue.CreateMapping();
LPCValue arr = ImportToArray(file, checkValid);
foreach (LPCValue v in arr.AsArray.Values)
{
LPCValue kv = v.AsMapping [kField];
LPCValue vv = v.AsMapping [vField];
if (kv.IsInt)
{
result.AsMapping.Add(kv.AsInt, vv);
}
else if (kv.IsString)
{
result.AsMapping.Add(kv.AsString, vv);
}
}
return(result);
}
private static LPCValue ParseStringType(string text)
{
return(LPCValue.Create(text));
}
/// <summary>
/// 序列化csv文件操作.
/// </summary>
public static void Save(string filePath, bool checkValid, string dir)
{
CsvFile csv = new CsvFile(System.IO.Path.GetFileNameWithoutExtension(filePath));
string[] lines = FileMgr.ReadLines(filePath);
if (lines.Length == 0)
{
NIDebug.Log("空文件 {0}", lines);
return;
}
// 解析csv文件
CsvParser cp = new CsvParser();
LPCValue m;
try
{
cp.Load(filePath, checkValid);
if (cp.Fields.Count == 0 || cp.Records.Count == 0)
{
return;
}
m = ImportMgr.Read(cp);
}
catch (Exception e)
{
NIDebug.Log("读取csv错误 {0}\n{1}", filePath, e.ToString());
return;
}
// 主key
csv.primaryKey = cp.PrimaryKey;
// 列名字对应的索引
for (int i = 0; i < cp.Fields.Count; i++)
{
csv.columns.Add(cp.Fields[i].name, i);
}
// 每列值
csv.rows = new CsvRow[m.AsArray.Count];
for (int i = 0; i < m.AsArray.Count; i++)
{
LPCValue v = m.AsArray[i];
CsvRow row = new CsvRow(csv);
for (int idx = 0; idx < cp.Fields.Count; idx++)
{
row.Add(idx, v.AsMapping[cp.Fields[idx].name]);
}
csv.AddRow(i, row);
}
// 序列化
MemoryStream ms = new MemoryStream();
CsvFileMgr.Serialize(ms, csv);
// 写入数据
string fileName = System.IO.Path.GetFileNameWithoutExtension(filePath);
// 确保路径存在
Directory.CreateDirectory(dir);
FileStream fs = new FileStream(dir + "/" + fileName + CSV_EXT, FileMode.Create, FileAccess.Write);
fs.Write(ms.GetBuffer(), 0, (int)ms.Length);
fs.Close();
}
/// <summary>
/// 序列化
/// </summary>
public static void Serialize(MemoryStream stream, CsvFile csv)
{
// 初始化缓存
if (mSerBuffer == null)
{
mSerBuffer = new byte[1024 * 1024];
}
FileMgr.WriteInt(stream, CsvFileMgr.Version);
FileMgr.WriteString(stream, csv.Name);
FileMgr.WriteString(stream, csv.primaryKey);
// 写入主key类型
LPC.LPCValue.ValueType pkeyType = LPCValue.ValueType.INT;
if (csv.rows.Length > 0)
{
var row = csv.rows[0];
var pkey = row.Query <LPCValue>(csv.primaryKey);
pkeyType = pkey.type;
FileMgr.WriteInt(stream, (int)pkeyType);
}
// 列名
FileMgr.WriteInt(stream, csv.columns.Count);
foreach (var kv in csv.columns)
{
FileMgr.WriteString(stream, kv.Key);
FileMgr.WriteInt(stream, kv.Value);
}
// 行数
FileMgr.WriteInt(stream, csv.rows.Length);
// 写入每行的主key
for (int i = 0; i < csv.rows.Length; i++)
{
var row = csv.rows[i];
if (pkeyType == LPCValue.ValueType.INT)
{
var pkey = row.Query <int>(csv.primaryKey);
FileMgr.WriteInt(stream, pkey);
}
else
{
var pkey = row.Query <string>(csv.primaryKey);
FileMgr.WriteString(stream, pkey);
}
}
// 写入行长度和内容
for (int i = 0; i < csv.rows.Length; i++)
{
var row = csv.rows[i];
int len = 0;
for (var idx = 0; idx < csv.columns.Count; idx++)
{
len += LPCValue.SaveToBuffer(mSerBuffer, len, row.properties[idx]);
}
FileMgr.WriteInt(stream, len);
stream.Write(mSerBuffer, 0, len);
}
// 释放
mSerBuffer = null;
}
// 设置数据
public void Add(int i, LPCValue v)
{
mProperties[i] = v;
}
/// <summary>
/// 反序列化.
/// </summary>
public static CsvFile Deserialize(MemoryStream stream)
{
int ver = FileMgr.ReadInt(stream);
if (ver != CsvFileMgr.Version)
{
NIDebug.Log("Csv版本 {0} 错误, 最新版本 {1}", ver, CsvFileMgr.Version);
return(null);
}
// 文件名
string name = FileMgr.ReadString(stream);
CsvFile csv = new CsvFile(name);
csv.primaryKey = FileMgr.ReadString(stream);
// 主key类型
var pkeyType = (LPC.LPCValue.ValueType)FileMgr.ReadInt(stream);
// 列名
int n = FileMgr.ReadInt(stream);
csv.columns = new Dictionary <string, int>(n);
for (int i = 0; i < n; i++)
{
string k = FileMgr.ReadString(stream);
int v = FileMgr.ReadInt(stream);
csv.columns.Add(k, v);
}
// 行数
n = FileMgr.ReadInt(stream);
csv.rows = new CsvRow[n];
// 主key的列
int pkeyIdx = csv.columns[csv.primaryKey];
// 每行主key
for (var i = 0; i < n; i++)
{
var row = new CsvRow(csv);
if (pkeyType == LPCValue.ValueType.INT)
{
int pkey = FileMgr.ReadInt(stream);
row.Add(pkeyIdx, LPCValue.Create(pkey));
}
else
{
string pkey = FileMgr.ReadString(stream);
row.Add(pkeyIdx, LPCValue.Create(pkey));
}
csv.AddRow(i, row);
}
// 行数据
for (int i = 0; i < n; i++)
{
int len = FileMgr.ReadInt(stream);
csv.rows[i].rowData = new byte[len];
stream.Read(csv.rows[i].rowData, 0, len);
}
return(csv);
}
