/// <summary>
/// 查询数据
/// </summary>
/// <param name="queryData">查询数据</param>
/// <param name="onQuery"></param>
/// <param name="isDeSerializeStream">是否反序列化网络流，否则需要 Copy 数据</param>
internal void Query(ref SubArray <byte> queryData, Func <AutoCSer.Net.TcpServer.ReturnValue <IdentityReturnParameter>, bool> onQuery, bool isDeSerializeStream)
{
try
{
queryBuffer.Set(ref queryData);
fixed(byte *dataFixed = queryData.Array)
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, queryBuffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
parser.SetOnReturn(onQuery, isDeSerializeStream);
onQuery = null;
try
{
dataStructure.Node.Query(ref parser);
}
finally
{
parser.CallOnReturnDistributionMessage();
}
}
}
}
finally
{
if (onQuery != null)
{
onQuery(new IdentityReturnParameter(ReturnType.DataStructureIdentityError));
}
}
}
/// <summary>
/// 操作数据
/// </summary>
/// <param name="buffer">数据缓冲区</param>
/// <returns>返回参数</returns>
internal ValueData.Data Operation(Buffer buffer)
{
if (CanWrite)
{
fixed(byte *dataFixed = buffer.Array.Array)
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, buffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
dataStructure.Node.Operation(ref parser);
if (parser.IsOperation)
{
onOperation(buffer);
}
else
{
buffer.FreeReference();
}
return(parser.ReturnParameter);
}
}
buffer.FreeReference();
return(new ValueData.Data(ReturnType.DataStructureIdentityError));
}
buffer.FreeReference();
return(new ValueData.Data(ReturnType.CanNotWrite));
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="queryData">查询数据</param>
/// <param name="onQuery"></param>
/// <param name="isDeSerializeStream">是否反序列化网络流，否则需要 Copy 数据</param>
internal void Query(ref SubArray <byte> queryData, AutoCSer.Net.TcpServer.ServerCallback <ReturnParameter> onQuery, bool isDeSerializeStream)
{
try
{
queryBuffer.Set(ref queryData);
fixed(byte *dataFixed = queryData.GetFixedBuffer())
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, queryBuffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
parser.SetOnReturn(onQuery, isDeSerializeStream);
onQuery = null;
try
{
dataStructure.Node.Query(ref parser);
}
finally
{
parser.CallOnReturn();
}
}
}
}
finally
{
if (onQuery != null)
{
onQuery.Callback(new ReturnParameter(ReturnType.DataStructureIdentityError));
}
}
}
/// <summary>
/// 加载操作数据
/// </summary>
/// <param name="loadData">加载数据</param>
/// <returns>是否加载成功</returns>
internal bool Load(ref LoadData loadData)
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, ref loadData);
do
{
if (parser.Load(ref loadData))
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.LoadArraySize:
int size = parser.ReadInt();
if (parser.IsEnd)
{
Array = new DataStructureItem[size];
isRebuild = true;
break;
}
return(false);
case OperationParameter.OperationType.GetOrCreateDataStructure:
if (loadDataStructure(loadData.Buffer))
{
break;
}
return(false);
case OperationParameter.OperationType.RemoveDataStructure:
if (loadRemoveDataStructure(loadData.Buffer))
{
break;
}
return(false);
case OperationParameter.OperationType.LoadIndexIdentity:
if (loadIndexIdentity(ref parser))
{
break;
}
return(false);
default:
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
dataStructure.Node.Operation(ref parser);
}
break;
}
}
else
{
return(false);
}
}while (loadData.IsNext);
return(true);
}
/// <summary>
/// 加载数据结构标识
/// </summary>
/// <param name="identity"></param>
/// <param name="dataStructure"></param>
/// <returns></returns>
internal bool Load(ulong identity, out ServerDataStructure dataStructure)
{
dataStructure = DataStructure;
if (DataStructure == null)
{
Identity = identity;
return(true);
}
return(Identity == identity);
}
/// <summary>
/// 操作数据
/// </summary>
/// <param name="buffer">数据缓冲区</param>
/// <param name="onOperation"></param>
internal void Operation(Buffer buffer, Func <AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter>, bool> onOperation)
{
int isReturn = 0;
try
{
if (CanWrite)
{
fixed(byte *dataFixed = buffer.Array.Array)
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, buffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
parser.OnReturn = onOperation;
try
{
dataStructure.Node.Operation(ref parser);
}
finally
{
if (parser.OnReturn == null)
{
isReturn = 1;
}
}
if (parser.IsOperation)
{
this.onOperation(buffer);
}
else
{
buffer.FreeReference();
}
return;
}
}
buffer.FreeReference();
isReturn = 1;
onOperation(new ReturnParameter(ReturnType.DataStructureIdentityError));
return;
}
buffer.FreeReference();
}
finally
{
if (isReturn == 0)
{
onOperation(new ReturnParameter(ReturnType.CanNotWrite));
}
}
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="queryData">查询数据</param>
/// <returns>返回参数</returns>
internal ValueData.Data Query(ref SubArray <byte> queryData)
{
queryBuffer.Set(ref queryData);
fixed(byte *dataFixed = queryData.Array)
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, queryBuffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
dataStructure.Node.Query(ref parser);
return(parser.ReturnParameter);
}
}
return(new ValueData.Data(ReturnType.DataStructureIdentityError));
}
/// <summary>
/// 添加数据结构定义
/// </summary>
/// <param name="buffer">数据缓冲区</param>
/// <returns>数据结构索引标识</returns>
internal IndexIdentity GetOrCreateDataStructure(Buffer buffer)
{
if (CanWrite)
{
DataStructureBuffer dataStructureBuffer = new DataStructureBuffer(buffer);
HashString name = dataStructureBuffer.CacheName;
ServerDataStructure dataStructure;
if (DataStructures.TryGetValue(name, out dataStructure))
{
if (dataStructure.IsNodeData(ref dataStructureBuffer.Data))
{
buffer.FreeReference();
return(dataStructure.Identity);
}
buffer.FreeReference();
return(new IndexIdentity {
ReturnType = ReturnType.DataStructureNameExists
});
}
OnDataStructureCreated = onDataStructureCreated;
if ((dataStructure = new ServerDataStructure(this, buffer, ref dataStructureBuffer)).Node != null)
{
int index = getFreeIndex();
DataStructures.Add(name, dataStructure);
Array[index].Set(index, dataStructure);
buffer.SetIdentity(ref dataStructure.Identity);
onOperation(buffer);
OnDataStructureCreated(dataStructure.Identity);
OnDataStructureCreated = onDataStructureCreated;
return(dataStructure.Identity);
}
buffer.FreeReference();
return(new IndexIdentity {
ReturnType = dataStructure.ReturnType
});
}
buffer.FreeReference();
return(new IndexIdentity {
ReturnType = ReturnType.CanNotWrite
});
}
/// <summary>
/// 添加数据结构定义
/// </summary>
/// <param name="buffer">数据缓冲区</param>
/// <returns></returns>
private bool loadDataStructure(Buffer buffer)
{
DataStructureBuffer dataStructureBuffer = new DataStructureBuffer(buffer);
ServerDataStructure dataStructure = new ServerDataStructure(this, buffer, ref dataStructureBuffer);
int index = dataStructureBuffer.Identity.Index;
if (loadBuffer == null)
{
if (!isRebuild && index != getFreeIndex())
{
return(false);
}
}
else if (index >= Array.Length)
{
Array = Array.copyNew(Math.Max(Array.Length << 1, Math.Max(sizeof(int), index + 1)));
}
DataStructures.Add(dataStructureBuffer.CacheName, dataStructure);
Array[index].Load(dataStructure);
return(true);
}
internal void Load(ServerDataStructure dataStructure)
{
Identity = dataStructure.Identity.SetSuccess();
DataStructure = dataStructure;
}
internal void LoadFree(ulong identity)
{
DataStructure = null;
Identity = identity;
}
internal ulong Free()
{
DataStructure = null;
return(++Identity);
}
internal void Set(int index, ServerDataStructure dataStructure)
{
dataStructure.Identity.Set(index, Identity);
DataStructure = dataStructure;
}
