// crudwork // Copyright 2004 by Steve T. Pham (http://www.crudwork.com) // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with This program. If not, see <http://www.gnu.org/licenses/>. using System; using System.Collections.Generic; using System.IO; using System.Text; using System.CodeDom.Compiler; using System.Text.RegularExpressions; namespace crudwork.Utilities { /// <summary> /// File Utility /// </summary> public static class FileUtil { #region Stream methods /// <summary> /// Read from stream /// </summary> /// <param name="s"></param> /// <returns></returns> public static string[] ReadStream(Stream s) { List<string> results = new List<string>(); using (StreamReader r = new StreamReader(s)) { while (!r.EndOfStream) { results.Add(r.ReadLine()); } r.Close(); } return results.ToArray(); } /// <summary> /// Write to stream /// </summary> /// <param name="s"></param> /// <param name="value"></param> public static void WriteStream(Stream s, string value) { byte[] byteArray = ASCIIEncoding.UTF8.GetBytes(value); s.Write(byteArray, 0, byteArray.Length); s.Flush(); s.Close(); } #endregion } }
Author: coder
Fifo Stream
///////////////////////////////////////////////////////////////////////////////////////////////
//
// This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
// Copyright (c) 2005-2008, Jim Heising
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation and/or
// other materials provided with the distribution.
//
// * Neither the name of Jim Heising nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////
using System;
using System.IO;
using System.Collections;
namespace WOSI.Utilities
{
public class FifoStream : Stream
{
private const int BlockSize = 65536;
private const int MaxBlocksInCache = (3 * 1024 * 1024) / BlockSize;
private int m_Size;
private int m_RPos;
private int m_WPos;
private Stack m_UsedBlocks = new Stack();
private ArrayList m_Blocks = new ArrayList();
private byte[] AllocBlock()
{
byte[] Result = null;
Result = m_UsedBlocks.Count > 0 ? (byte[])m_UsedBlocks.Pop() : new byte[BlockSize];
return Result;
}
private void FreeBlock(byte[] block)
{
if (m_UsedBlocks.Count < MaxBlocksInCache)
m_UsedBlocks.Push(block);
}
private byte[] GetWBlock()
{
byte[] Result = null;
if (m_WPos < BlockSize && m_Blocks.Count > 0)
Result = (byte[])m_Blocks[m_Blocks.Count – 1];
else
{
Result = AllocBlock();
m_Blocks.Add(Result);
m_WPos = 0;
}
return Result;
}
// Stream members
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return true; }
}
public override long Length
{
get
{
lock (this)
return m_Size;
}
}
public override long Position
{
get { throw new InvalidOperationException(); }
set { throw new InvalidOperationException(); }
}
public override void Close()
{
Flush();
}
public override void Flush()
{
lock (this)
{
foreach (byte[] block in m_Blocks)
FreeBlock(block);
m_Blocks.Clear();
m_RPos = 0;
m_WPos = 0;
m_Size = 0;
}
}
public override void SetLength(long len)
{
throw new InvalidOperationException();
}
public override long Seek(long pos, SeekOrigin o)
{
throw new InvalidOperationException();
}
public override int Read(byte[] buf, int ofs, int count)
{
lock (this)
{
int Result = Peek(buf, ofs, count);
Advance(Result);
return Result;
}
}
public override void Write(byte[] buf, int ofs, int count)
{
lock (this)
{
int Left = count;
while (Left > 0)
{
int ToWrite = Math.Min(BlockSize – m_WPos, Left);
Array.Copy(buf, ofs + count – Left, GetWBlock(), m_WPos, ToWrite);
m_WPos += ToWrite;
Left -= ToWrite;
}
m_Size += count;
}
}
// extra stuff
public int Advance(int count)
{
lock (this)
{
int SizeLeft = count;
while (SizeLeft > 0 && m_Size > 0)
{
if (m_RPos == BlockSize)
{
m_RPos = 0;
FreeBlock((byte[])m_Blocks[0]);
m_Blocks.RemoveAt(0);
}
int ToFeed = m_Blocks.Count == 1 ? Math.Min(m_WPos – m_RPos, SizeLeft) : Math.Min(BlockSize – m_RPos, SizeLeft);
m_RPos += ToFeed;
SizeLeft -= ToFeed;
m_Size -= ToFeed;
}
return count – SizeLeft;
}
}
public int Peek(byte[] buf, int ofs, int count)
{
lock (this)
{
int SizeLeft = count;
int TempBlockPos = m_RPos;
int TempSize = m_Size;
int CurrentBlock = 0;
while (SizeLeft > 0 && TempSize > 0)
{
if (TempBlockPos == BlockSize)
{
TempBlockPos = 0;
CurrentBlock++;
}
int Upper = CurrentBlock < m_Blocks.Count - 1 ? BlockSize : m_WPos;
int ToFeed = Math.Min(Upper - TempBlockPos, SizeLeft);
Array.Copy((byte[])m_Blocks[CurrentBlock], TempBlockPos, buf, ofs + count - SizeLeft, ToFeed);
SizeLeft -= ToFeed;
TempBlockPos += ToFeed;
TempSize -= ToFeed;
}
return count - SizeLeft;
}
}
}
}
[/csharp]
Enumerate non-empty Lines for StreamReader
using System.Collections.Generic; public static class IOUtil { public static IEnumerable<string> EnumLines(System.IO.StringReader fp) { while (true) { var line = fp.ReadLine(); if (line == null) { break; } yield return line; } } }
Enumerate Lines for StreamReader
using System.Collections.Generic; public static class IOUtil { public static IEnumerable<string> EnumLines(System.IO.StreamReader fp) { while (!fp.EndOfStream) { var line = fp.ReadLine(); yield return line; } } }
Copy Stream from fromStream to toStream
// Copyright (c) Microsoft Corporation. All rights reserved. // This file is best viewed using outline mode (Ctrl-M Ctrl-O) // // This program uses code hyperlinks available as part of the HyperAddin Visual Studio plug-in. // It is available from http://www.codeplex.com/hyperAddin // using System; using System.IO; class MainClass{ static public int CopyStream(Stream fromStream, Stream toStream) { byte[] buffer = new byte[8192]; int totalBytes = 0; for (; ; ) { int count = fromStream.Read(buffer, 0, buffer.Length); if (count == 0) break; toStream.Write(buffer, 0, count); totalBytes += count; } return totalBytes; } }
Copies one stream into another.
#region License /* * Copyright 2002-2005 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #endregion using System; using System.IO; namespace Spring.Util { /// <summary> /// Utility methods for IO handling /// </summary> internal sealed class IOUtils { private IOUtils() { throw new InvalidOperationException("instantiation not supported"); } /// <summary> /// Copies one stream into another. /// (Don't forget to call <see cref="Stream.Flush"/> on the destination stream!) /// </summary> /// <remarks> /// Does not close the input stream! /// </remarks> public static void CopyStream(Stream src, Stream dest) { int bufferSize = 2048; byte[] buffer = new byte[bufferSize]; int bytesRead = 0; while ((bytesRead = src.Read(buffer, 0, bufferSize)) > 0) { dest.Write(buffer, 0, bytesRead); } } } }
Reads a stream into a byte array.
#region License /* * Copyright 2002-2005 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #endregion using System; using System.IO; namespace Spring.Util { /// <summary> /// Utility methods for IO handling /// </summary> internal sealed class IOUtils { private IOUtils() { throw new InvalidOperationException("instantiation not supported"); } /// <summary> /// Reads a stream into a byte array. /// </summary> /// <remarks> /// Does not close the input stream! /// </remarks> public static byte[] ToByteArray(Stream src) { MemoryStream stm = new MemoryStream(); CopyStream(src, stm); stm.Close(); return stm.ToArray(); } /// <summary> /// Copies one stream into another. /// (Don't forget to call <see cref="Stream.Flush"/> on the destination stream!) /// </summary> /// <remarks> /// Does not close the input stream! /// </remarks> public static void CopyStream(Stream src, Stream dest) { int bufferSize = 2048; byte[] buffer = new byte[bufferSize]; int bytesRead = 0; while ((bytesRead = src.Read(buffer, 0, bufferSize)) > 0) { dest.Write(buffer, 0, bytesRead); } } } }