/// <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; }