/// <summary>
/// 添加获取数据任务
/// </summary>
/// <param name="reader"></param>
/// <param name="parser"></param>
internal GetMessage(FileReader reader, ref OperationParameter.NodeParser parser) : base(reader.Node)
{
OnReturn = parser.OnReturn;
IsReturnStream = parser.ReturnParameter.IsReturnDeSerializeStream;
Identity = parser.ValueData.Int64.ULong;
this.reader = reader;
parser.OnReturn = null;
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.MessageQueueEnqueue: enqueue(ref parser, ValueData.Data <valueType> .DataType); return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
/// <summary>
/// 数据缓冲区
/// </summary>
/// <param name="node"></param>
/// <param name="parser"></param>
internal Buffer(Node node, ref OperationParameter.NodeParser parser)
{
Data = parser.ValueData;
onReturn = parser.OnReturn;
Node = node;
BufferCount = Data.CopyToMessageQueueBufferCount();
parser.OnReturn = null;
}
/// <summary>
/// 修改数据
/// </summary>
/// <param name="parser"></param>
private unsafe void update(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if ((uint)index < count)
{
byte *read = parser.Read;
if (parser.LoadValueData() && !parser.IsEnd)
{
valueType updateValue = ValueData.Data <valueType> .GetData(ref parser.ValueData);
if (parser.LoadValueData() && parser.ValueData.Type == ValueData.DataType.UInt)
{
valueType[] array = arrays[index >> FragmentArray.ArrayShift];
valueType value = array[index &= FragmentArray.ArraySizeAnd];
uint type = parser.ValueData.Int64.UInt;
OperationUpdater.LogicType logicType = (OperationUpdater.LogicType)(byte)(type >> 16);
if (logicType != OperationUpdater.LogicType.None && parser.LoadValueData() && parser.IsEnd)
{
if (OperationUpdater.Data <valueType> .IsLogicData(logicType, value, ValueData.Data <valueType> .GetData(ref parser.ValueData)))
{
logicType = OperationUpdater.LogicType.None;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.Success;
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, value);
return;
}
}
if (logicType == OperationUpdater.LogicType.None && parser.IsEnd)
{
switch (parser.ReturnParameter.ReturnType = OperationUpdater.Data <valueType> .UpdateData((OperationUpdater.OperationType)(ushort) type, ref value, updateValue))
{
case ReturnType.Success:
array[index] = value;
parser.UpdateOperation(read, value, OperationParameter.OperationType.SetValue);
goto SETDATA;
case ReturnType.Unknown:
parser.ReturnParameter.ReturnType = ReturnType.Success;
SETDATA:
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, value);
return;
}
return;
}
}
}
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
/// <summary>
/// 消息节点 数据节点
/// </summary>
/// <param name="parent"></param>
/// <param name="parser"></param>
protected Node(Cache.Node parent, ref OperationParameter.NodeParser parser) : base(parent)
{
Cache = parser.Cache;
if (Cache.IsFile)
{
packet = parser.CreateReadPacket(OperationParameter.Serializer.HeaderSize);
tryStart();
}
}
/// <summary>
/// 设置数据
/// </summary>
/// <param name="parser"></param>
private void setValue(ref OperationParameter.NodeParser parser)
{
HashCodeKey <valueType> key;
if (HashCodeKey <valueType> .Get(ref parser, out key))
{
hashSet.Add(key);
parser.SetOperationReturnParameter();
}
}
/// <summary>
/// 获取下一个节点
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
internal override Cache.Node GetOperationNext(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.SetValue: setValue(ref parser); break;
default: parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError; break;
}
return(null);
}
/// <summary>
/// 获取关键字
/// </summary>
/// <param name="parser"></param>
/// <param name="key"></param>
/// <returns></returns>
internal static bool Get(ref OperationParameter.NodeParser parser, out HashCodeKey <valueType> key)
{
if (parser.ValueData.Type == ValueData.Data <valueType> .DataType)
{
key = new HashCodeKey <valueType>(ValueData.Data <valueType> .GetData(ref parser.ValueData));
return(true);
}
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
key = default(HashCodeKey <valueType>);
return(false);
}
private unsafe void setReturnParameter(ref OperationParameter.NodeParser parser)
{
if (parser.ValueData.Int64.Bool)
{
ValueData.Data <keyType> .SetData(ref parser.ReturnParameter, heap.Array[heap.Heap.Int[1]].Key);
}
else
{
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, heap.Array[heap.Heap.Int[1]].Value);
}
}
/// <summary>
/// 数据位取反
/// </summary>
/// <param name="parser">参数解析</param>
private void setNegate(ref OperationParameter.NodeParser parser)
{
BitmapIndex index = new BitmapIndex(this, ref parser);
if (index.Map != null)
{
bool isBit = index.SetNegate() != 0;
parser.ReturnParameter.ReturnParameterSet(isBit);
parser.SetOperationType(isBit ? OperationParameter.OperationType.SetValue : OperationParameter.OperationType.Remove);
}
}
/// <summary>
/// 获取下一个节点
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
private nodeType getNext(ref OperationParameter.NodeParser parser)
{
keyType key;
if (HashCodeKey<keyType>.Get(ref parser, out key))
{
nodeType node;
if (dictionary.TryGetValue(key, out node)) return node;
parser.ReturnParameter.ReturnType = ReturnType.NotFoundDictionaryKey;
}
return null;
}
/// <summary>
/// 获取下一个节点
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
internal override Cache.Node GetOperationNext(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.InsertBefore: insertBefore(ref parser); break;
case OperationParameter.OperationType.InsertAfter: insertAfter(ref parser); break;
default: parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError; break;
}
return(null);
}
/// <summary>
/// 弹出数据
/// </summary>
/// <param name="parser"></param>
private void removeTop(ref OperationParameter.NodeParser parser)
{
if (heap.Count != 0)
{
heap.RemoveTop();
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.HeapIsEmpty;
}
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.InsertBefore:
if (parser.ValueData.Type == ValueData.DataType.Long)
{
if (parser.OnReturn != null)
{
QueueTaskThread.TryEnter enter = new QueueTaskThread.TryEnter(this);
enter.LinkNode = new LinkNode(this, ref parser);
QueueTaskThread.Thread.Default.Add(enter);
}
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
return;
case OperationParameter.OperationType.SetValue:
if (parser.ValueData.Type == ValueData.DataType.Long)
{
if (parser.OnReturn != null)
{
QueueTaskThread.Enter enter = new QueueTaskThread.Enter(this);
enter.LinkNode = new LinkNode(this, ref parser);
QueueTaskThread.Thread.Default.Add(enter);
}
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
return;
case OperationParameter.OperationType.Remove:
if (parser.ValueData.Type == ValueData.DataType.ULong)
{
if (parser.OnReturn != null)
{
QueueTaskThread.Thread.Default.Add(new QueueTaskThread.Exit(this, ref parser));
}
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if ((uint)index < count)
{
arrays[index >> FragmentArray.ArrayShift][index & FragmentArray.ArraySizeAnd] = default(valueType);
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
/// <summary>
/// 获取或者创建节点
/// </summary>
/// <param name="parser"></param>
private void getOrCreateNode(ref OperationParameter.NodeParser parser)
{
keyType key;
if (HashCodeKey<keyType>.Get(ref parser, out key))
{
if (!dictionary.ContainsKey(key))
{
dictionary.Set(key, nodeConstructor(this, ref parser));
parser.IsOperation = true;
}
parser.ReturnParameter.ReturnParameterSet(true);
}
else parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
keyType key;
switch (parser.OperationType)
{
case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(Dictionary.Count); return;
case OperationParameter.OperationType.GetValue:
if (HashCodeKey <keyType> .Get(ref parser, out key))
{
valueType value;
if (Dictionary.TryGetValue(key, out value))
{
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, value);
parser.ReturnParameter.ReturnType = ReturnType.Success;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.NotFoundDictionaryKey;
}
}
return;
case OperationParameter.OperationType.ContainsKey:
if (HashCodeKey <keyType> .Get(ref parser, out key))
{
parser.ReturnParameter.ReturnParameterSet(Dictionary.ContainsKey(key));
}
return;
case OperationParameter.OperationType.GetValues:
if (parser.OnReturn != null)
{
if (parser.ValueData.Type == ValueData.DataType.ULong)
{
ulong count = parser.ValueData.Int64.ULong;
int skipCount = (int)(uint)count, getCount = (int)(uint)(count >> 32);
if (skipCount >= 0 && getCount != 0)
{
parser.Cache.TcpServer.CallQueue.Add(new ServerCall.SearchTreeDictionaryGetter <keyType, valueType>(this, skipCount, getCount, ref parser));
}
}
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.GetValue:
BitmapIndex index = new BitmapIndex(Maps, ref parser);
if (index.Map != null)
{
parser.ReturnParameter.ReturnParameterSet(index.Get() != 0);
}
return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
protected void enqueue(ref OperationParameter.NodeParser parser, AutoCSer.CacheServer.ValueData.DataType dataType)
{
if (parser.ValueData.Type == dataType)
{
if (parser.OnReturn != null)
{
Writer.Append(new Buffer(this, ref parser));
}
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
}
/// <summary>
/// 获取下一个节点
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
private nodeType getNext(ref OperationParameter.NodeParser parser)
{
HashCodeKey <keyType> key;
if (HashCodeKey <keyType> .Get(ref parser, out key))
{
nodeType node;
if (fragmentDictionary.TryGetValue(key, out node))
{
return(node);
}
parser.ReturnParameter.ReturnType = ReturnType.NotFoundDictionaryKey;
}
return(null);
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
LinkNode <valueType> node = getNode(parser.GetValueData(int.MinValue));
if (node != null)
{
node.Remove(this);
--count;
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.LinkIndexOutOfRange;
}
}
/// <summary>
/// 设置数据
/// </summary>
/// <param name="parser"></param>
private void setValue(ref OperationParameter.NodeParser parser)
{
HashCodeKey <keyType> key;
if (HashCodeKey <keyType> .Get(ref parser, out key) && parser.LoadValueData() && parser.IsEnd && parser.ValueData.Type == ValueData.Data <valueType> .DataType)
{
fragmentDictionary[key] = ValueData.Data <valueType> .GetData(ref parser.ValueData);
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
}
/// <summary>
/// 删除节点
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
keyType key;
if (HashCodeKey<keyType>.Get(ref parser, out key))
{
nodeType node;
if (dictionary.Remove(ref key, out node))
{
parser.SetOperationReturnParameter();
node.OnRemoved();
}
else parser.ReturnParameter.ReturnParameterSet(false);
}
else parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.MessageQueueEnqueue: enqueue(ref parser, ValueData.Data <valueType> .DataType); return;
case OperationParameter.OperationType.MessageQueueGetDequeueIdentity:
Config.QueueReader config = getReaderConfig(ref parser);
if (config != null)
{
if (reader == null || reader.IsDisposed)
{
QueueTaskThread.Thread.Default.Add(new QueueTaskThread.GetIdentity(this, config, ref parser));
return;
}
else
{
parser.ReturnParameter.Set(reader.Identity);
}
}
return;
case OperationParameter.OperationType.MessageQueueDequeue:
if (parser.ValueData.Type == ValueData.DataType.ULong)
{
File.QueueReader reader = this.reader;
if (reader != null && !reader.IsDisposed)
{
if (parser.OnReturn != null)
{
QueueTaskThread.Thread.Default.Add(new QueueTaskThread.GetMessage(reader, ref parser));
}
}
else
{
parser.ReturnParameter.Type = ReturnType.MessageQueueNotFoundReader;
}
}
else
{
parser.ReturnParameter.Type = ReturnType.ValueDataLoadError;
}
return;
case OperationParameter.OperationType.MessageQueueSetDequeueIdentity: setDequeueIdentity(ref parser, this.reader); return;
}
parser.ReturnParameter.Type = ReturnType.OperationTypeError;
}
/// <summary>
/// 设置数据
/// </summary>
/// <param name="parser"></param>
private void setValue(ref OperationParameter.NodeParser parser)
{
keyType key;
if (HashCodeKey <keyType> .Get(ref parser, out key) && parser.LoadValueData() && parser.IsEnd && parser.ValueData.Type == ValueData.Data <valueType> .DataType)
{
valueType value = ValueData.Data <valueType> .GetData(ref parser.ValueData);
heap.Push(key, ref value);
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
}
/// <summary>
/// 清除数据位
/// </summary>
/// <param name="parser">参数解析</param>
private void clear(ref OperationParameter.NodeParser parser)
{
BitmapIndex index = new BitmapIndex(Maps, ref parser);
if (index.Map != null)
{
if (index.IsOperationClear())
{
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnParameterSet(false);
}
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
HashCodeKey <keyType> key;
if (HashCodeKey <keyType> .Get(ref parser, out key))
{
if (fragmentDictionary.Remove(key))
{
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnParameterSet(false);
}
}
}
/// <summary>
/// 设置数据位
/// </summary>
/// <param name="parser">参数解析</param>
private void set(ref OperationParameter.NodeParser parser)
{
BitmapIndex index = new BitmapIndex(this, ref parser);
if (index.Map != null)
{
if (index.IsOperationSet())
{
parser.SetOperationReturnParameterFalse();
}
else
{
parser.ReturnParameter.ReturnParameterSet(true);
}
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
HashCodeKey <valueType> key;
if (HashCodeKey <valueType> .Get(ref parser, out key))
{
if (hashSet.Remove(key))
{
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnParameterSet(false);
}
}
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(dictionary.Count); return;
case OperationParameter.OperationType.ContainsKey:
keyType key;
if (HashCodeKey<keyType>.Get(ref parser, out key)) parser.ReturnParameter.ReturnParameterSet(dictionary.ContainsKey(key));
return;
case OperationParameter.OperationType.CreateShortPath:
nodeType node = getNext(ref parser);
if (node != null) node.CreateShortPath(ref parser);
return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
