source: rtems/cpukit/zlib/contrib/dotzlib/DotZLib/DotZLib.cs @ 4995d21

4.104.114.84.9
Last change on this file since 4995d21 was 4995d21, checked in by Ralf Corsepius <ralf.corsepius@…>, on Oct 28, 2005 at 7:22:44 AM

Import from zlib-1.2.4

  • Property mode set to 100644
File size: 9.7 KB
Line 
1//
2// © Copyright Henrik Ravn 2004
3//
4// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
5// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6//
7
8using System;
9using System.IO;
10using System.Runtime.InteropServices;
11using System.Text;
12
13
14namespace DotZLib
15{
16
17    #region Internal types
18
19    /// <summary>
20    /// Defines constants for the various flush types used with zlib
21    /// </summary>
22    internal enum FlushTypes
23    {
24        None,  Partial,  Sync,  Full,  Finish,  Block
25    }
26
27    #region ZStream structure
28    // internal mapping of the zlib zstream structure for marshalling
29    [StructLayoutAttribute(LayoutKind.Sequential, Pack=4, Size=0, CharSet=CharSet.Ansi)]
30    internal struct ZStream
31    {
32        public IntPtr next_in;
33        public uint avail_in;
34        public uint total_in;
35
36        public IntPtr next_out;
37        public uint avail_out;
38        public uint total_out;
39
40        [MarshalAs(UnmanagedType.LPStr)]
41        string msg;
42        uint state;
43
44        uint zalloc;
45        uint zfree;
46        uint opaque;
47
48        int data_type;
49        public uint adler;
50        uint reserved;
51    }
52
53    #endregion
54
55    #endregion
56
57    #region Public enums
58    /// <summary>
59    /// Defines constants for the available compression levels in zlib
60    /// </summary>
61    public enum CompressLevel : int
62    {
63        /// <summary>
64        /// The default compression level with a reasonable compromise between compression and speed
65        /// </summary>
66        Default = -1,
67        /// <summary>
68        /// No compression at all. The data are passed straight through.
69        /// </summary>
70        None = 0,
71        /// <summary>
72        /// The maximum compression rate available.
73        /// </summary>
74        Best = 9,
75        /// <summary>
76        /// The fastest available compression level.
77        /// </summary>
78        Fastest = 1
79    }
80    #endregion
81
82    #region Exception classes
83    /// <summary>
84    /// The exception that is thrown when an error occurs on the zlib dll
85    /// </summary>
86    public class ZLibException : ApplicationException
87    {
88        /// <summary>
89        /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
90        /// error message and error code
91        /// </summary>
92        /// <param name="errorCode">The zlib error code that caused the exception</param>
93        /// <param name="msg">A message that (hopefully) describes the error</param>
94        public ZLibException(int errorCode, string msg) : base(String.Format("ZLib error {0} {1}", errorCode, msg))
95        {
96        }
97
98        /// <summary>
99        /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
100        /// error code
101        /// </summary>
102        /// <param name="errorCode">The zlib error code that caused the exception</param>
103        public ZLibException(int errorCode) : base(String.Format("ZLib error {0}", errorCode))
104        {
105        }
106    }
107    #endregion
108
109    #region Interfaces
110
111    /// <summary>
112    /// Declares methods and properties that enables a running checksum to be calculated
113    /// </summary>
114    public interface ChecksumGenerator
115    {
116        /// <summary>
117        /// Gets the current value of the checksum
118        /// </summary>
119        uint Value { get; }
120
121        /// <summary>
122        /// Clears the current checksum to 0
123        /// </summary>
124        void Reset();
125
126        /// <summary>
127        /// Updates the current checksum with an array of bytes
128        /// </summary>
129        /// <param name="data">The data to update the checksum with</param>
130        void Update(byte[] data);
131
132        /// <summary>
133        /// Updates the current checksum with part of an array of bytes
134        /// </summary>
135        /// <param name="data">The data to update the checksum with</param>
136        /// <param name="offset">Where in <c>data</c> to start updating</param>
137        /// <param name="count">The number of bytes from <c>data</c> to use</param>
138        /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
139        /// <exception cref="ArgumentNullException"><c>data</c> is a null reference</exception>
140        /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
141        void Update(byte[] data, int offset, int count);
142
143        /// <summary>
144        /// Updates the current checksum with the data from a string
145        /// </summary>
146        /// <param name="data">The string to update the checksum with</param>
147        /// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
148        void Update(string data);
149
150        /// <summary>
151        /// Updates the current checksum with the data from a string, using a specific encoding
152        /// </summary>
153        /// <param name="data">The string to update the checksum with</param>
154        /// <param name="encoding">The encoding to use</param>
155        void Update(string data, Encoding encoding);
156    }
157
158
159    /// <summary>
160    /// Represents the method that will be called from a codec when new data
161    /// are available.
162    /// </summary>
163    /// <paramref name="data">The byte array containing the processed data</paramref>
164    /// <paramref name="startIndex">The index of the first processed byte in <c>data</c></paramref>
165    /// <paramref name="count">The number of processed bytes available</paramref>
166    /// <remarks>On return from this method, the data may be overwritten, so grab it while you can.
167    /// You cannot assume that startIndex will be zero.
168    /// </remarks>
169    public delegate void DataAvailableHandler(byte[] data, int startIndex, int count);
170
171    /// <summary>
172    /// Declares methods and events for implementing compressors/decompressors
173    /// </summary>
174    public interface Codec
175    {
176        /// <summary>
177        /// Occurs when more processed data are available.
178        /// </summary>
179        event DataAvailableHandler DataAvailable;
180
181        /// <summary>
182        /// Adds more data to the codec to be processed.
183        /// </summary>
184        /// <param name="data">Byte array containing the data to be added to the codec</param>
185        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
186        void Add(byte[] data);
187
188        /// <summary>
189        /// Adds more data to the codec to be processed.
190        /// </summary>
191        /// <param name="data">Byte array containing the data to be added to the codec</param>
192        /// <param name="offset">The index of the first byte to add from <c>data</c></param>
193        /// <param name="count">The number of bytes to add</param>
194        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
195        void Add(byte[] data, int offset, int count);
196
197        /// <summary>
198        /// Finishes up any pending data that needs to be processed and handled.
199        /// </summary>
200        void Finish();
201
202        /// <summary>
203        /// Gets the checksum of the data that has been added so far
204        /// </summary>
205        uint Checksum { get; }
206
207
208    }
209
210    #endregion
211
212    #region Classes
213    /// <summary>
214    /// Encapsulates general information about the ZLib library
215    /// </summary>
216    public class Info
217    {
218        #region DLL imports
219        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
220        private static extern uint zlibCompileFlags();
221
222        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
223        private static extern string zlibVersion();
224        #endregion
225
226        #region Private stuff
227        private uint _flags;
228
229        // helper function that unpacks a bitsize mask
230        private static int bitSize(uint bits)
231        {
232            switch (bits)
233            {
234                case 0: return 16;
235                case 1: return 32;
236                case 2: return 64;
237            }
238            return -1;
239        }
240        #endregion
241
242        /// <summary>
243        /// Constructs an instance of the <c>Info</c> class.
244        /// </summary>
245        public Info()
246        {
247            _flags = zlibCompileFlags();
248        }
249
250        /// <summary>
251        /// True if the library is compiled with debug info
252        /// </summary>
253        public bool HasDebugInfo { get { return 0 != (_flags & 0x100); } }
254
255        /// <summary>
256        /// True if the library is compiled with assembly optimizations
257        /// </summary>
258        public bool UsesAssemblyCode { get { return 0 != (_flags & 0x200); } }
259
260        /// <summary>
261        /// Gets the size of the unsigned int that was compiled into Zlib
262        /// </summary>
263        public int SizeOfUInt { get { return bitSize(_flags & 3); } }
264
265        /// <summary>
266        /// Gets the size of the unsigned long that was compiled into Zlib
267        /// </summary>
268        public int SizeOfULong { get { return bitSize((_flags >> 2) & 3); } }
269
270        /// <summary>
271        /// Gets the size of the pointers that were compiled into Zlib
272        /// </summary>
273        public int SizeOfPointer { get { return bitSize((_flags >> 4) & 3); } }
274
275        /// <summary>
276        /// Gets the size of the z_off_t type that was compiled into Zlib
277        /// </summary>
278        public int SizeOfOffset { get { return bitSize((_flags >> 6) & 3); } }
279
280        /// <summary>
281        /// Gets the version of ZLib as a string, e.g. "1.2.1"
282        /// </summary>
283        public static string Version { get { return zlibVersion(); } }
284    }
285
286    #endregion
287
288}
Note: See TracBrowser for help on using the repository browser.