Extract KaitaiStreamBase containing utility methods.

Author: pluskal

Kaitai.Struct.Runtime/Interface/IKaitaiStream.cs

@@ -1,22 +1,7 @@
 namespace Kaitai
 {
-    public interface IKaitaiStream
+    public interface IKaitaiStream : IKaitaiStreamBase
     {
-        /// <summary>
-        /// Check if the stream position is at the end of the stream
-        /// </summary>
-        bool IsEof { get; }
-
-        /// <summary>
-        /// Get the current position in the stream
-        /// </summary>
-        long Pos { get; }
-
-        /// <summary>
-        /// Get the total length of the stream (ie. file size)
-        /// </summary>
-        long Size { get; }
-
         /// <summary>
         /// Seek to a specific position from the beginning of the stream
         /// </summary>
@@ -131,7 +116,6 @@ public interface IKaitaiStream
         /// <returns></returns>
         double ReadF8le();
 
-        void AlignToByte();
         ulong ReadBitsInt(int n);
         ulong ReadBitsIntLe(int n);
 
@@ -171,39 +155,5 @@ public interface IKaitaiStream
         /// <param name="expected">The expected result</param>
         /// <returns></returns>
         byte[] EnsureFixedContents(byte[] expected);
-
-        /// <summary>
-        /// Performs XOR processing with given data, XORing every byte of the input with a single value.
-        /// </summary>
-        /// <param name="value">The data toe process</param>
-        /// <param name="key">The key value to XOR with</param>
-        /// <returns>Processed data</returns>
-        byte[] ProcessXor(byte[] value, int key);
-
-        /// <summary>
-        /// Performs XOR processing with given data, XORing every byte of the input with a key
-        /// array, repeating from the beginning of the key array if necessary
-        /// </summary>
-        /// <param name="value">The data toe process</param>
-        /// <param name="key">The key array to XOR with</param>
-        /// <returns>Processed data</returns>
-        byte[] ProcessXor(byte[] value, byte[] key);
-
-        /// <summary>
-        /// Performs a circular left rotation shift for a given buffer by a given amount of bits.
-        /// Pass a negative amount to rotate right.
-        /// </summary>
-        /// <param name="data">The data to rotate</param>
-        /// <param name="amount">The number of bytes to rotate by</param>
-        /// <param name="groupSize"></param>
-        /// <returns></returns>
-        byte[] ProcessRotateLeft(byte[] data, int amount, int groupSize);
-
-        /// <summary>
-        /// Inflates a deflated zlib byte stream
-        /// </summary>
-        /// <param name="data">The data to deflate</param>
-        /// <returns>The deflated result</returns>
-        byte[] ProcessZlib(byte[] data);
     }
 }

Kaitai.Struct.Runtime/Interface/IKaitaiStreamBase.cs

@@ -0,0 +1,56 @@
+namespace Kaitai
+{
+    public interface IKaitaiStreamBase
+    {
+        /// <summary>
+        /// Check if the stream position is at the end of the stream
+        /// </summary>
+        bool IsEof { get; }
+
+        /// <summary>
+        /// Get the current position in the stream
+        /// </summary>
+        long Pos { get; }
+
+        /// <summary>
+        /// Get the total length of the stream (ie. file size)
+        /// </summary>
+        long Size { get; }
+
+        void AlignToByte();
+
+        /// <summary>
+        /// Performs XOR processing with given data, XORing every byte of the input with a single value.
+        /// </summary>
+        /// <param name="value">The data toe process</param>
+        /// <param name="key">The key value to XOR with</param>
+        /// <returns>Processed data</returns>
+        byte[] ProcessXor(byte[] value, int key);
+
+        /// <summary>
+        /// Performs XOR processing with given data, XORing every byte of the input with a key
+        /// array, repeating from the beginning of the key array if necessary
+        /// </summary>
+        /// <param name="value">The data toe process</param>
+        /// <param name="key">The key array to XOR with</param>
+        /// <returns>Processed data</returns>
+        byte[] ProcessXor(byte[] value, byte[] key);
+
+        /// <summary>
+        /// Performs a circular left rotation shift for a given buffer by a given amount of bits.
+        /// Pass a negative amount to rotate right.
+        /// </summary>
+        /// <param name="data">The data to rotate</param>
+        /// <param name="amount">The number of bytes to rotate by</param>
+        /// <param name="groupSize"></param>
+        /// <returns></returns>
+        byte[] ProcessRotateLeft(byte[] data, int amount, int groupSize);
+
+        /// <summary>
+        /// Inflates a deflated zlib byte stream
+        /// </summary>
+        /// <param name="data">The data to deflate</param>
+        /// <returns>The deflated result</returns>
+        byte[] ProcessZlib(byte[] data);
+    }
+}

Kaitai.Struct.Runtime/Kaitai.Struct.Runtime.csproj.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=interface/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Kaitai.Struct.Runtime/KaitaiStream.cs

@@ -1,20 +1,16 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.IO.Compression;
 
 namespace Kaitai
 {
     /// <summary>
     /// The base Kaitai stream which exposes an API for the Kaitai Struct framework.
     /// It's based off a <code>BinaryReader</code>, which is a little-endian reader.
     /// </summary>
-    public partial class KaitaiStream : IKaitaiStream
+    public partial class KaitaiStream : KaitaiStreamBase, IKaitaiStream
     {
         #region Constructors
-
-        static readonly bool IsLittleEndian = BitConverter.IsLittleEndian;
-
         private ulong Bits;
         private int BitsLeft;
         private BinaryReader m_binaryReader;
@@ -53,7 +49,7 @@ protected BinaryReader BinaryReader
         /// <summary>
         /// Check if the stream position is at the end of the stream
         /// </summary>
-        public bool IsEof
+        public override bool IsEof
         {
             get { return BaseStream.Position >= BaseStream.Length && BitsLeft == 0; }
         }
@@ -70,15 +66,15 @@ public void Seek(long position)
         /// <summary>
         /// Get the current position in the stream
         /// </summary>
-        public long Pos
+        public override long Pos
         {
             get { return BaseStream.Position; }
         }
 
         /// <summary>
         /// Get the total length of the stream (ie. file size)
         /// </summary>
-        public long Size
+        public override long Size
         {
             get { return BaseStream.Length; }
         }
@@ -289,7 +285,7 @@ public double ReadF8le()
 
         #region Unaligned bit values
 
-        public void AlignToByte()
+        public override void AlignToByte()
         {
             Bits = 0;
             BitsLeft = 0;
@@ -361,11 +357,6 @@ public ulong ReadBitsIntLe(int n)
             return res;
         }
 
-        private static ulong GetMaskOnes(int n)
-        {
-            return n == 64 ? 0xffffffffffffffffUL : (1UL << n) - 1;
-        }
-
         #endregion
 
         #region Byte arrays
@@ -441,7 +432,10 @@ public byte[] ReadBytesFull()
         /// <param name="consumeTerminator">True to consume the terminator byte before returning</param>
         /// <param name="eosError">True to throw an error when the EOS was reached before the terminator</param>
         /// <returns></returns>
-        public byte[] ReadBytesTerm(byte terminator, bool includeTerminator, bool consumeTerminator, bool eosError)
+        public byte[] ReadBytesTerm(byte terminator,
+            bool includeTerminator,
+            bool consumeTerminator,
+            bool eosError)
         {
             List<byte> bytes = new List<byte>();
             while (true)
@@ -492,112 +486,6 @@ public byte[] EnsureFixedContents(byte[] expected)
             return bytes;
         }
 
-        public static byte[] BytesStripRight(byte[] src, byte padByte)
-        {
-            return Utilities.BytesStripRight(src, padByte);
-        }
-
-        public static byte[] BytesTerminate(byte[] src, byte terminator, bool includeTerminator)
-        {
-            return Utilities.BytesTerminate(src, terminator, includeTerminator);
-        }
-        #endregion
-
-        #region Byte array processing
-
-        /// <summary>
-        /// Performs XOR processing with given data, XORing every byte of the input with a single value.
-        /// </summary>
-        /// <param name="value">The data toe process</param>
-        /// <param name="key">The key value to XOR with</param>
-        /// <returns>Processed data</returns>
-        public byte[] ProcessXor(byte[] value, int key)
-        {
-            return Utilities.ProcessXor(value, key);
-        }
-
-        /// <summary>
-        /// Performs XOR processing with given data, XORing every byte of the input with a key
-        /// array, repeating from the beginning of the key array if necessary
-        /// </summary>
-        /// <param name="value">The data toe process</param>
-        /// <param name="key">The key array to XOR with</param>
-        /// <returns>Processed data</returns>
-        public byte[] ProcessXor(byte[] value, byte[] key)
-        {
-            return Utilities.ProcessXor(value, key);
-        }
-
-        /// <summary>
-        /// Performs a circular left rotation shift for a given buffer by a given amount of bits.
-        /// Pass a negative amount to rotate right.
-        /// </summary>
-        /// <param name="data">The data to rotate</param>
-        /// <param name="amount">The number of bytes to rotate by</param>
-        /// <param name="groupSize"></param>
-        /// <returns></returns>
-        public byte[] ProcessRotateLeft(byte[] data, int amount, int groupSize)
-        {
-            return Utilities.ProcessRotateLeft(data, amount, groupSize);
-        }
-
-        /// <summary>
-        /// Inflates a deflated zlib byte stream
-        /// </summary>
-        /// <param name="data">The data to deflate</param>
-        /// <returns>The deflated result</returns>
-        public byte[] ProcessZlib(byte[] data)
-        {
-            return Utilities.ProcessZlib(data);
-        }
-
-        #endregion
-
-        #region Misc utility methods
-
-        /// <summary>
-        /// Performs modulo operation between two integers.
-        /// </summary>
-        /// <remarks>
-        /// This method is required because C# lacks a "true" modulo
-        /// operator, the % operator rather being the "remainder"
-        /// operator. We want mod operations to always be positive.
-        /// </remarks>
-        /// <param name="a">The value to be divided</param>
-        /// <param name="b">The value to divide by. Must be greater than zero.</param>
-        /// <returns>The result of the modulo opertion. Will always be positive.</returns>
-        public static int Mod(int a, int b)
-        {
-            return Utilities.Mod(a, b);
-        }
-
-        /// <summary>
-        /// Performs modulo operation between two integers.
-        /// </summary>
-        /// <remarks>
-        /// This method is required because C# lacks a "true" modulo
-        /// operator, the % operator rather being the "remainder"
-        /// operator. We want mod operations to always be positive.
-        /// </remarks>
-        /// <param name="a">The value to be divided</param>
-        /// <param name="b">The value to divide by. Must be greater than zero.</param>
-        /// <returns>The result of the modulo opertion. Will always be positive.</returns>
-        public static long Mod(long a, long b)
-        {
-            return Utilities.Mod(a, b);
-        }
-
-        /// <summary>
-        /// Compares two byte arrays in lexicographical order.
-        /// </summary>
-        /// <returns>negative number if a is less than b, <c>0</c> if a is equal to b, positive number if a is greater than b.</returns>
-        /// <param name="a">First byte array to compare</param>
-        /// <param name="b">Second byte array to compare.</param>
-        public static int ByteArrayCompare(byte[] a, byte[] b)
-        {
-            return Utilities.ByteArrayCompare(a, b);
-        }
-
         #endregion
     }
 }