コード例 #1
0
        /// <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>, nodeType> dictionary = dictionarys[key.HashCode & 0xff];
                if (dictionary != null)
                {
                    nodeType node;
                    if (dictionary.TryGetValue(key, out node))
                    {
                        dictionary.Remove(key);
                        --count;
                        parser.SetOperationReturnParameter();
                        node.OnRemoved();
                        return;
                    }
                }
                parser.ReturnParameter.ReturnParameterSet(false);
            }
            else
            {
                parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
            }
        }
コード例 #2
0
ファイル: HashSet.cs プロジェクト: zhangzheng1205/AutoCSer
        /// <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();
            }
        }
コード例 #3
0
ファイル: ArrayHeap.cs プロジェクト: zhangzheng1205/AutoCSer
 /// <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;
     }
 }
コード例 #4
0
ファイル: FragmentArray.cs プロジェクト: AutoCSer/AutoCSer
        /// <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;
            }
        }
コード例 #5
0
        /// <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;
            }
        }
コード例 #6
0
 /// <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;
 }
コード例 #7
0
        /// <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;
            }
        }
コード例 #8
0
ファイル: HashSet.cs プロジェクト: zhangzheng1205/AutoCSer
        /// <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);
                }
            }
        }
コード例 #9
0
ファイル: ArrayHeap.cs プロジェクト: zhangzheng1205/AutoCSer
        /// <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;
            }
        }
コード例 #10
0
ファイル: Bitmap.cs プロジェクト: AutoCSer/AutoCSer
        /// <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);
                }
            }
        }
コード例 #11
0
        /// <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);
                }
            }
        }
コード例 #12
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))
            {
                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);
                }
            }
        }
コード例 #13
0
        /// <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);
                }
            }
        }
コード例 #14
0
        /// <summary>
        /// 后置插入数据
        /// </summary>
        /// <param name="parser"></param>
        private void insertAfter(ref OperationParameter.NodeParser parser)
        {
            int index = parser.GetValueData(int.MinValue);
            LinkNode <valueType> node = getNode(index);

            if (node != null)
            {
                if (parser.LoadValueData() && parser.IsEnd && parser.ValueData.Type == ValueData.Data <valueType> .DataType)
                {
                    LinkNode <valueType> newNode = new LinkNode <valueType>(node, node.Next, ValueData.Data <valueType> .GetData(ref parser.ValueData));
                    if (node.InsertAfter(newNode))
                    {
                        end = newNode;
                    }
                    ++count;
                    parser.SetOperationReturnParameter();
                }
                else
                {
                    parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
                }
            }
            else if ((count | (index ^ -1)) == 0)
            {
                if (parser.LoadValueData() && parser.IsEnd && parser.ValueData.Type == ValueData.Data <valueType> .DataType)
                {
                    setHeadEnd(ref parser, ValueData.Data <valueType> .GetData(ref parser.ValueData));
                }
                else
                {
                    parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
                }
            }
            else
            {
                parser.ReturnParameter.ReturnType = ReturnType.LinkIndexOutOfRange;
            }
        }
コード例 #15
0
        /// <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;
            }
        }
コード例 #16
0
ファイル: FragmentArray.cs プロジェクト: AutoCSer/AutoCSer
        /// <summary>
        /// 设置数据
        /// </summary>
        /// <param name="parser"></param>
        private void setValue(ref OperationParameter.NodeParser parser)
        {
            int indexParameter = parser.GetValueData(-1);

            if (indexParameter >= 0 && parser.LoadValueData() && parser.IsEnd)
            {
                if (parser.ValueData.Type == ValueData.Data <valueType> .DataType)
                {
                    valueType value = ValueData.Data <valueType> .GetData(ref parser.ValueData);

                    int arrayIndex = indexParameter >> FragmentArray.ArrayShift;
                    if (arrayIndex >= arrays.Length)
                    {
                        valueType[][] newArrays = arrays.copyNew(arrayIndex + 1, arrays.Length);
                        for (int newIndex = arrays.Length; newIndex != newArrays.Length; newArrays[newIndex++] = new valueType[FragmentArray.ArraySize])
                        {
                            ;
                        }
                        arrays = newArrays;
                    }
                    arrays[arrayIndex][indexParameter & FragmentArray.ArraySizeAnd] = value;
                    if (indexParameter >= count)
                    {
                        count = indexParameter + 1;
                    }
                    parser.SetOperationReturnParameter();
                }
                else
                {
                    parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
                }
            }
            else
            {
                parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
            }
        }
コード例 #17
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))
            {
                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);
                }
            }
        }
コード例 #18
0
 /// <summary>
 /// 添加第一个节点
 /// </summary>
 /// <param name="parser"></param>
 /// <param name="value"></param>
 private void setHeadEnd(ref OperationParameter.NodeParser parser, valueType value)
 {
     head  = end = new LinkNode <valueType>(value);
     count = 1;
     parser.SetOperationReturnParameter();
 }