/// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="parser">参数解析</param>
        internal override void QueryEnd(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <keyType> key;

            switch (parser.OperationType)
            {
            case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(fragmentDictionary.Count); return;

            case OperationParameter.OperationType.GetValue:
                if (HashCodeKey <keyType> .Get(ref parser, out key))
                {
                    valueType value;
                    if (fragmentDictionary.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(fragmentDictionary.ContainsKey(key));
                }
                return;
            }
            parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
        }
Exemple #2
0
        /// <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();
            }
        }
Exemple #3
0
        /// <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>
        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)
        {
            HashCodeKey <keyType> key;

            if (HashCodeKey <keyType> .Get(ref parser, out key))
            {
                if (fragmentDictionary.Remove(key))
                {
                    parser.SetOperationReturnParameter();
                }
                else
                {
                    parser.ReturnParameter.ReturnParameterSet(false);
                }
            }
        }
Exemple #6
0
        /// <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;
            }
        }
Exemple #7
0
        /// <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);
                }
            }
        }
Exemple #8
0
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="parser">参数解析</param>
        internal override void QueryEnd(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <valueType> key;

            switch (parser.OperationType)
            {
            case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(hashSet.Count); return;

            case OperationParameter.OperationType.ContainsKey:
                if (HashCodeKey <valueType> .Get(ref parser, out key))
                {
                    parser.ReturnParameter.ReturnParameterSet(hashSet.Contains(key));
                }
                return;
            }
            parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
        }
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="parser"></param>
        private void remove(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <keyType> key;

            if (HashCodeKey <keyType> .Get(ref parser, out key))
            {
                System.Collections.Generic.Dictionary <HashCodeKey <keyType>, valueType> dictionary = dictionarys[key.HashCode & 0xff];
                if (dictionary != null && dictionary.Remove(key))
                {
                    --count;
                    parser.SetOperationReturnParameter();
                }
                else
                {
                    parser.ReturnParameter.ReturnParameterSet(false);
                }
            }
        }
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="parser"></param>
        private void remove(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <valueType> key;

            if (HashCodeKey <valueType> .Get(ref parser, out key))
            {
                System.Collections.Generic.HashSet <HashCodeKey <valueType> > hashSet = hashSets[key.HashCode & 0xff];
                if (hashSet != null && hashSet.Remove(key))
                {
                    --count;
                    parser.SetOperationReturnParameter();
                }
                else
                {
                    parser.ReturnParameter.ReturnParameterSet(false);
                }
            }
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="parser">参数解析</param>
        internal override void QueryEnd(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <valueType> key;

            switch (parser.OperationType)
            {
            case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(count); return;

            case OperationParameter.OperationType.ContainsKey:
                if (HashCodeKey <valueType> .Get(ref parser, out key))
                {
                    System.Collections.Generic.HashSet <HashCodeKey <valueType> > hashSet = hashSets[key.HashCode & 0xff];
                    parser.ReturnParameter.ReturnParameterSet(hashSet != null && hashSet.Contains(key));
                }
                return;
            }
            parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
        }
        /// <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)
            {
                valueType value = ValueData.Data <valueType> .GetData(ref parser.ValueData);

                System.Collections.Generic.Dictionary <HashCodeKey <keyType>, valueType> dictionary = dictionarys[key.HashCode & 0xff];
                if (dictionary == null)
                {
                    dictionarys[key.HashCode & 0xff] = dictionary = AutoCSer.DictionaryCreator <HashCodeKey <keyType> > .Create <valueType>();
                }
                int count = dictionary.Count;
                dictionary[key] = value;
                this.count     += dictionary.Count - count;
                parser.SetOperationReturnParameter();
            }
            else
            {
                parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
            }
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="parser">参数解析</param>
        internal override void QueryEnd(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <keyType> key;

            switch (parser.OperationType)
            {
            case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(count); return;

            case OperationParameter.OperationType.GetValue:
                if (HashCodeKey <keyType> .Get(ref parser, out key))
                {
                    System.Collections.Generic.Dictionary <HashCodeKey <keyType>, valueType> dictionary = dictionarys[key.HashCode & 0xff];
                    valueType value;
                    if (dictionary != null && 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))
                {
                    System.Collections.Generic.Dictionary <HashCodeKey <keyType>, valueType> dictionary = dictionarys[key.HashCode & 0xff];
                    parser.ReturnParameter.ReturnParameterSet(dictionary != null && dictionary.ContainsKey(key));
                }
                return;
            }
            parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
        }
        /// <summary>
        /// 设置数据
        /// </summary>
        /// <param name="parser"></param>
        private void setValue(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <valueType> key;

            if (HashCodeKey <valueType> .Get(ref parser, out key))
            {
                System.Collections.Generic.HashSet <HashCodeKey <valueType> > hashSet = hashSets[key.HashCode & 0xff];
                if (hashSet == null)
                {
                    hashSets[key.HashCode & 0xff] = hashSet = AutoCSer.HashSetCreator <HashCodeKey <valueType> > .Create();
                }
                int count = hashSet.Count;
                hashSet.Add(key);
                if (hashSet.Count != count)
                {
                    ++this.count;
                    parser.SetOperationReturnParameter();
                }
                else
                {
                    parser.ReturnParameter.ReturnParameterSet(true);
                }
            }
        }
        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="parser"></param>
        private unsafe void update(ref OperationParameter.NodeParser parser)
        {
            HashCodeKey <keyType> key;

            if (HashCodeKey <keyType> .Get(ref parser, out key))
            {
                valueType value;
                System.Collections.Generic.Dictionary <HashCodeKey <keyType>, valueType> dictionary;
                if (fragmentDictionary.TryGetValue(key, out value, out dictionary))
                {
                    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)
                        {
                            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:
                                    dictionary[key] = 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;
                            }
                        }
                    }
                }
                else
                {
                    parser.ReturnParameter.ReturnType = ReturnType.NotFoundDictionaryKey;
                    return;
                }
            }
            parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
        }