Buffer for characters : Char « Data Types « C# / C Sharp






Buffer for characters

  
// CharBuffer.cs
// 
// Copyright (C) 2003-2004 Ryan Seghers
//
// This software is provided AS IS. No warranty is granted, 
// neither expressed nor implied. USE THIS SOFTWARE AT YOUR OWN RISK.
// NO REPRESENTATION OF MERCHANTABILITY or FITNESS FOR ANY 
// PURPOSE is given.
//
// License to use this software is limited by the following terms:
// 1) This code may be used in any program, including programs developed
//    for commercial purposes, provided that this notice is included verbatim.
//    
// Also, in return for using this code, please attempt to make your fixes and
// updates available in some way, such as by sending your updates to the
// author.

using System;

namespace RTools_NTS.Util
{
  /// <summary>
  /// Buffer for characters.  This approximates StringBuilder
  /// but is designed to be faster for specific operations.
  /// This is about 30% faster for the operations I'm interested in
  /// (Append, Clear, Length, ToString).
  /// This trades off memory for speed.
  /// </summary>
  /// <remarks>
  /// <para>To make Remove from the head fast, this is implemented
  /// as a ring buffer.</para>
  /// <para>This uses head and tail indices into a fixed-size 
  /// array. This will grow the array as necessary.</para>
  /// </remarks>
  public class CharBuffer
  {
    #region Fields

    int capacity = 128;
    char[] buffer;
    int headIndex;  // index of first char
    int tailIndex;  // index 1 past last char

    #endregion

    #region Properties

    /// <summary>
    /// Gets/Sets the number of characters in the character buffer.
    /// Increasing the length this way provides indeterminate results.
    /// </summary>
    public int Length
    {
      get { return(tailIndex - headIndex); }
      set 
      { 
        tailIndex = headIndex + value;
        if (tailIndex >= capacity) throw new 
          IndexOutOfRangeException("Tail index greater than capacity");
      }
    }

    /// <summary>
    /// Returns the capacity of this character buffer.
    /// </summary>
    public int Capacity
    {
      get { return(capacity); }
    }

    #endregion

    #region Constructors

    /// <summary>
    /// Default constructor.
    /// </summary>
    public CharBuffer()
    {
      buffer = new char[capacity];
    }

    /// <summary>
    /// Construct with a specific capacity.
    /// </summary>
    /// <param name="capacity"></param>
    public CharBuffer(int capacity)
    {
      this.capacity = capacity;
      buffer = new char[capacity];
    }

    #endregion

    #region Non-Public Methods

    /// <summary>
    /// Reallocate the buffer to be larger. For the new size, this
    /// uses the max of the requested length and double the current
    /// capacity.
    /// This does not shift, meaning it does not change the head or
    /// tail indices.
    /// </summary>
    /// <param name="requestedLen">The new requested length.</param>
    protected void Grow(int requestedLen)
    {
      int newLen = Math.Max(capacity*2, requestedLen);
      newLen = Math.Max(newLen, 16);
      char[] newBuffer = new char[newLen];
      Array.Copy(buffer, 0, newBuffer, 0, capacity);
      buffer = newBuffer;
      capacity = newLen;
    }

    /// <summary>
    /// Ensure that we're set for the requested length by 
    /// potentially growing or shifting contents.
    /// </summary>
    /// <param name="requestedLength"></param>
    protected void CheckCapacity(int requestedLength)
    {
      if (requestedLength + headIndex >= capacity)
      {
        // have to do something
        if ((requestedLength + headIndex > (capacity >> 1))
          && (requestedLength < capacity - 1))
        {
          // we're more than half-way through the buffer, and shifting is enough
          // so just shift
          ShiftToZero();
        }
        else
        {
          // not far into buffer or shift wouldn't be enough anyway
          Grow(0);
        }
      }
    }

    /// <summary>
    /// Move the buffer contents such that headIndex becomes 0.
    /// </summary>
    protected void ShiftToZero()
    {
      int len = Length;
      for (int i = 0; i < len; i++)
      {
        buffer[i] = buffer[i + headIndex];
      }
      headIndex = 0;
      tailIndex = len;
    }

    #endregion

    #region Public Methods and Indexer

    /// <summary>
    /// Overwrite this object's underlying buffer with the specified
    /// buffer.
    /// </summary>
    /// <param name="b">The character array.</param>
    /// <param name="len">The number of characters to consider filled
    /// in the input buffer.</param>
    public void SetBuffer(char[] b, int len)
    {
      capacity = b.Length;
      buffer = b;
      headIndex = 0;
      tailIndex = len;
    }

    /// <summary>
    /// Append a character to this buffer.
    /// </summary>
    /// <param name="c"></param>
    public void Append(char c)
    {
      if (tailIndex >= capacity) CheckCapacity(Length + 1);
      buffer[tailIndex++] = c;
    }

    /// <summary>
    /// Append a string to this buffer.
    /// </summary>
    /// <param name="s">The string to append.</param>
    public void Append(string s)
    {
      if (s.Length + tailIndex >= capacity) CheckCapacity(Length + s.Length);
      for(int i = 0; i < s.Length; i++)
        buffer[tailIndex++] = s[i];
    }

    /// <summary>
    /// Append a string to this buffer.
    /// </summary>
    /// <param name="s">The string to append.</param>
    public void Append(CharBuffer s)
    {
      if (s.Length + tailIndex >= capacity) CheckCapacity(Length + s.Length);
      for(int i = 0; i < s.Length; i++)
        buffer[tailIndex++] = s[i];
    }

    /// <summary>
    /// Remove a character at the specified index.
    /// </summary>
    /// <param name="i">The index of the character to remove.</param>
    /// <returns></returns>
    public void Remove(int i)
    {
      Remove(i, 1);
    }

    /// <summary>
    /// Remove a specified number of characters at the specified index.
    /// </summary>
    /// <param name="i">The index of the characters to remove.</param>
    /// <param name="n">The number of characters to remove.</param>
    public void Remove(int i, int n)
    {
      n = Math.Min(n, Length);
      if (i == 0)
      {
        headIndex += n;
      }
      else
      {
        Array.Copy(buffer, i + headIndex + n, buffer, i + headIndex, 
          tailIndex - (i + headIndex + n));
      }
    }

    /// <summary>
    /// Find the first instance of a character in the buffer, and
    /// return its index.  This returns -1 if the character is
    /// not found.
    /// </summary>
    /// <param name="c">The character to find.</param>
    /// <returns>The index of the specified character, or -1
    /// for not found.</returns>
    public int IndexOf(char c)
    {
      for (int i = headIndex; i < tailIndex; i++)
      {
        if (buffer[i] == c) return(i - headIndex);
      }
      return(-1);
    }

    /// <summary>
    /// Empty the buffer.
    /// </summary>
    public void Clear()
    {
      headIndex = 0;
      tailIndex = 0;
    }

    /// <summary>
    /// Indexer.
    /// </summary>
    public char this [int index]
    {
      get { return(buffer[index + headIndex]); }
      set { buffer[index + headIndex] = value; }
    }

    /// <summary>
    /// Return the current contents as a string.
    /// </summary>
    /// <returns>The new string.</returns>
    public override String ToString()
    {
      return(new String(buffer, headIndex, tailIndex - headIndex));
    }

    #endregion    
  }
}

   
    
  








Related examples in the same category

1.Get char type: control, digit, letter, number, punctuation, surrogate, symbol and white spaceGet char type: control, digit, letter, number, punctuation, surrogate, symbol and white space
2.Determining If A Character Is Within A Specified RangeDetermining If A Character Is Within A Specified Range
3.Is a char in a range: Case InsensitiveIs a char in a range: Case Insensitive
4.Is a char in a range ExclusivelyIs a char in a range Exclusively
5.Using Char
6.Escape Characters
7.A stack class for charactersA stack class for characters
8.Encode or decode a message
9.Demonstrate several Char methodsDemonstrate several Char methods
10.Demonstrate the ICharQ interface: A character queue interfaceDemonstrate the ICharQ interface: A character queue interface
11.A set class for charactersA set class for characters
12.A queue class for charactersA queue class for characters
13.IsDigit, IsLetter, IsWhiteSpace, IsLetterOrDigit, IsPunctuation
14.Char: Get Unicode Category
15.Char.IsLowSurrogate(), IsHighSurrogate(), IsSurrogatePair() method
16.demonstrates IsSymbol.
17.Test an input character if it is contained in a character list.
18.Is vowel char
19.Filter letter and digit
20.First Char Upper