示例#1
0
        /// <summary>
        /// Inserts an element after another in the list.
        /// </summary>
        /// <param name="preceding">The element already in the list.</param>
        /// <param name="element">The element to be inserted.</param>
        /// <remarks>
        /// Passing preceding as null will add the element at the
        /// front of the list.
        /// </remarks>
        /// <exception cref="InvalidOperationException">Thrown if the element is already in a list.</exception>
        public void InsertAfter(IDLElement preceding, IDLElement element)
        {
            Flush();

            if (element.Previous != null || element.Next != null)
            {
                throw new InvalidOperationException(AlreadyInListMsg);
            }

            if (preceding == null)
            {
                AddToFront(element);
            }
            else
            {
                element.Previous = preceding;
                element.Next     = preceding.Next;
                preceding.Next   = element;

                if (object.ReferenceEquals(element.Next, this))
                {
                    this.back = element;
                }
                else
                {
                    ((IDLElement)element.Next).Previous = element;
                }

                this.count++;
            }
        }
示例#2
0
        /// <summary>
        /// Adds an element to the end of the list.
        /// </summary>
        /// <param name="element">The element to be inserted.</param>
        /// <exception cref="InvalidOperationException">Thrown if the element is already in a list.</exception>
        public void AddToEnd(IDLElement element)
        {
            Flush();

            if (element.Previous != null || element.Next != null)
            {
                throw new InvalidOperationException(AlreadyInListMsg);
            }

            if (this.front == null)
            {
                // The list is empty

                this.front       = element;
                this.back        = element;
                element.Previous = this;
                element.Next     = this;
            }
            else
            {
                element.Previous = this.back;
                element.Next     = this;
                this.back.Next   = element;
                this.back        = element;
            }

            this.count++;
        }
示例#3
0
        /// <summary>
        /// Removes all elements from the list.
        /// </summary>
        public void Clear()
        {
            Flush();

            this.front = null;
            this.back  = null;
            this.count = 0;
        }
示例#4
0
        private IDLElement lastElement;         // The last referenced element (or null)

        /// <summary>
        /// Constructs an empty list.
        /// </summary>
        public DoubleList()
        {
            this.front       = null;
            this.back        = null;
            this.count       = 0;
            this.opCount     = 0;
            this.lastElement = null;
            this.lastIndex   = -1;
        }
示例#5
0
        /// <summary>
        /// Returns the element at the specified position in the list.
        /// </summary>
        /// <remarks>
        /// <note>
        /// Index=0 references the element at the front of the list and
        /// Index=Count-1 reference the last element in the list.
        /// </note>
        /// <note>
        /// The class optimizes for scanning forward or backwards
        /// through the list.
        /// </note>
        /// </remarks>
        /// <exception cref="IndexOutOfRangeException">Thrown if the index is not in the range <b>0..Count-1</b>.</exception>
        public IDLElement this[int index]
        {
            get
            {
                if (index < 0 || index >= count)
                {
                    throw new IndexOutOfRangeException();
                }

                if (lastElement != null)
                {
                    if (index == lastIndex)
                    {
                        return(lastElement);
                    }
                    else if (index == lastIndex - 1)
                    {
                        lastIndex   = index;
                        lastElement = (IDLElement)lastElement.Previous;

                        return(lastElement);
                    }
                    else if (index == lastIndex + 1)
                    {
                        lastIndex   = index;
                        lastElement = (IDLElement)lastElement.Next;

                        return(lastElement);
                    }
                }

                // $todo(jeff.lill):
                //
                // If I ever have some spare time to burn, I
                // could optimize this by deciding whether it
                // makes more sense to count up or down from
                // the current position, count up from the beginning,
                // or count down from the end of the list.

                IDLElement element;

                element = this.front;
                for (int i = 0; i < index; i++)
                {
                    element = (IDLElement)element.Next;
                }

                lastIndex   = index;
                lastElement = element;

                return(element);
            }
        }
示例#6
0
文件: IDLType.cs 项目: reshadi2/mcjs
    public IDLType(XElement type, IDLElement ownerElement = null)
      : base(type)
    {
      IsPrimitive = Elem.Attribute("type") != null;
      IsObject = Elem.Attribute("name") != null;
      IsString = IsPrimitive && Elem.Attribute("type").Value == "DOMString";
      IsVoid = IsPrimitive && Elem.Attribute("type").Value == "void";
      IsNullable = IsString || IsObject;
      Name = IsPrimitive ? Elem.Attribute("type").Value : Elem.Attribute("name").Value;

      // Some attributes on the owner element make sense as type annotations.
      ByRef = ownerElement != null ? ownerElement.HasExtendedAttribute("ByRef") : false;
      IsPrivate = ownerElement != null ? ownerElement.HasExtendedAttribute("Private") : false;
    }
示例#7
0
        public IDLType(XElement type, IDLElement ownerElement = null)
            : base(type)
        {
            IsPrimitive = Elem.Attribute("type") != null;
            IsObject    = Elem.Attribute("name") != null;
            IsString    = IsPrimitive && Elem.Attribute("type").Value == "DOMString";
            IsVoid      = IsPrimitive && Elem.Attribute("type").Value == "void";
            IsNullable  = IsString || IsObject;
            Name        = IsPrimitive ? Elem.Attribute("type").Value : Elem.Attribute("name").Value;

            // Some attributes on the owner element make sense as type annotations.
            ByRef = ownerElement != null?ownerElement.HasExtendedAttribute("ByRef") : false;

            IsPrivate = ownerElement != null?ownerElement.HasExtendedAttribute("Private") : false;
        }
示例#8
0
        /// <summary>
        /// Removes an element from the list.
        /// </summary>
        /// <param name="element">The element to be removed.</param>
        /// <exception cref="InvalidOperationException">Thrown if the element is not in the list.</exception>
        public void Remove(IDLElement element)
        {
            Flush();

            if (element.Previous == null || element.Next == null)
            {
                throw new InvalidOperationException(NotInListMsg);
            }

            if (count == 1)
            {
                this.front = null;
                this.back  = null;
            }
            else
            {
                if (this.front == element)
                {
                    this.front = (IDLElement)element.Next;
                    ((IDLElement)element.Next).Previous = this;
                }
                else if (this.back == element)
                {
                    this.back = (IDLElement)element.Previous;
                    ((IDLElement)element.Previous).Next = this;
                }
                else
                {
                    ((IDLElement)element.Previous).Next = element.Next;
                    ((IDLElement)element.Next).Previous = element.Previous;
                }
            }

            element.Previous = null;
            element.Next     = null;

            this.count--;
            if (count < 0)
            {
                throw new InvalidOperationException("Remove error.");
            }
        }
示例#9
0
        /// <summary>
        /// Inserts an element at s specified position in the list.
        /// </summary>
        /// <param name="index">The index where the element will be inserted.</param>
        /// <param name="element">The element to be inserted.</param>
        /// <exception cref="InvalidOperationException">Thrown if the element is already in a list.</exception>
        /// <exception cref="IndexOutOfRangeException">Thrown if the index is outside the range of <b>0..Count</b>.</exception>
        public void InsertAt(int index, IDLElement element)
        {
            Flush();

            if (element.Previous != null || element.Next != null)
            {
                throw new InvalidOperationException(AlreadyInListMsg);
            }

            if (index < 0 || index > count)
            {
                throw new IndexOutOfRangeException();
            }

            if (index == 0)
            {
                AddToFront(element);
            }
            else
            {
                InsertAfter(this[index - 1], element);
            }
        }
示例#10
0
 /// <summary>
 /// Indicates that an element has been touched by moving it
 /// to the most recently used end of the list.
 /// </summary>
 /// <param name="element">The element.</param>
 public void Touch(IDLElement element)
 {
     list.Remove(element);
     list.AddToEnd(element);
 }
示例#11
0
 /// <summary>
 /// Removes and element from the list.
 /// </summary>
 /// <param name="element">The element.</param>
 public void Remove(IDLElement element)
 {
     list.Remove(element);
 }
示例#12
0
 /// <summary>
 /// Adds an element to the list.
 /// </summary>
 /// <param name="element">The element.</param>
 public void Add(IDLElement element)
 {
     list.AddToEnd(element);
 }
示例#13
0
 /// <summary>
 /// Called whenever the list is modified to update the opCount, as well
 /// as clearing the cached index and element.
 /// </summary>
 private void Flush()
 {
     opCount++;
     lastIndex   = -1;
     lastElement = null;
 }