youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

c-o

Browse Source
This commit is contained in:
Nitload
2024-06-10 15:12:08 +08:00
parent f6963b8e00
commit be6c2e6b92
305 changed files with 28336 additions and 5938 deletions
Download Patch File Download Diff File Expand all files Collapse all files
源代码/StgSharp/Data/Encode/CodeCounter.cs
-100
View File
@@ -1,100 +0,0 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="CodeCounter.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp.Data;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.Data
{
public static class CodeSeparator
{
public static List<(T, ulong)> CountCodeFrequency<T>(T[] rawArray) where T : struct
{
Dictionary<T, ulong> frequencyCollection = new Dictionary<T, ulong>();
foreach (var item in rawArray)
{
if (frequencyCollection.ContainsKey(item))
{
frequencyCollection[item] += 1;
}
else
{
frequencyCollection.Add(item, 1);
}
}
return frequencyCollection.OrderByDescending(pair => pair.Value)
.Select(pair => (pair.Key, pair.Value)).ToList();
}
public static unsafe T[] SeparateCode<T>(string filePath) where T : struct
{
byte[] allByte = File.ReadAllBytes(filePath);
List<T> rawList = new List<T>();
fixed (byte* allBytePtr = allByte)
{
for (int i = 0; i < allByte.Length; i += Marshal.SizeOf<T>())
{
T t = new T();
t = *(T*)(allBytePtr + i);
rawList.Add(t);
}
}
return rawList.ToArray();
}
public static unsafe T[] SeparateCode<T>(byte[] stream) where T : struct
{
List<T> rawList = new List<T>();
fixed (byte* allBytePtr = stream)
{
for (int i = 0; i < stream.Length; i += Marshal.SizeOf<T>())
{
T t = new T();
t = *(T*)(allBytePtr + i);
rawList.Add(t);
}
}
return rawList.ToArray();
}
}
}
源代码/StgSharp/Data/Encode/EncodStream.cs
-82
View File
@@ -1,82 +0,0 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="EncodStream.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp.Data;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Data
{
public class EncodeStream
{
byte[] buffer;
BitArray bufferArray;
byte count;
List<byte> data;
public EncodeStream()
{
count = 0;
buffer = new byte[1];
data = new List<byte>();
bufferArray = new BitArray(8, true);
}
public List<byte> EncodeData
=> data;
public int Length => data.Count;
public string Output => Encoding.UTF8.GetString(data.ToArray());
public void WriteBits<T>(HuffmanKey<T> key) where T : struct
{
BitArray bit = key.GetBitArray();
for (int i = 0; i < bit.Count; i++)
{
if (count == 8)
{
bufferArray.CopyTo(buffer, 0);
data.Add(buffer[0]);
count = 0;
}
bufferArray[count] = bit[i];
count++;
}
}
}
}
源代码/StgSharp/Data/Encode/Encoder.cs
-55
View File
@@ -1,55 +0,0 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="Encoder.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp.Data;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Data
{
public static class Encode
{
public static void Freeze<T>(
Dictionary<T, HuffmanKey<T>> indexDict
)
where T : struct
{
foreach (var key in indexDict)
{
key.Value.Freeze();
}
}
}
}
源代码/StgSharp/Data/Encode/HuffmanTree.cs
-237
View File
@@ -1,237 +0,0 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="HuffmanTree.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Xml;
using System.Xml.Linq;
namespace StgSharp.Data
{
public partial class HuffmanTree<T> where T : struct
{
HuffmanNodeList<T> leaves;
internal HuffmanTree(HuffmanNodeList<T> nodeList)
{
leaves = nodeList;
}
public HuffmanNodeList<T> LeafList
=> leaves;
public TreeNode<T> Root
=> leaves.Last;
public static HuffmanTree<T> BuildHuffmanTree(List<(T, ulong)> metaData)
{
if (metaData.Count <= 3)
{
throw new Exception("Data is too little, no need to compress");
}
HuffmanNodeList<T> leaves = new HuffmanNodeList<T>();
HuffmanNodeList<T> all = new HuffmanNodeList<T>();
foreach (var item in metaData)
{
leaves.Add(new TreeNode<T>(item));
}
while (leaves.Count > 2)
{
TreeNode<T> node, toMove;
if (leaves.Last._frequency < leaves.BeforeLast._frequency)
{
if (leaves.BeforeLast._frequency < leaves.OverLast._frequency)
{
//第三节点最大
node = new TreeNode<T>(leaves.BeforeLast, leaves.Last);
toMove = leaves.RemoveAndGetLast; all.Add(toMove);
toMove = leaves.RemoveAndGetLast; all.Add(toMove);
leaves.Add(node);
}
else
{
//第二节点最大
node = (leaves.Last._frequency < leaves.OverLast._frequency) ?
(new TreeNode<T>(leaves.OverLast, leaves.Last)) :
(new TreeNode<T>(leaves.Last, leaves.OverLast));
toMove = leaves.RemoveAndGetLast; all.Add(toMove);
toMove = leaves.RemoveAndGetBeforeLast; all.Add(toMove);
leaves.Add(node);
}
}
else
{
if (leaves.Last._frequency < leaves.OverLast._frequency)
{
//第三节点最大
node = new TreeNode<T>(leaves.Last, leaves.BeforeLast);
toMove = leaves.RemoveAndGetLast; all.Add(toMove);
toMove = leaves.RemoveAndGetLast; all.Add(toMove);
leaves.Add(node);
}
else
{
//第一节点最大
node = (leaves.BeforeLast._frequency < leaves.OverLast._frequency) ?
(new TreeNode<T>(leaves.OverLast, leaves.BeforeLast)) :
(new TreeNode<T>(leaves.BeforeLast, leaves.OverLast));
toMove = leaves.RemoveAndGetBeforeLast; all.Add(toMove);
toMove = leaves.RemoveAndGetBeforeLast; all.Add(toMove);
leaves.Add(node);
}
}
leaves = new HuffmanNodeList<T>(leaves.OrderByDescending(pair => pair.frequency)
.Select(pair => pair).ToList());
}
TreeNode<T> lastOne = leaves[0];
TreeNode<T> lastTwo = leaves[1];
TreeNode<T> root = (lastOne.frequency > lastTwo.frequency) ?
(new TreeNode<T>(lastOne, lastTwo)) :
(new TreeNode<T>(lastTwo, lastOne));
all.Add(lastOne);
all.Add(lastTwo);
all.Add(root);
leaves = all;
return new HuffmanTree<T>(all);
}
}
public class HuffmanNodeList<T> : List<TreeNode<T>> where T : struct
{
public HuffmanNodeList() : base()
{
}
public HuffmanNodeList(IEnumerable<TreeNode<T>> values) : base(values)
{ }
public TreeNode<T> BeforeLast
=> this[Count - 2];
public TreeNode<T> Last
=> this[Count - 1];
public TreeNode<T> OverLast
=> this[Count - 3];
public TreeNode<T> RemoveAndGetBeforeLast
{
get
{
TreeNode<T> ret = this[Count - 2];
RemoveAt(Count - 2);
return ret;
}
}
public TreeNode<T> RemoveAndGetLast
{
get
{
TreeNode<T> ret = this[Count - 1];
RemoveAt(Count - 1);
return ret;
}
}
public TreeNode<T> RemoveAndGetOverLast
{
get
{
TreeNode<T> ret = this[Count - 3];
RemoveAt(Count - 3);
return ret;
}
}
public void Add(T element, ulong f)
{
base.Add(new TreeNode<T>(element, f));
}
}
public class TreeNode<T> where T : struct
{
internal ulong _frequency;
internal TreeNode<T> _left;
internal TreeNode<T> _right;
internal T? _value;
internal TreeNode(TreeNode<T> left, TreeNode<T> right)
{
_left = left;
_right = right;
_value = null;
_frequency = left._frequency + right._frequency;
}
public TreeNode((T, ulong) data)
{
_value = data.Item1;
_frequency = data.Item2;
}
public TreeNode(T? value, ulong frequncy)
{
_value = value;
_frequency = frequncy;
}
public ulong frequency => _frequency;
public TreeNode<T> Left => _left;
public TreeNode<T> Right => _right;
public T? Value => _value;
}
}
源代码/StgSharp/Data/Encode/MappingTable.cs
-189
View File
@@ -1,189 +0,0 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="MappingTable.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.Data
{
public partial class HuffmanTree<T> where T : struct
{
public Dictionary<T, HuffmanKey<T>> BuildHuffmanDictionary()
{
Dictionary<T, HuffmanKey<T>> ret = new Dictionary<T, HuffmanKey<T>>();
TreeNode<T> root = Root;
HuffmanKey<T> key = new HuffmanKey<T>();
key = key.SetSide(KeySide.Right);
InternalBuildDictionary(ret, root, key);
return ret;
}
public void InternalBuildDictionary(
Dictionary<T, HuffmanKey<T>> dict,
TreeNode<T> node,
HuffmanKey<T> valueTemp
)
{
HuffmanKey<T> nativeNode = new HuffmanKey<T>(valueTemp.bitList);
nativeNode.AddIndexLevel();
//检查左节点
if (node._left.Value == null)
{
//左节点不是叶子节点，继续搜索
InternalBuildDictionary(
dict,
node._left,
nativeNode.SetSide(KeySide.Left));
}
else
{
//左节点是叶子节点，添加值
dict.Add(node._left.Value.Value, nativeNode.SetSide(KeySide.Left));
}
//检查右节点
if (node._right.Value == null)
{
//右节点不是叶子节点，继续搜索
InternalBuildDictionary(
dict,
node._right,
nativeNode.SetSide(KeySide.Right));
}
else
{
//右节点是叶子节点，添加值
dict.Add(node._right.Value.Value, nativeNode.SetSide(KeySide.Right));
}
//这里检查自己是不是叶子节点
//但是上面已经检查过了，不需要被检查
}
}
public class HuffmanKey<T> where T : struct
{
internal List<bool> bitList;
internal BitArray code;
public HuffmanKey()
{
bitList = new List<bool>();
bitList.Add(false);
}
public HuffmanKey(List<bool> former)
{
bitList = new List<bool>(former);
}
public bool IsSupported
{
get
{
return
(typeof(T) == typeof(byte)) ||
(typeof(T) == typeof(uint)) ||
(typeof(T) == typeof(ushort)) ||
(typeof(T) == typeof(ulong)) ||
#if NET7_0_OR_GREATER
typeof(T) == typeof(UInt128) ||
#endif
(typeof(T) == typeof(M128));
}
}
public unsafe void AddIndexLevel()
{
bitList.Add(true);
}
public void Freeze()
{
if (code != null)
{
return;
}
bitList.RemoveAt(0);
code = new BitArray(bitList.ToArray());
}
public BitArray GetBitArray()
{
if (code == null)
{
List<bool> list = new List<bool>(bitList);
list.RemoveAt(0);
return new BitArray(list.ToArray());
}
return code;
}
public unsafe byte[] GetBytes()
{
byte[] bytes = new byte[(bitList.Count / 8) + 1];
BitArray array = new BitArray(bitList.ToArray());
array.CopyTo(bytes, 0);
return bytes;
}
public unsafe HuffmanKey<T> SetSide(KeySide side)
{
HuffmanKey<T> newKey = new HuffmanKey<T>(bitList);
newKey.bitList[newKey.bitList.Count - 1] = side == KeySide.Left;
return newKey;
}
public override string ToString()
{
string str = string.Empty;
foreach (var bit in bitList)
{
str += $"{bit} ";
}
return str;
}
}
public enum KeySide
{
Left,
Right
}
}
源代码/StgSharp/Data/GlobalData/idProvider.cs
-46
View File
@@ -1,46 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Data
{
public partial class Area
{
private static byte leastUnusedDisc;
public byte NewDisc(byte raidWith)
{
byte ret = leastUnusedDisc;
leastUnusedDisc++;
return ret;
}
public void ClearDiscIDBuffer()
{
leastUnusedDisc = 0;
}
private int leastUnusedID;
public int NewID()
{
int ret = leastUnusedID;
if (ret == int.MaxValue)
{
throw new ArgumentOutOfRangeException("Reaches max IDs that one ssd file can provide.");
}
leastUnusedID++;
return ret;
}
public void ClearIDBuffer()
{
leastUnusedID = 1;
}
}
}
源代码/StgSharp/Data/Serialize/BitArray.cs
-161
View File
@@ -1,161 +0,0 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="BitArray.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
namespace StgSharp.Data
{
public static partial class Serializer
{
public static void Deserialize(byte[] stream, out BitArray target)
{
List<bool> boolStream = new List<bool>(4 * stream.Length);
int i = 0, count = 0;
foreach (byte b in stream)
{
uint raw = b;
for (i = 0; i < 4; i++)
{
switch (raw & 0b11)
{
case (uint)BoolMap.True_0:
boolStream.Add(true);
break;
case (uint)BoolMap.False_0:
boolStream.Add(false);
break;
case (uint)BoolMap.None_0:
goto end;
default:
throw new Exception();
}
raw >>= 2;
count++;
continue;
end:
{
break;
}
}
}
while (boolStream.Count > count)
{
boolStream.RemoveAt(count);
}
target = new BitArray(boolStream.ToArray());
}
/// <summary>
/// Serialize a <see cref="BitArray"/>, useful when writing
/// a Huffman tree index dictionary to file.
/// </summary>
/// <param name="bits"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public static byte[] Serialize(BitArray bits)
{
int size = (bits.Count / 4) + 1;
List<byte> ret = new List<byte>(size);
int count = 0, total = 0; byte temp = new byte();
for (int i = 0; i < bits.Count; i++)
{
if (count == 4)
{
ret.Add(temp);
count = 0;
temp = 0;
total++;
}
switch (count)
{
case 0:
temp |= (byte)(bits[i] ? BoolMap.True_0 : BoolMap.False_0);
break;
case 1:
temp |= (byte)(bits[i] ? BoolMap.True_1 : BoolMap.False_1);
break;
case 2:
temp |= (byte)(bits[i] ? BoolMap.True_2 : BoolMap.False_2);
break;
case 3:
temp |= (byte)(bits[i] ? BoolMap.True_3 : BoolMap.False_3);
break;
default:
throw new Exception();
}
count++;
}
for (; count < 4; count++)
{
switch (count)
{
case 1:
temp |= (byte)BoolMap.None_1;
break;
case 2:
temp |= (byte)BoolMap.None_2;
break;
case 3:
temp |= (byte)BoolMap.None_3;
break;
default:
throw new Exception();
}
continue;
}
ret.Add(temp);
return ret.ToArray();
}
}
internal enum BoolMap : byte
{
False_0 = 0b00000010,
True_0 = 0b00000001,
None_0 = 0b00000011,
False_1 = 0b00001000,
True_1 = 0b00000100,
None_1 = 0b00001100,
False_2 = 0b00100000,
True_2 = 0b00010000,
None_2 = 0b00110000,
False_3 = 0b10000000,
True_3 = 0b01000000,
None_3 = 0b11000000,
}
}
源代码/StgSharp/Data/Serialize/Dictionary.cs
-97
View File
@@ -1,97 +0,0 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="Dictionary.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
namespace StgSharp.Data
{
/// <summary>
/// A class contains a sets of methods to serialize several types
/// </summary>
public static partial class Serializer
{
/**/
public static void Deserialize(byte[] data, out Dictionary<byte, BitArray> dict)
{
dict = new Dictionary<byte, BitArray>();
int stat = 0; byte key = 0;
byte[] raw = new byte[0];
foreach (var b in data)
{
switch (stat)
{
case 0: //getting key
if (raw.Length != 0)
{
BitArray bits;
Deserialize(raw, out bits);
dict.Add(key, bits);
}
key = b;
stat -= 1;
break;
case -1: //getting length
raw = new byte[b];
stat = b;
break;
default:
raw[raw.Length - stat] = b;
stat--;
break;
}
}
}
/**/
public static byte[] Serialize(Dictionary<byte, BitArray> table)
{
using (var stream = new MemoryStream())
{
foreach (var pair in table)
{
stream.WriteByte(pair.Key);
byte[] keyCode = Serialize(pair.Value);
stream.WriteByte((byte)keyCode.Length);
stream.Write(keyCode, 0, keyCode.Length);
}
return stream.ToArray();
}
}
}
}