public PhysicalPartition(PartitionDescriptor descriptor, IBuffer buffer, uint sectorSize)
 {
     _partitionNumber = descriptor.PartitionNumber;
     _parentBuffer = buffer;
     _contentBuffer = new SubBuffer(_parentBuffer, descriptor.PartitionStartingLocation * (long)sectorSize, descriptor.PartitionLength * (long)sectorSize);
     _descriptor = descriptor;
 }

        ///<summary>
        ///
        ///            Creates lexer, that corresponds to source file text (NOT generated!) 
        ///            
        ///</summary>
        ///
        public ILexerFactory CreateLexer(ProjectFileType languageType, IBuffer buffer)
        {
            if (languageType != L4N)
                return null;

            return new XmlLexerFactory(L4NLanguageService.L4N);
        }

   public PdfStream(
 IBuffer body
 )
       : this(new PdfDictionary(),
   body)
   {
   }

        /// <summary>
        /// Sets a value of all cells in a buffer
        /// </summary>
        /// <param name="source">image source</param>
        /// <param name="value">value to set</param>
        public void SetValue(IBuffer<float> source, float value)
        {
            if (source == null) throw new ArgumentNullException("source");

            for (int i = 0, length = source.HostBuffer.Length; i < length; i++)
                source.HostBuffer[i] = value;
        }

 public void Init(IBuffer buffer)
 {
     m_rawData = buffer;
     m_buffer = m_rawData.Buffer;
     bufferLength = m_buffer.Length;
     m_ioIndex = 0;
 }

public PsiLexerGenerated(IBuffer buffer, int startOffset, int endOffset) : this(buffer)
  {
  yy_buffer_index = startOffset;
  yy_buffer_start = startOffset;
  yy_buffer_end = startOffset;
  yy_eof_pos = endOffset + 1;
  }

 public InlineImageBody(
     IBuffer value
     )
     : base(null)
 {
     this.value = value;
 }

        public ILexerFactory GetMixedLexerFactory(IBuffer buffer, IPsiSourceFile sourceFile, PsiManager manager)
        {
            var LanguageService = RaconteurLanguage.Instance.LanguageService();

            return LanguageService == null ? null
                : LanguageService.GetPrimaryLexerFactory();
        }

 public ILexerFactory CreateLexer(ProjectFileType languageType, IBuffer buffer) {
     //Logger.LogMessage("MappingFileProjectFileLanguageService.CreateLexer for language type {0}", languageType.Name);
     if (languageType == MAPPING_FILE) {
         return new XmlLexerFactory(MappingFileLanguageService.MAPPING_FILE);
     }
     return null;
 }

 public void SendAsync(IBuffer buffer)
 {
     if (IsConnected && buffer.Size > 0)
     {
         Socket.SendAsync(buffer);
     }
 }

 private void HandleDataReceived(INetSocket clientSocket, IBuffer buffer)
 {
     if (buffer.Size > 0)
     {
         ReceiveData();
     }
     OnMessage(this, buffer);
 }

 public InputAssembler( IBuffer vertexBuffer, IVertexDeclaration vertexDeclaration, PrimitiveType primitiveType = PrimitiveType.TriangleList, IBuffer indexBuffer = null )
     : this()
 {
     PrimitiveType = primitiveType;
     VertexBuffer = vertexBuffer;
     VertexDeclaration = vertexDeclaration;
     IndexBuffer = indexBuffer;
 }

 /// <summary>
 /// Reads the given stream up to the end, returning the data as a byte
 /// array, using the given buffer for transferring data. Note that the
 /// current contents of the buffer is ignored, so the buffer needn't
 /// be cleared beforehand.
 /// </summary>
 /// <param name="input">The stream to read from</param>
 /// <param name="buffer">The buffer to use to transfer data</param>
 /// <exception cref="ArgumentNullException">input is null</exception>
 /// <exception cref="ArgumentNullException">buffer is null</exception>
 /// <exception cref="IOException">An error occurs while reading from the stream</exception>
 /// <returns>The data read from the stream</returns>
 public static byte[] ReadFully(Stream input, IBuffer buffer)
 {
     if (buffer==null)
     {
         throw new ArgumentNullException("buffer");
     }
     return ReadFully(input, buffer.Bytes);
 }

		protected Document (IBuffer buffer,ILineSplitter splitter)
		{
			this.buffer = buffer;
			this.splitter = splitter;
			splitter.LineChanged += SplitterLineSegmentTreeLineChanged;
			splitter.LineRemoved += HandleSplitterLineSegmentTreeLineRemoved;
			foldSegmentTree.InstallListener (this);
		}

		protected Document (IBuffer buffer,ILineSplitter splitter)
		{
			this.buffer = buffer;
			this.splitter = splitter;
			splitter.LineChanged += SplitterLineSegmentTreeLineChanged;
			splitter.LineRemoved += HandleSplitterLineSegmentTreeLineRemoved;
			foldSegmentTree.tree.NodeRemoved += HandleFoldSegmentTreetreeNodeRemoved; 
		}

 /// <summary>
 /// Copies all the data from one stream into another, using the given 
 /// buffer for transferring data. Note that the current contents of 
 /// the buffer is ignored, so the buffer needn't be cleared beforehand.
 /// </summary>
 /// <param name="input">The stream to read from</param>
 /// <param name="output">The stream to write to</param>
 /// <param name="buffer">The buffer to use to transfer data</param>
 /// <exception cref="ArgumentNullException">input is null</exception>
 /// <exception cref="ArgumentNullException">output is null</exception>
 /// <exception cref="ArgumentNullException">buffer is null</exception>
 /// <exception cref="IOException">An error occurs while reading or writing</exception>
 public static void Copy(Stream input, Stream output, IBuffer buffer)
 {
     if (buffer==null)
     {
         throw new ArgumentNullException("buffer");
     }
     Copy(input, output, buffer.Bytes);
 }

 public static void Set(this IBinding<BufferRange> binding, IBuffer buffer)
 {
     binding.Set(new BufferRange
     {
         Buffer = buffer,
         Offset = 0,
         Size = buffer.SizeInBytes
     });
 }

 internal void ReleaseBufferToPool(IBuffer buffer)
 {
     for (int i = 0; i < pool.Length; i++)
     {
         if (Interlocked.CompareExchange(ref pool[i], buffer, null) == null)
         {
             break; // found a null; swapped it in
         }
     }
 }

        /// <summary>
        /// Initializes a new instance of the SubBuffer class.
        /// </summary>
        /// <param name="parent">The parent buffer.</param>
        /// <param name="first">The first byte in <paramref name="parent"/> represented by this sub-buffer.</param>
        /// <param name="length">The number of bytes of <paramref name="parent"/> represented by this sub-buffer.</param>
        public SubBuffer(IBuffer parent, long first, long length)
        {
            _parent = parent;
            _first = first;
            _length = length;

            if (_first + _length > _parent.Capacity)
            {
                throw new ArgumentException("Substream extends beyond end of parent stream");
            }
        }

		protected Document (IBuffer buffer,ILineSplitter splitter)
		{
			this.buffer = buffer;
			this.splitter = splitter;
			splitter.LineChanged += SplitterLineSegmentTreeLineChanged;
			splitter.LineRemoved += HandleSplitterLineSegmentTreeLineRemoved;
			foldSegmentTree.InstallListener (this);
			foldSegmentTree.tree.NodeRemoved += delegate(object sender, RedBlackTree<FoldSegment>.RedBlackTreeNodeEventArgs e) {
				if (e.Node.IsFolded)
					foldedSegments.Remove (e.Node);
			};
		}