com.wallstop-studios.unity-helpers 2.0.0-rc79.3 → 2.0.0-rc79.5

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

@@ -62,7 +62,10 @@ namespace SevenZip.Compression.LZ
         {
             base.Init();
             for (UInt32 i = 0; i < _hashSizeSum; i++)
+            {
                 _hash[i] = kEmptyHashValue;
+            }
+
             _cyclicBufferPos = 0;
             ReduceOffsets(-1);
         }
@@ -70,10 +73,15 @@ namespace SevenZip.Compression.LZ
         public new void MovePos()
         {
             if (++_cyclicBufferPos >= _cyclicBufferSize)
+            {
                 _cyclicBufferPos = 0;
+            }
+
             base.MovePos();
             if (_pos == kMaxValForNormalize)
+            {
                 Normalize();
+            }
         }
 
         public new Byte GetIndexByte(Int32 index)
@@ -99,7 +107,10 @@ namespace SevenZip.Compression.LZ
         )
         {
             if (historySize > kMaxValForNormalize - 256)
+            {
                 throw new Exception();
+            }
+
             _cutValue = 16 + (matchMaxLen >> 1);
 
             UInt32 windowReservSize =
@@ -115,7 +126,9 @@ namespace SevenZip.Compression.LZ
 
             UInt32 cyclicBufferSize = historySize + 1;
             if (_cyclicBufferSize != cyclicBufferSize)
+            {
                 _son = new UInt32[(_cyclicBufferSize = cyclicBufferSize) * 2];
+            }
 
             UInt32 hs = kBT2HashSize;
 
@@ -129,20 +142,27 @@ namespace SevenZip.Compression.LZ
                 hs >>= 1;
                 hs |= 0xFFFF;
                 if (hs > (1 << 24))
+                {
                     hs >>= 1;
+                }
+
                 _hashMask = hs;
                 hs++;
                 hs += kFixHashSize;
             }
             if (hs != _hashSizeSum)
+            {
                 _hash = new UInt32[_hashSizeSum = hs];
+            }
         }
 
         public UInt32 GetMatches(UInt32[] distances)
         {
             UInt32 lenLimit;
             if (_pos + _matchMaxLen <= _streamPos)
+            {
                 lenLimit = _matchMaxLen;
+            }
             else
             {
                 lenLimit = _streamPos - _pos;
@@ -170,7 +190,9 @@ namespace SevenZip.Compression.LZ
                 hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
             }
             else
+            {
                 hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
+            }
 
             UInt32 curMatch = _hash[kFixHashSize + hashValue];
             if (HASH_ARRAY)
@@ -180,20 +202,29 @@ namespace SevenZip.Compression.LZ
                 _hash[hash2Value] = _pos;
                 _hash[kHash3Offset + hash3Value] = _pos;
                 if (curMatch2 > matchMinPos)
+                {
                     if (_bufferBase[_bufferOffset + curMatch2] == _bufferBase[cur])
                     {
                         distances[offset++] = maxLen = 2;
                         distances[offset++] = _pos - curMatch2 - 1;
                     }
+                }
+
                 if (curMatch3 > matchMinPos)
+                {
                     if (_bufferBase[_bufferOffset + curMatch3] == _bufferBase[cur])
                     {
                         if (curMatch3 == curMatch2)
+                        {
                             offset -= 2;
+                        }
+
                         distances[offset++] = maxLen = 3;
                         distances[offset++] = _pos - curMatch3 - 1;
                         curMatch2 = curMatch3;
                     }
+                }
+
                 if (offset != 0 && curMatch2 == curMatch)
                 {
                     offset -= 2;
@@ -247,8 +278,13 @@ namespace SevenZip.Compression.LZ
                 if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
                 {
                     while (++len != lenLimit)
+                    {
                         if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
+                        {
                             break;
+                        }
+                    }
+
                     if (maxLen < len)
                     {
                         distances[offset++] = maxLen = len;
@@ -286,7 +322,9 @@ namespace SevenZip.Compression.LZ
             {
                 UInt32 lenLimit;
                 if (_pos + _matchMaxLen <= _streamPos)
+                {
                     lenLimit = _matchMaxLen;
+                }
                 else
                 {
                     lenLimit = _streamPos - _pos;
@@ -313,7 +351,9 @@ namespace SevenZip.Compression.LZ
                     hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
                 }
                 else
+                {
                     hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
+                }
 
                 UInt32 curMatch = _hash[kFixHashSize + hashValue];
                 _hash[kFixHashSize + hashValue] = _pos;
@@ -347,8 +387,13 @@ namespace SevenZip.Compression.LZ
                     if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
                     {
                         while (++len != lenLimit)
+                        {
                             if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
+                            {
                                 break;
+                            }
+                        }
+
                         if (len == lenLimit)
                         {
                             _son[ptr1] = _son[cyclicPos];
@@ -381,9 +426,14 @@ namespace SevenZip.Compression.LZ
             {
                 UInt32 value = items[i];
                 if (value <= subValue)
+                {
                     value = kEmptyHashValue;
+                }
                 else
+                {
                     value -= subValue;
+                }
+
                 items[i] = value;
             }
         }

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);