public static byte[] ZipString(string sBuffer)
{
MemoryStream m_msBZip2 = null;
BZip2OutputStream m_osBZip2 = null;
byte[] result;
try {
m_msBZip2 = new MemoryStream();
Int32 size = sBuffer.Length;
// Prepend the compressed data with the length of the uncompressed data (firs 4 bytes)
//
using (BinaryWriter writer = new BinaryWriter(m_msBZip2, System.Text.Encoding.ASCII)) {
writer.Write(size);
m_osBZip2 = new BZip2OutputStream(m_msBZip2);
m_osBZip2.Write(Encoding.ASCII.GetBytes(sBuffer), 0, sBuffer.Length);
m_osBZip2.Close();
result = m_msBZip2.ToArray();
m_msBZip2.Close();
writer.Close();
}
} finally {
if (m_osBZip2 != null)
{
m_osBZip2.Dispose();
}
if (m_msBZip2 != null)
{
m_msBZip2.Dispose();
}
}
return(result);
}
public void CreateEmptyArchive()
{
var ms = new MemoryStream();
var outStream = new BZip2OutputStream(ms);
#if NET451
outStream.Close();
#elif NETCOREAPP1_0
outStream.Dispose();
#endif
ms = new MemoryStream(ms.ToArray());
ms.Seek(0, SeekOrigin.Begin);
using (BZip2InputStream inStream = new BZip2InputStream(ms)) {
byte[] buffer = new byte[1024];
int pos = 0;
while (true)
{
int numRead = inStream.Read(buffer, 0, buffer.Length);
if (numRead <= 0)
{
break;
}
pos += numRead;
}
Assert.AreEqual(pos, 0);
}
}
void Writer()
{
WriteTargetBytes();
#if NET451
outStream_.Close();
#elif NETCOREAPP1_0
outStream_.Dispose();
#endif
}
public static byte[] ZipStream(byte[] sBuffer)
{
MemoryStream m_msBZip2 = null;
BZip2OutputStream m_osBZip2 = null;
byte[] result;
try
{
m_msBZip2 = new MemoryStream();
Int32 size = sBuffer.Length;
using (BinaryWriter writer = new BinaryWriter(m_msBZip2, System.Text.Encoding.ASCII))
{
writer.Write(size);
m_osBZip2 = new BZip2OutputStream(m_msBZip2);
m_osBZip2.Write(sBuffer, 0, sBuffer.Length);
m_osBZip2.Close();
result = m_msBZip2.ToArray();
m_msBZip2.Close();
writer.Close();
}
}
finally
{
if (m_osBZip2 != null)
{
m_osBZip2.Dispose();
}
if (m_msBZip2 != null)
{
m_msBZip2.Dispose();
}
}
return(result);
}
protected override BitStream internalDecode(BitStream data)
{
MemoryStream sin = new MemoryStream((byte[])data.Value);
MemoryStream sout = new MemoryStream();
BZip2OutputStream bzip2 = new BZip2OutputStream(sout);
sin.CopyTo(bzip2);
bzip2.Dispose();
return(new BitStream(sout.ToArray()));
}
public static void SerializeToFileBZip2(T data, string fileName)
{
FileStream fs = new FileStream(fileName, FileMode.Create);
BZip2OutputStream bzs = new BZip2OutputStream(fs);
BinaryFormatter bFormatter = new BinaryFormatter();
bFormatter.Serialize(bzs, data);
bzs.Close();
bzs.Dispose();
fs.Close();
fs.Dispose();
}
public static byte[] SerializeToBytesBZip2(T data)
{
MemoryStream ms = new MemoryStream();
BZip2OutputStream gzs = new BZip2OutputStream(ms);
BinaryFormatter bFormatter = new BinaryFormatter();
bFormatter.Serialize(gzs, data);
gzs.Close();
gzs.Dispose();
byte[] ret = ms.ToArray();
ms.Close();
ms.Dispose();
return(ret);
}
/// <summary>
/// Saves a woman to the given path.
/// </summary>
/// <param name="w">Woman to save.</param>
/// <param name="path"><Path to the new/overwritten file./param>
/// <returns>True if file successfully saved.</returns>
public static bool SaveWomanTo(Woman w, string path)
{
try
{
// Serialize to memory stream to make sure data is serializable.
var saveMemoryStream = new MemoryStream();
var testSaveDataStream = new BZip2OutputStream(saveMemoryStream, 9);
// Make sure serialization goes well.
new XmlSerializer(w.GetType()).Serialize(testSaveDataStream, w);
testSaveDataStream.Close();
var data = saveMemoryStream.ToArray();
testSaveDataStream.Close();
// Dispose resources.
saveMemoryStream.Dispose();
testSaveDataStream.Dispose();
// Prepare to read the saved data.
var loadMemoryStream = new MemoryStream(data);
var testLoadDataStream = new BZip2InputStream(loadMemoryStream);
// Make sure we can read it back.
new XmlSerializer(typeof(Woman)).Deserialize(testLoadDataStream);
testLoadDataStream.Close();
// Dispose resources.
loadMemoryStream.Dispose();
testLoadDataStream.Dispose();
// Make sure we have access to the file system.
var filestream = new FileStream(path, FileMode.Create);
// Save to file.
filestream.Write(data, 0, data.Length);
filestream.Close();
}
catch (Exception ex)
{
MsgBox.Error(TEXT.Get["Unable_to_save_file"] + ex.Message, TEXT.Get["Error"]);
return(false);
}
return(true);
}
/*static int GetMaterialIndex(Material material)
* {
* if (!_materialPack.Contains(material))
* _materialPack.Add(material);
* return _materialPack.IndexOf(material);
* }*/
/*static int GetTextureIndex(Texture txtr)
* {
* if (_texturePack == null)
* return -1;
* if (!_texturePack.Contains(txtr))
* _texturePack.Add(txtr);
* return _texturePack.IndexOf(txtr);
* }*/
/*byte[] GetResource(object value)
* {
* if (!_objectPack.Contains(value))
* {
* _objectPack.Add(value);
* _bytesPack.Add(Encoding(value));
* }
* var result = new byte[]{252,0,0,0,0};
* Buffer.BlockCopy(EncodeInteger(_objectPack.IndexOf(value)), 0, result, 1, 4);
* return result;
* }*/
/// <summary>
/// Compress byte array
/// For decompress use Decode
///
/// </summary>
/// <param name="data">array of byte</param>
/// <returns></returns>
public byte[] Compress(byte[] data)
{
MemoryStream mMsBZip2 = null;
BZip2OutputStream mOsBZip2 = null;
byte[] result;
try
{
mMsBZip2 = new MemoryStream();
mOsBZip2 = new BZip2OutputStream(mMsBZip2);
mOsBZip2.Write(data, 0, data.Length);
mOsBZip2.Close();
var packLength = mMsBZip2.ToArray().Length;
var unpackLength = data.Length;
result = new byte[11 + packLength];
Buffer.SetByte(result, 0, Version);
Buffer.SetByte(result, 1, 0x0); //Size of next head (bytes)
#region Head
//reserved
//Buffer.SetByte(result, 2, 0x0);example head
#endregion
Buffer.SetByte(result, 2, 0xfe); //Compress
Buffer.BlockCopy(BitConverter.GetBytes(packLength), 0, result, 3, 4);
Buffer.BlockCopy(BitConverter.GetBytes(unpackLength), 0, result, 7, 4);
Buffer.BlockCopy(mMsBZip2.ToArray(), 0, result, 11, packLength);
mMsBZip2.Close();
mMsBZip2.Dispose();
}
finally
{
if (mOsBZip2 != null)
{
mOsBZip2.Dispose();
}
if (mMsBZip2 != null)
{
mMsBZip2.Dispose();
}
}
return(result);
}
public void BasicRoundTrip()
{
var ms = new MemoryStream();
var outStream = new BZip2OutputStream(ms);
byte[] buf = new byte[10000];
var rnd = new Random();
rnd.NextBytes(buf);
outStream.Write(buf, 0, buf.Length);
#if NET451
outStream.Close();
#elif NETCOREAPP1_0
outStream.Dispose();
#endif
ms = new MemoryStream(ms.ToArray());
ms.Seek(0, SeekOrigin.Begin);
using (BZip2InputStream inStream = new BZip2InputStream(ms)) {
byte[] buf2 = new byte[buf.Length];
int pos = 0;
while (true)
{
int numRead = inStream.Read(buf2, pos, 4096);
if (numRead <= 0)
{
break;
}
pos += numRead;
}
for (int i = 0; i < buf.Length; ++i)
{
Assert.AreEqual(buf2[i], buf[i]);
}
}
}
public byte[] Encode(byte[] src, int level = 0)
{
MemoryStream m_msBZip2 = null;
BZip2OutputStream m_osBZip2 = null;
byte[] result = null;
try
{
m_msBZip2 = new MemoryStream();
Int32 size = src.Length;
// Prepend the compressed data with the length of the uncompressed data (firs 4 bytes)
//
using (BinaryWriter writer = new BinaryWriter(m_msBZip2, System.Text.Encoding.ASCII))
{
writer.Write(size);
m_osBZip2 = new BZip2OutputStream(m_msBZip2);
m_osBZip2.Write(src, 0, src.Length);
m_osBZip2.Close();
result = m_msBZip2.ToArray();
m_msBZip2.Close();
writer.Close();
}
}
finally
{
if (m_osBZip2 != null)
{
m_osBZip2.Dispose();
}
if (m_msBZip2 != null)
{
m_msBZip2.Dispose();
}
}
return(result);
}
