[DDK]
[reactos.git] / irc / TechBot / Compression / PendingBuffer.cs
1 // PendingBuffer.cs
2 // Copyright (C) 2001 Mike Krueger
3 //
4 // This file was translated from java, it was part of the GNU Classpath
5 // Copyright (C) 2001 Free Software Foundation, Inc.
6 //
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License
9 // as published by the Free Software Foundation; either version 2
10 // of the License, or (at your option) any later version.
11 //
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 //
21 // Linking this library statically or dynamically with other modules is
22 // making a combined work based on this library. Thus, the terms and
23 // conditions of the GNU General Public License cover the whole
24 // combination.
25 //
26 // As a special exception, the copyright holders of this library give you
27 // permission to link this library with independent modules to produce an
28 // executable, regardless of the license terms of these independent
29 // modules, and to copy and distribute the resulting executable under
30 // terms of your choice, provided that you also meet, for each linked
31 // independent module, the terms and conditions of the license of that
32 // module. An independent module is a module which is not derived from
33 // or based on this library. If you modify this library, you may extend
34 // this exception to your version of the library, but you are not
35 // obligated to do so. If you do not wish to do so, delete this
36 // exception statement from your version.
37
38 using System;
39
40 namespace ICSharpCode.SharpZipLib.Zip.Compression
41 {
42
43 /// <summary>
44 /// This class is general purpose class for writing data to a buffer.
45 ///
46 /// It allows you to write bits as well as bytes
47 /// Based on DeflaterPending.java
48 ///
49 /// author of the original java version : Jochen Hoenicke
50 /// </summary>
51 public class PendingBuffer
52 {
53 protected byte[] buf;
54 int start;
55 int end;
56
57 uint bits;
58 int bitCount;
59
60 public PendingBuffer() : this( 4096 )
61 {
62
63 }
64
65 public PendingBuffer(int bufsize)
66 {
67 buf = new byte[bufsize];
68 }
69
70 public void Reset()
71 {
72 start = end = bitCount = 0;
73 }
74
75 public void WriteByte(int b)
76 {
77 if (DeflaterConstants.DEBUGGING && start != 0) {
78 throw new Exception();
79 }
80 buf[end++] = (byte) b;
81 }
82
83 public void WriteShort(int s)
84 {
85 if (DeflaterConstants.DEBUGGING && start != 0) {
86 throw new Exception();
87 }
88 buf[end++] = (byte) s;
89 buf[end++] = (byte) (s >> 8);
90 }
91
92 public void WriteInt(int s)
93 {
94 if (DeflaterConstants.DEBUGGING && start != 0) {
95 throw new Exception();
96 }
97 buf[end++] = (byte) s;
98 buf[end++] = (byte) (s >> 8);
99 buf[end++] = (byte) (s >> 16);
100 buf[end++] = (byte) (s >> 24);
101 }
102
103 public void WriteBlock(byte[] block, int offset, int len)
104 {
105 if (DeflaterConstants.DEBUGGING && start != 0) {
106 throw new Exception();
107 }
108 System.Array.Copy(block, offset, buf, end, len);
109 end += len;
110 }
111
112 public int BitCount {
113 get {
114 return bitCount;
115 }
116 }
117
118 public void AlignToByte()
119 {
120 if (DeflaterConstants.DEBUGGING && start != 0) {
121 throw new Exception();
122 }
123 if (bitCount > 0) {
124 buf[end++] = (byte) bits;
125 if (bitCount > 8) {
126 buf[end++] = (byte) (bits >> 8);
127 }
128 }
129 bits = 0;
130 bitCount = 0;
131 }
132
133 public void WriteBits(int b, int count)
134 {
135 if (DeflaterConstants.DEBUGGING && start != 0) {
136 throw new Exception();
137 }
138 // if (DeflaterConstants.DEBUGGING) {
139 // //Console.WriteLine("writeBits("+b+","+count+")");
140 // }
141 bits |= (uint)(b << bitCount);
142 bitCount += count;
143 if (bitCount >= 16) {
144 buf[end++] = (byte) bits;
145 buf[end++] = (byte) (bits >> 8);
146 bits >>= 16;
147 bitCount -= 16;
148 }
149 }
150
151 public void WriteShortMSB(int s)
152 {
153 if (DeflaterConstants.DEBUGGING && start != 0) {
154 throw new Exception();
155 }
156 buf[end++] = (byte) (s >> 8);
157 buf[end++] = (byte) s;
158 }
159
160 public bool IsFlushed {
161 get {
162 return end == 0;
163 }
164 }
165
166 /// <summary>
167 /// Flushes the pending buffer into the given output array. If the
168 /// output array is to small, only a partial flush is done.
169 /// </summary>
170 /// <param name="output">
171 /// the output array;
172 /// </param>
173 /// <param name="offset">
174 /// the offset into output array;
175 /// </param>
176 /// <param name="length">
177 /// length the maximum number of bytes to store;
178 /// </param>
179 /// <exception name="ArgumentOutOfRangeException">
180 /// IndexOutOfBoundsException if offset or length are invalid.
181 /// </exception>
182 public int Flush(byte[] output, int offset, int length)
183 {
184 if (bitCount >= 8) {
185 buf[end++] = (byte) bits;
186 bits >>= 8;
187 bitCount -= 8;
188 }
189 if (length > end - start) {
190 length = end - start;
191 System.Array.Copy(buf, start, output, offset, length);
192 start = 0;
193 end = 0;
194 } else {
195 System.Array.Copy(buf, start, output, offset, length);
196 start += length;
197 }
198 return length;
199 }
200
201 public byte[] ToByteArray()
202 {
203 byte[] ret = new byte[end - start];
204 System.Array.Copy(buf, start, ret, 0, ret.Length);
205 start = 0;
206 end = 0;
207 return ret;
208 }
209 }
210 }