com.wallstop-studios.unity-helpers 2.0.0-rc79.4 → 2.0.0-rc79.6

package/Runtime/Utils/SevenZip/Compress/LZ/LzInWindow.cs

@@ -26,25 +26,36 @@ namespace SevenZip.Compression.LZ
             UInt32 offset = (UInt32)(_bufferOffset) + _pos - _keepSizeBefore;
             // we need one additional byte, since MovePos moves on 1 byte.
             if (offset > 0)
+            {
                 offset--;
+            }
 
             UInt32 numBytes = (UInt32)(_bufferOffset) + _streamPos - offset;
 
             // check negative offset ????
             for (UInt32 i = 0; i < numBytes; i++)
+            {
                 _bufferBase[i] = _bufferBase[offset + i];
+            }
+
             _bufferOffset -= offset;
         }
 
         public virtual void ReadBlock()
         {
             if (_streamEndWasReached)
+            {
                 return;
+            }
+
             while (true)
             {
                 int size = (int)((0 - _bufferOffset) + _blockSize - _streamPos);
                 if (size == 0)
+                {
                     return;
+                }
+
                 int numReadBytes = _stream.Read(
                     _bufferBase,
                     (int)(_bufferOffset + _streamPos),
@@ -55,14 +66,18 @@ namespace SevenZip.Compression.LZ
                     _posLimit = _streamPos;
                     UInt32 pointerToPostion = _bufferOffset + _posLimit;
                     if (pointerToPostion > _pointerToLastSafePosition)
+                    {
                         _posLimit = (UInt32)(_pointerToLastSafePosition - _bufferOffset);
+                    }
 
                     _streamEndWasReached = true;
                     return;
                 }
                 _streamPos += (UInt32)numReadBytes;
                 if (_streamPos >= _pos + _keepSizeAfter)
+                {
                     _posLimit = _streamPos - _keepSizeAfter;
+                }
             }
         }
 
@@ -111,7 +126,10 @@ namespace SevenZip.Compression.LZ
             {
                 UInt32 pointerToPostion = _bufferOffset + _pos;
                 if (pointerToPostion > _pointerToLastSafePosition)
+                {
                     MoveBlock();
+                }
+
                 ReadBlock();
             }
         }
@@ -125,15 +143,23 @@ namespace SevenZip.Compression.LZ
         public UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit)
         {
             if (_streamEndWasReached)
+            {
                 if ((_pos + index) + limit > _streamPos)
+                {
                     limit = _streamPos - (UInt32)(_pos + index);
+                }
+            }
+
             distance++;
             // Byte *pby = _buffer + (size_t)_pos + index;
             UInt32 pby = _bufferOffset + _pos + (UInt32)index;
 
             UInt32 i;
             for (i = 0; i < limit && _bufferBase[pby + i] == _bufferBase[pby + i - distance]; i++)
+            {
                 ;
+            }
+
             return i;
         }
 

package/Runtime/Utils/SevenZip/Compress/LZ/LzOutWindow.cs

@@ -47,15 +47,23 @@ namespace SevenZip.Compression.LZ
             {
                 uint curSize = _windowSize - _pos;
                 if (size < curSize)
+                {
                     curSize = size;
+                }
+
                 int numReadBytes = stream.Read(_buffer, (int)_pos, (int)curSize);
                 if (numReadBytes == 0)
+                {
                     return false;
+                }
+
                 size -= (uint)numReadBytes;
                 _pos += (uint)numReadBytes;
                 _streamPos += (uint)numReadBytes;
                 if (_pos == _windowSize)
+                {
                     _streamPos = _pos = 0;
+                }
             }
             return true;
         }
@@ -70,10 +78,16 @@ namespace SevenZip.Compression.LZ
         {
             uint size = _pos - _streamPos;
             if (size == 0)
+            {
                 return;
+            }
+
             _stream.Write(_buffer, (int)_streamPos, (int)size);
             if (_pos >= _windowSize)
+            {
                 _pos = 0;
+            }
+
             _streamPos = _pos;
         }
 
@@ -81,14 +95,22 @@ namespace SevenZip.Compression.LZ
         {
             uint pos = _pos - distance - 1;
             if (pos >= _windowSize)
+            {
                 pos += _windowSize;
+            }
+
             for (; len > 0; len--)
             {
                 if (pos >= _windowSize)
+                {
                     pos = 0;
+                }
+
                 _buffer[_pos++] = _buffer[pos++];
                 if (_pos >= _windowSize)
+                {
                     Flush();
+                }
             }
         }
 
@@ -96,14 +118,19 @@ namespace SevenZip.Compression.LZ
         {
             _buffer[_pos++] = b;
             if (_pos >= _windowSize)
+            {
                 Flush();
+            }
         }
 
         public byte GetByte(uint distance)
         {
             uint pos = _pos - distance - 1;
             if (pos >= _windowSize)
+            {
                 pos += _windowSize;
+            }
+
             return _buffer[pos];
         }
     }

package/Runtime/Utils/SevenZip/Compress/LZMA/LzmaBase.cs

@@ -24,11 +24,17 @@ namespace SevenZip.Compression.LZMA
             public void UpdateChar()
             {
                 if (Index < 4)
+                {
                     Index = 0;
+                }
                 else if (Index < 10)
+                {
                     Index -= 3;
+                }
                 else
+                {
                     Index -= 6;
+                }
             }
 
             public void UpdateMatch()
@@ -67,7 +73,10 @@ namespace SevenZip.Compression.LZMA
         {
             len -= kMatchMinLen;
             if (len < kNumLenToPosStates)
+            {
                 return len;
+            }
+
             return (uint)(kNumLenToPosStates - 1);
         }
 

package/Runtime/Utils/SevenZip/Compress/LZMA/LzmaDecoder.cs

@@ -12,8 +12,8 @@ namespace SevenZip.Compression.LZMA
         {
             BitDecoder m_Choice = new BitDecoder();
             BitDecoder m_Choice2 = new BitDecoder();
-            BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
-            BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
+            readonly BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
+            readonly BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
             BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
             uint m_NumPosStates = 0;
 
@@ -42,12 +42,16 @@ namespace SevenZip.Compression.LZMA
             public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)
             {
                 if (m_Choice.Decode(rangeDecoder) == 0)
+                {
                     return m_LowCoder[posState].Decode(rangeDecoder);
+                }
                 else
                 {
                     uint symbol = Base.kNumLowLenSymbols;
                     if (m_Choice2.Decode(rangeDecoder) == 0)
+                    {
                         symbol += m_MidCoder[posState].Decode(rangeDecoder);
+                    }
                     else
                     {
                         symbol += Base.kNumMidLenSymbols;
@@ -72,14 +76,18 @@ namespace SevenZip.Compression.LZMA
                 public void Init()
                 {
                     for (int i = 0; i < 0x300; i++)
+                    {
                         m_Decoders[i].Init();
+                    }
                 }
 
                 public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)
                 {
                     uint symbol = 1;
-                    do symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
-                    while (symbol < 0x100);
+                    do
+                    {
+                        symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
+                    } while (symbol < 0x100);
                     return (byte)symbol;
                 }
 
@@ -95,7 +103,10 @@ namespace SevenZip.Compression.LZMA
                         if (matchBit != bit)
                         {
                             while (symbol < 0x100)
+                            {
                                 symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
+                            }
+
                             break;
                         }
                     } while (symbol < 0x100);
@@ -111,21 +122,28 @@ namespace SevenZip.Compression.LZMA
             public void Create(int numPosBits, int numPrevBits)
             {
                 if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)
+                {
                     return;
+                }
+
                 m_NumPosBits = numPosBits;
                 m_PosMask = ((uint)1 << numPosBits) - 1;
                 m_NumPrevBits = numPrevBits;
                 uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
                 m_Coders = new Decoder2[numStates];
                 for (uint i = 0; i < numStates; i++)
+                {
                     m_Coders[i].Create();
+                }
             }
 
             public void Init()
             {
                 uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
                 for (uint i = 0; i < numStates; i++)
+                {
                     m_Coders[i].Init();
+                }
             }
 
             uint GetState(uint pos, byte prevByte)
@@ -151,31 +169,34 @@ namespace SevenZip.Compression.LZMA
             }
         };
 
-        LZ.OutWindow m_OutWindow = new LZ.OutWindow();
-        RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();
+        readonly LZ.OutWindow m_OutWindow = new LZ.OutWindow();
+        readonly RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();
 
-        BitDecoder[] m_IsMatchDecoders = new BitDecoder[
+        readonly BitDecoder[] m_IsMatchDecoders = new BitDecoder[
             Base.kNumStates << Base.kNumPosStatesBitsMax
         ];
-        BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];
-        BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];
-        BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];
-        BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];
-        BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[
+
+        readonly BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];
+        readonly BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];
+        readonly BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];
+        readonly BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];
+
+        readonly BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[
             Base.kNumStates << Base.kNumPosStatesBitsMax
         ];
 
-        BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
-        BitDecoder[] m_PosDecoders = new BitDecoder[
+        readonly BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
+
+        readonly BitDecoder[] m_PosDecoders = new BitDecoder[
             Base.kNumFullDistances - Base.kEndPosModelIndex
         ];
 
         BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
 
-        LenDecoder m_LenDecoder = new LenDecoder();
-        LenDecoder m_RepLenDecoder = new LenDecoder();
+        readonly LenDecoder m_LenDecoder = new LenDecoder();
+        readonly LenDecoder m_RepLenDecoder = new LenDecoder();
 
-        LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
+        readonly LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
 
         uint m_DictionarySize;
         uint m_DictionarySizeCheck;
@@ -186,7 +207,9 @@ namespace SevenZip.Compression.LZMA
         {
             m_DictionarySize = 0xFFFFFFFF;
             for (int i = 0; i < Base.kNumLenToPosStates; i++)
+            {
                 m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
+            }
         }
 
         void SetDictionarySize(uint dictionarySize)
@@ -203,16 +226,25 @@ namespace SevenZip.Compression.LZMA
         void SetLiteralProperties(int lp, int lc)
         {
             if (lp > 8)
+            {
                 throw new InvalidParamException();
+            }
+
             if (lc > 8)
+            {
                 throw new InvalidParamException();
+            }
+
             m_LiteralDecoder.Create(lp, lc);
         }
 
         void SetPosBitsProperties(int pb)
         {
             if (pb > Base.kNumPosStatesBitsMax)
+            {
                 throw new InvalidParamException();
+            }
+
             uint numPosStates = (uint)1 << pb;
             m_LenDecoder.Create(numPosStates);
             m_RepLenDecoder.Create(numPosStates);
@@ -243,10 +275,15 @@ namespace SevenZip.Compression.LZMA
 
             m_LiteralDecoder.Init();
             for (i = 0; i < Base.kNumLenToPosStates; i++)
+            {
                 m_PosSlotDecoder[i].Init();
+            }
+
             // m_PosSpecDecoder.Init();
             for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)
+            {
                 m_PosDecoders[i].Init();
+            }
 
             m_LenDecoder.Init();
             m_RepLenDecoder.Init();
@@ -278,7 +315,10 @@ namespace SevenZip.Compression.LZMA
                     m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax]
                         .Decode(m_RangeDecoder) != 0
                 )
+                {
                     throw new DataErrorException();
+                }
+
                 state.UpdateChar();
                 byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
                 m_OutWindow.PutByte(b);
@@ -298,18 +338,23 @@ namespace SevenZip.Compression.LZMA
                         byte b;
                         byte prevByte = m_OutWindow.GetByte(0);
                         if (!state.IsCharState())
+                        {
                             b = m_LiteralDecoder.DecodeWithMatchByte(
                                 m_RangeDecoder,
                                 (uint)nowPos64,
                                 prevByte,
                                 m_OutWindow.GetByte(rep0)
                             );
+                        }
                         else
+                        {
                             b = m_LiteralDecoder.DecodeNormal(
                                 m_RangeDecoder,
                                 (uint)nowPos64,
                                 prevByte
                             );
+                        }
+
                         m_OutWindow.PutByte(b);
                         state.UpdateChar();
                         nowPos64++;
@@ -344,7 +389,9 @@ namespace SevenZip.Compression.LZMA
                                 else
                                 {
                                     if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
+                                    {
                                         distance = rep2;
+                                    }
                                     else
                                     {
                                         distance = rep3;
@@ -374,12 +421,14 @@ namespace SevenZip.Compression.LZMA
                                 int numDirectBits = (int)((posSlot >> 1) - 1);
                                 rep0 = ((2 | (posSlot & 1)) << numDirectBits);
                                 if (posSlot < Base.kEndPosModelIndex)
+                                {
                                     rep0 += BitTreeDecoder.ReverseDecode(
                                         m_PosDecoders,
                                         rep0 - posSlot - 1,
                                         m_RangeDecoder,
                                         numDirectBits
                                     );
+                                }
                                 else
                                 {
                                     rep0 += (
@@ -391,7 +440,9 @@ namespace SevenZip.Compression.LZMA
                                 }
                             }
                             else
+                            {
                                 rep0 = posSlot;
+                            }
                         }
                         if (
                             rep0 >= m_OutWindow.TrainSize + nowPos64
@@ -399,7 +450,10 @@ namespace SevenZip.Compression.LZMA
                         )
                         {
                             if (rep0 == 0xFFFFFFFF)
+                            {
                                 break;
+                            }
+
                             throw new DataErrorException();
                         }
                         m_OutWindow.CopyBlock(rep0, len);
@@ -415,16 +469,25 @@ namespace SevenZip.Compression.LZMA
         public void SetDecoderProperties(byte[] properties)
         {
             if (properties.Length < 5)
+            {
                 throw new InvalidParamException();
+            }
+
             int lc = properties[0] % 9;
             int remainder = properties[0] / 9;
             int lp = remainder % 5;
             int pb = remainder / 5;
             if (pb > Base.kNumPosStatesBitsMax)
+            {
                 throw new InvalidParamException();
+            }
+
             UInt32 dictionarySize = 0;
             for (int i = 0; i < 4; i++)
+            {
                 dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);
+            }
+
             SetDictionarySize(dictionarySize);
             SetLiteralProperties(lp, lc);
             SetPosBitsProperties(pb);