/* ====================================================================
|
Licensed to the Apache Software Foundation (ASF) under one or more
|
contributor license agreements. See the NOTICE file distributed with
|
this work for Additional information regarding copyright ownership.
|
The ASF licenses this file to You 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.
|
==================================================================== */
|
|
/* ================================================================
|
* About NPOI
|
* Author: Tony Qu
|
* Author's email: tonyqus (at) gmail.com
|
* Author's Blog: tonyqus.wordpress.com.cn (wp.tonyqus.cn)
|
* HomePage: http://www.codeplex.com/npoi
|
* Contributors:
|
*
|
* ==============================================================*/
|
using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using System.IO;
|
|
namespace HH.WMS.Utils.NPOI.POIFS.FileSystem
|
{
|
/// <summary>
|
/// This class provides a wrapper over an OutputStream so that Document
|
/// writers can't accidently go over their size limits
|
/// @author Marc Johnson (mjohnson at apache dot org)
|
/// </summary>
|
[Obsolete]
|
public class POIFSDocumentWriter:Stream
|
{
|
private int limit;
|
private Stream stream;
|
private int written;
|
|
/// <summary>
|
/// Create a POIFSDocumentWriter
|
/// </summary>
|
/// <param name="stream">the OutputStream to which the data is actually</param>
|
/// <param name="limit">the maximum number of bytes that can be written</param>
|
public POIFSDocumentWriter(Stream stream, int limit)
|
{
|
this.stream = stream;
|
this.limit = limit;
|
this.written = 0;
|
}
|
/// <summary>
|
/// Closes this output stream and releases any system resources
|
/// associated with this stream. The general contract of close is
|
/// that it closes the output stream. A closed stream cannot
|
/// perform output operations and cannot be reopened.
|
/// </summary>
|
public override void Close()
|
{
|
this.stream.Close();
|
}
|
/// <summary>
|
/// Flushes this output stream and forces any buffered output bytes
|
/// to be written out.
|
/// </summary>
|
public override void Flush()
|
{
|
this.stream.Flush();
|
}
|
|
private void LimitCheck(int toBeWritten)
|
{
|
if ((this.written + toBeWritten) > this.limit)
|
{
|
throw new IOException("tried to write too much data");
|
}
|
this.written += toBeWritten;
|
}
|
|
public override int Read(byte[] buffer, int offset, int count)
|
{
|
throw new NotImplementedException();
|
}
|
|
public override long Seek(long offset, SeekOrigin origin)
|
{
|
return 0L;
|
}
|
|
public override void SetLength(long value)
|
{
|
throw new NotImplementedException();
|
}
|
|
|
public void Write(int b)
|
{
|
LimitCheck(1);
|
stream.WriteByte((byte)b);
|
}
|
|
/// <summary>
|
/// Writes b.length bytes from the specified byte array
|
/// to this output stream.
|
/// </summary>
|
/// <param name="b">the data.</param>
|
public void Write(byte[] b)
|
{
|
this.Write(b, 0, b.Length);
|
}
|
/// <summary>
|
/// Writes len bytes from the specified byte array starting at
|
/// offset off to this output stream. The general contract for
|
/// write(b, off, len) is that some of the bytes in the array b are
|
/// written to the output stream in order; element b[off] is the
|
/// first byte written and b[off+len-1] is the last byte written by
|
/// this operation.
|
/// If b is null, a NullPointerException is thrown.
|
/// If off is negative, or len is negative, or off+len is greater
|
/// than the length of the array b, then an
|
/// IndexOutOfBoundsException is thrown.
|
/// </summary>
|
/// <param name="b">the data.</param>
|
/// <param name="off">the start offset in the data.</param>
|
/// <param name="len">the number of bytes to write.</param>
|
public override void Write(byte[] b, int off, int len)
|
{
|
this.LimitCheck(len);
|
this.stream.Write(b, off, len);
|
}
|
|
/// <summary>
|
/// Writes the specified byte to this output stream. The general
|
/// contract for write is that one byte is written to the output
|
/// stream. The byte to be written is the eight low-order bits of
|
/// the argument b. The 24 high-order bits of b are ignored.
|
/// </summary>
|
/// <param name="b">the byte.</param>
|
public override void WriteByte(byte b)
|
{
|
this.LimitCheck(1);
|
this.stream.WriteByte(b);
|
}
|
/// <summary>
|
/// write the rest of the document's data (fill in at the end)
|
/// </summary>
|
/// <param name="totalLimit">the actual number of bytes the corresponding
|
/// document must fill</param>
|
/// <param name="fill">the byte to fill remaining space with</param>
|
public virtual void WriteFiller(int totalLimit, byte fill)
|
{
|
if (totalLimit > this.written)
|
{
|
byte[] buffer = new byte[totalLimit - this.written];
|
for (int i = 0; i < buffer.Length; i++)
|
{
|
buffer[i] = fill;
|
}
|
this.stream.Write(buffer, 0, buffer.Length);
|
}
|
}
|
|
/// <summary>
|
/// When overridden in a derived class, gets a value indicating whether the current stream supports reading.
|
/// </summary>
|
/// <value></value>
|
/// <returns>true if the stream supports reading; otherwise, false.
|
/// </returns>
|
public override bool CanRead
|
{
|
get
|
{
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// When overridden in a derived class, gets a value indicating whether the current stream supports seeking.
|
/// </summary>
|
/// <value></value>
|
/// <returns>true if the stream supports seeking; otherwise, false.
|
/// </returns>
|
public override bool CanSeek
|
{
|
get
|
{
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// When overridden in a derived class, gets a value indicating whether the current stream supports writing.
|
/// </summary>
|
/// <value></value>
|
/// <returns>true if the stream supports writing; otherwise, false.
|
/// </returns>
|
public override bool CanWrite
|
{
|
get
|
{
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// When overridden in a derived class, gets the length in bytes of the stream.
|
/// </summary>
|
/// <value></value>
|
/// <returns>
|
/// A long value representing the length of the stream in bytes.
|
/// </returns>
|
/// <exception cref="T:System.NotSupportedException">
|
/// A class derived from Stream does not support seeking.
|
/// </exception>
|
/// <exception cref="T:System.ObjectDisposedException">
|
/// Methods were called after the stream was closed.
|
/// </exception>
|
public override long Length
|
{
|
get
|
{
|
return this.stream.Length;
|
}
|
}
|
|
/// <summary>
|
/// When overridden in a derived class, gets or sets the position within the current stream.
|
/// </summary>
|
/// <value></value>
|
/// <returns>
|
/// The current position within the stream.
|
/// </returns>
|
/// <exception cref="T:System.IO.IOException">
|
/// An I/O error occurs.
|
/// </exception>
|
/// <exception cref="T:System.NotSupportedException">
|
/// The stream does not support seeking.
|
/// </exception>
|
/// <exception cref="T:System.ObjectDisposedException">
|
/// Methods were called after the stream was closed.
|
/// </exception>
|
public override long Position
|
{
|
get
|
{
|
return this.stream.Position;
|
}
|
set
|
{
|
this.stream.Position = value;
|
}
|
}
|
|
}
|
}
|
