private static MemoryStream UnZip(byte[] data)
{
if (data == null)
{
return(null);
}
MemoryStream memoryStream = null;
MemoryStream memoryStream2 = null;
InflaterInputStream inflaterInputStream = null;
try
{
memoryStream = new MemoryStream(data);
memoryStream2 = new MemoryStream();
inflaterInputStream = new InflaterInputStream(memoryStream);
byte[] array = new byte[data.Length];
while (true)
{
int num = inflaterInputStream.Read(array, 0, array.Length);
if (num <= 0)
{
break;
}
memoryStream2.Write(array, 0, num);
}
memoryStream2.Flush();
memoryStream2.Seek(0L, SeekOrigin.Begin);
}
finally
{
if (memoryStream != null)
{
memoryStream.Close();
}
if (inflaterInputStream != null)
{
inflaterInputStream.Close();
}
memoryStream = null;
inflaterInputStream = null;
}
return(memoryStream2);
}
private List <byte> Decompress(FileStream data, long offset, long length)
{
var t = new List <byte>();
var inflator = new Inflater();
Stream stream = CopyStream(data, offset, (int)length);
var in1 = new InflaterInputStream(stream, inflator, 1024 * 8);
var buffer = new byte[1024 * 8];
int len;
while ((len = in1.Read(buffer, 0, 1024 * 8)) > 0)
{
for (int i = 0; i < len; i++)
{
t.Add(buffer[i]);
}
}
return(t);
}
public override bool Load(Stream input)
{
if (this._IsLoaded == true)
{
return(true);
}
input.Seek(this._DataOffset, SeekOrigin.Begin);
this._Data = new byte[this.Size];
var inflater = new InflaterInputStream(input);
if (inflater.Read(this._Data, 0, this._Data.Length) != this._Data.Length)
{
throw new InvalidOperationException();
}
this._IsLoaded = true;
return(true);
}
private static byte[] ZlibDecompress(Stream data, int expectedLength)
{
// This assumes that Zlib won't be used in combination with another compression type
byte[] Output = new byte[expectedLength];
Stream s = new InflaterInputStream(data);
int Offset = 0;
while (expectedLength > 0)
{
int size = s.Read(Output, Offset, expectedLength);
if (size == 0)
{
break;
}
Offset += size;
expectedLength -= size;
}
return(Output);
}
private static byte[] unpackStageFour(byte[] pkaBuffer3)
{
byte[] xmlResult = new byte[(pkaBuffer3[0] * 0x1000000) + (pkaBuffer3[1] * 0x10000) + (pkaBuffer3[2] * 0x100) + (pkaBuffer3[3] * 0x1)]; // first 4 bytes are size
var zlibdata = pkaBuffer3.ToList();
zlibdata.RemoveRange(0, 4);
InflaterInputStream inflate = new InflaterInputStream(new MemoryStream(zlibdata.ToArray()));
inflate.Read(xmlResult, 0, xmlResult.Length);
#if DEBUG
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(Encoding.UTF8.GetString(xmlResult.ToList().GetRange(0, 420).ToArray()));
Console.ForegroundColor = ConsoleColor.Gray;
#endif
return(xmlResult);
}
protected override string DoDownloadSubtitle(string fileName, SubtitleInfo si)
{
OPMedia.Runtime.ProTONE.NuSoap.SubtitleDownload sd = new OPMedia.Runtime.ProTONE.NuSoap.SubtitleDownload();
int x = 0;
int.TryParse(si.IDSubtitleFile, out x);
sd.cod_subtitle_file = x;
sd.movie_hash = si.MovieHash;
string destPath = Path.ChangeExtension(fileName, si.SubFormat);
SubtitleArchive[] archives = _wsdl.downloadSubtitles(new OPMedia.Runtime.ProTONE.NuSoap.SubtitleDownload[] { sd });
if (archives != null && archives.Length > 0)
{
byte[] decodedBytes = Convert.FromBase64String(archives[0].data);
using (MemoryStream compressedSubtitle = new MemoryStream(decodedBytes))
{
using (InflaterInputStream str = new InflaterInputStream(compressedSubtitle))
{
using (FileStream outputSubtitle = new FileStream(destPath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
byte[] buffer = new byte[65536];
int read = 0;
do
{
read = str.Read(buffer, 0, buffer.Length);
if (read > 0)
{
outputSubtitle.Write(buffer, 0, read);
}
}while (read > 0);
}
}
}
return(destPath);
}
return(string.Empty);
}
public static byte[] DeCompress(byte[] data)
{
MemoryStream memory = new MemoryStream();
byte[] writeData = new byte[4096];
using (InflaterInputStream stream = new InflaterInputStream(new MemoryStream(data)))
{
while (true)
{
int size = stream.Read(writeData, 0, writeData.Length);
if (size <= 0)
{
break;
}
memory.Write(writeData, 0, size);
}
}
return(memory.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="dataOffset"></param>
/// <param name="fileDataOffset"></param>
/// <param name="bytes"></param>
/// <returns></returns>
public byte[] ReadFileDataZipped(long dataOffset, long fileDataOffset, long bytes)
{
InflaterInputStream zipped = null;
try
{
byte [] compressed = ReadFileData(dataOffset, fileDataOffset, bytes);
MemoryStream ms = new MemoryStream(compressed, 0, compressed.Length);
ms.Seek(0, SeekOrigin.Begin);
zipped = new InflaterInputStream(ms);
if (bytes <= int.MaxValue)
{
byte[] byteArr = new byte[bytes];
int size = 0;
int offset = 0;
try
{
do
{
size = zipped.Read(byteArr, offset, byteArr.Length);
offset += size;
} while (size > 0);
}
catch (RelicTools.Exceptions.Exception ex)
{
throw new FileNotZippedException(ex);
}
return(byteArr);
}
else
{
throw new RelicTools.Exceptions.Exception("File larger than 2GB!");
}
}
finally
{
zipped.Close();
}
}
/// <summary>
/// 解压
/// </summary>
/// <param name="inputdata"></param>
/// <param name="ds"></param>
/// <param name="error"></param>
/// <returns></returns>
public static bool Decompress(string inputdata, ref DataSet ds, ref string error)
{
try
{
//inputdata = inputdata.Replace("-", "+").Replace("_", "/").Replace(".", "=");
byte[] bb = Convert.FromBase64String(inputdata);
MemoryStream data = new MemoryStream(bb);
//int s1 = (int)data.Length;
using (MemoryStream m = new MemoryStream())
{
using (InflaterInputStream mem = new InflaterInputStream(data))
{
byte[] buffer = new byte[4096];
while (true)
{
int size = mem.Read(buffer, 0, buffer.Length);
m.Write(buffer, 0, size);
if (size == 0)
{
break;
}
}
mem.Close();
mem.Dispose();
}
m.Seek(0, SeekOrigin.Begin);
BinaryFormatter bf = new BinaryFormatter();
ds = bf.Deserialize(m) as DataSet;
m.Close();
m.Dispose();
}
return(true);
}
catch (Exception ex)
{
error = ex.Message;
return(false);
}
}
public static MemoryStream UnZip(byte[] data)
{
InflaterInputStream zipStream = new InflaterInputStream(new MemoryStream(data));
byte[] buffer = new byte[data.Length];
MemoryStream upZipStream = new MemoryStream();
while (true)
{
int num = zipStream.Read(buffer, 0, buffer.Length);
if (num <= 0)
{
break;
}
upZipStream.Write(buffer, 0, num);
}
upZipStream.Flush();
upZipStream.Seek(0, SeekOrigin.Begin);
return(upZipStream);
}
public static void Decompress(Stream output, byte[] input)
{
using var stream = new MemoryStream(input);
using var inflater = new InflaterInputStream(stream);
stream.Position = 0;
int count = 0;
long start = output.Position;
byte[] buffer = new byte[2048];
while ((count = inflater.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, count);
}
output.Flush();
output.Position = start;
}
protected void addDecompressedProgramChecksum(FileStream pFileStream, ref Crc32 pChecksum)
{
if (this.compressedProgramLength > 0)
{
InflaterInputStream inflater;
int read;
byte[] data = new byte[READ_CHUNK_SIZE];
pFileStream.Seek((long)(RESERVED_SECTION_OFFSET + this.reservedSectionLength), SeekOrigin.Begin);
inflater = new InflaterInputStream(pFileStream);
while ((read = inflater.Read(data, 0, READ_CHUNK_SIZE)) > 0)
{
pChecksum.Update(data, 0, read);
}
inflater.Close();
inflater.Dispose();
}
}
public static byte[] Decompress(byte[] data)
{
using var stream = new MemoryStream(data);
using var inflater = new InflaterInputStream(stream);
var result = new List <byte>();
var buffer = new byte[512];
while (true)
{
var bytes = inflater.Read(buffer);
result.AddRange(buffer.Take(bytes));
if (bytes < buffer.Length)
{
break;
}
}
return(result.ToArray());
}
public static MemoryStream ProcessData(byte[] data)
{
if (data == null)
{
return(null);
}
MemoryStream baseInputStream = null;
MemoryStream stream2;
InflaterInputStream stream3 = null;
try
{
baseInputStream = new MemoryStream(data);
stream2 = new MemoryStream();
stream3 = new InflaterInputStream(baseInputStream);
byte[] buffer = new byte[data.Length];
while (true)
{
int count = stream3.Read(buffer, 0, buffer.Length);
if (count <= 0)
{
break;
}
stream2.Write(buffer, 0, count);
}
stream2.Flush();
stream2.Seek(0L, SeekOrigin.Begin);
}
finally
{
if (baseInputStream != null)
{
baseInputStream.Close();
}
if (stream3 != null)
{
stream3.Close();
}
}
return(stream2);
}
/// <summary>
/// Decompresses data with format 'Deflate'. 对应 php.gzuncompress
/// 调用该函数记得加try...catch...
/// </summary>
public static byte[] DecompressDeflate(byte[] data)
{
MemoryStream outputStream = new MemoryStream();
MemoryStream inputStream = new MemoryStream(data);
using (InflaterInputStream decompressZipStream = new InflaterInputStream(inputStream))
{
int count;
byte[] buffer = new byte[128];
while ((count = decompressZipStream.Read(buffer, 0, buffer.Length)) > 0)
{
outputStream.Write(buffer, 0, count);
}
}
byte[] output = outputStream.ToArray();
outputStream.Close();
return(output);
}
private byte[] DecompressData(byte[] data)
{
using (var input = new MemoryStream(data))
using (var stream = new InflaterInputStream(input))
{
byte[] buffer = new byte[4096];
using (var output = new MemoryStream())
{
int bytesRead = 0;
do
{
bytesRead = stream.Read(buffer, 0, 4096);
if (bytesRead > 0)
{
output.Write(buffer, 0, bytesRead);
}
}while (bytesRead > 0);
return(output.ToArray());
}
}
}
private string Decompress(byte[] data)
{
string result = null;
using (var memory = new MemoryStream())
{
using (var zlib = new InflaterInputStream(new MemoryStream(data)))
{
var buffer = new byte[0x1000];
var count = 0;
while ((count = zlib.Read(buffer, 0, 0x1000)) > 0)
{
memory.Write(buffer, 0, count);
}
zlib.Close();
}
result = Encoding.UTF8.GetString(memory.ToArray());
memory.Close();
}
return(result);
}
/// <summary>
/// SharpZip½âѹËõ
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static byte[] DecompressSharpZip(byte[] buffer)
{
if (buffer == null || buffer.Length == 0)
{
return(buffer);
}
using (MemoryStream inStream = new MemoryStream(buffer))
{
InflaterInputStream unCompressStream = new InflaterInputStream(inStream);
MemoryStream outStream = new MemoryStream();
int mSize;
Byte[] mWriteData = new Byte[4096];
while ((mSize = unCompressStream.Read(mWriteData, 0, mWriteData.Length)) > 0)
{
outStream.Write(mWriteData, 0, mSize);
}
unCompressStream.Close();
return(outStream.ToArray());
}
}
public static void DecompressData(byte[] inData, out byte[] outData, int tgt_size)
{
ICSharpCode.SharpZipLib.Zip.Compression.Inflater infl =
new ICSharpCode.SharpZipLib.Zip.Compression.Inflater(false);
var inStream = new InflaterInputStream(new MemoryStream(inData), infl);
outData = new byte[tgt_size];
try
{
int numRead = inStream.Read(outData, 0, tgt_size);
if (numRead != tgt_size)
{
throw new Exception();
}
}
catch (Exception ex)
{
Console.WriteLine("Unexpected exception - '{0}'", ex.Message);
throw;
}
}
public void EncodeDecode(CompressionLevel compression)
{
const int count = 2 * 4096 * 4;
var expected = GetBuffer(count);
var reference = new byte[count];
var actual = new byte[count];
using (var compressed = new MemoryStream())
{
using (var deflate = new ZlibOutputStream(compressed, compression))
{
deflate.Write(expected);
}
compressed.Position = 0;
using (var refInflate = new InflaterInputStream(compressed))
{
refInflate.IsStreamOwner = false;
refInflate.Read(reference);
}
compressed.Position = 0;
using (var inflate = new ZlibInputStream(compressed))
{
inflate.Read(actual);
}
}
for (int i = 0; i < expected.Length; i++)
{
byte e = expected[i];
byte r = reference[i];
byte a = actual[i];
Assert.Equal(e, r);
Assert.Equal(e, a);
}
}
public void Export(string path)
{
try
{
var fi = new FileInfo(path + @"\" + this.ID.ToString() + " " + this.FileName);
FileStream fs = fi.Open(FileMode.Create, FileAccess.Write);
var ms = new MemoryStream(this.ZipSize);
var inf = new Inflater();
var s = new InflaterInputStream(ms, inf, this.ZipSize);
// put the compressed file contents into a memory stream
ms.Write(this.FileContents, 0, this.ZipSize);
ms.Position = 0;
// decompress the stream into the file stream
// using a 4KB buffer
int bytes = 4096;
var buffer = new Byte[bytes];
while (true)
{
bytes = s.Read(buffer, 0, buffer.Length);
if (bytes > 0)
{
fs.Write(buffer, 0, bytes);
}
else
{
break;
}
}
// close all streams
ms.Close();
s.Close();
fs.Close();
LogMessageToFile(@"Exported " + fi);
}
catch (Exception e)
{
LogMessageToFile(@"Unable to export document " + this.FileName + @"ERROR: " + e.Message);
}
}
void ReadRecord(Record record, bool compressed)
{
//Log($"Recd: {record.Header.Type}");
if (!compressed)
{
record.Read(_r, FilePath, Format);
return;
}
var newDataSize = _r.ReadUInt32();
var data = _r.ReadBytes((int)record.Header.DataSize - 4);
var newData = new byte[newDataSize];
using (var s = new MemoryStream(data))
using (var gs = new InflaterInputStream(s))
gs.Read(newData, 0, newData.Length);
// read record
record.Header.Position = 0;
record.Header.DataSize = newDataSize;
using (var s = new MemoryStream(newData))
using (var r = new BinaryFileReader(s))
record.Read(r, FilePath, Format);
}
private static byte[] Inflate(MemoryStream ms, int length)
{
ms.Seek(0L, 0);
Inflater inflater = new Inflater(false);
InflaterInputStream inflaterInputStream = new InflaterInputStream(ms, inflater);
byte[] array = new byte[length];
int num = 0;
int num2 = array.Length;
try
{
while (true)
{
int num3 = inflaterInputStream.Read(array, num, num2);
if (num3 <= 0)
{
break;
}
num += num3;
num2 -= num3;
}
}
catch (Exception ex)
{
LocalStorageAPI.s_log.LogWarning("EXCEPTION (Inflate): {0}", new object[]
{
ex.get_Message()
});
byte[] result = null;
return(result);
}
if (num != length)
{
LocalStorageAPI.s_log.LogWarning("Decompressed size does not equal expected size.");
return(null);
}
return(array);
}
public static GenericReader Decompress(GenericReader gr)
{
int uncompressedLength = gr.ReadInt32();
byte[] input = gr.ReadBytes((int)gr.Remaining);
byte[] output = new byte[uncompressedLength];
gr.Close();
InflaterInputStream istream = new InflaterInputStream(new MemoryStream(input));
int offset = 0;
while (true)
{
int size = istream.Read(output, offset, uncompressedLength);
if (size == uncompressedLength)
{
break;
}
offset += size;
uncompressedLength -= size;
}
return(new GenericReader(new MemoryStream(output)));
}
/// <summary>
/// Inflater解压
/// </summary>
/// <param name="baseBytes"></param>
/// <returns></returns>
public static byte[] Decompress(byte[] baseBytes)
{
try
{
#if (DEBUG)
if (baseBytes != null && baseBytes.Length > 0)
{
string resultStr = string.Empty;
using (MemoryStream memoryStream = new MemoryStream(baseBytes))
{
using (InflaterInputStream inf = new InflaterInputStream(memoryStream))
{
using (MemoryStream buffer = new MemoryStream())
{
byte[] result = new byte[1024];
int resLen;
while ((resLen = inf.Read(result, 0, result.Length)) > 0)
{
buffer.Write(result, 0, resLen);
}
//resultStr = Encoding.UTF8.GetString(result);
byte[] bytes = buffer.ToArray();
//resultStr = Encoding.UTF8.GetString(bytes);
return(bytes);
}
}
}
}
else
{
return(new byte[0]);
}
#endif
}
catch (Exception e)
{
return(new byte[0]);
}
}
public static byte[] DeCompress(byte[] pBytes)
{
MemoryStream mMemory = new MemoryStream();
using (InflaterInputStream mStream = new InflaterInputStream(new MemoryStream(pBytes)))
{
Int32 mSize;
byte[] mWriteData = new byte[4096];
while (true)
{
mSize = mStream.Read(mWriteData, 0, mWriteData.Length);
if (mSize > 0)
{
mMemory.Write(mWriteData, 0, mSize);
}
else
{
break;
}
}
}
return(mMemory.ToArray());
}
public string Decompress(byte[] baseBytes)
{
string resultStr = string.Empty;
using (MemoryStream memoryStream = new MemoryStream(baseBytes))
{
using (InflaterInputStream inf = new InflaterInputStream(memoryStream))
{
using (MemoryStream buffer = new MemoryStream())
{
byte[] result = new byte[1024];
int resLen;
while ((resLen = inf.Read(result, 0, result.Length)) > 0)
{
buffer.Write(result, 0, resLen);
}
resultStr = Encoding.Default.GetString(result);
}
}
}
return(resultStr);
}
private static byte[] ZlibDecompress(Stream Data, int ExpectedLength)
{
// This assumes that Zlib won't be used in combination with another compression type
var Output = new byte[ExpectedLength];
var s = new InflaterInputStream(Data);
var Offset = 0;
while (true)
{
if (ExpectedLength == 0)
{
break;
}
var size = s.Read(Output, Offset, ExpectedLength);
if (size == 0)
{
break;
}
Offset += size;
ExpectedLength -= size;
}
return(Output);
}
public static byte[] DeCompress(byte [] b)
{
Stream s2 = new InflaterInputStream(new MemoryStream(b));
try
{
byte [] dest = null;
int size = s2.Read(writeData, 0, writeData.Length);
if (size > 0)
{
dest = new byte[size];
Buffer.BlockCopy(writeData, 0, dest, 0, size);
}
s2.Flush();
s2.Close();
return(dest);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
}
/// <summary>
/// Decompresses the provided data, returning the inflated result.
/// </summary>
/// <param name="data">the deflated picture data.</param>
/// <returns>the inflated picture data.</returns>
private static byte[] InflatePictureData(byte[] data)
{
using (MemoryStream out1 = new MemoryStream()) {
try {
using (MemoryStream ms = new MemoryStream(data)) {
Inflater inflater = new Inflater(false);
using (InflaterInputStream in1 = new InflaterInputStream(ms, inflater)) {
byte[] buf = new byte[4096];
int ReadBytes;
while ((ReadBytes = in1.Read(buf, 0, buf.Length)) > 0)
{
out1.Write(buf, 0, ReadBytes);
}
return(out1.ToArray());
}
}
}
catch (IOException e) {
log.Log(POILogger.INFO, "Possibly corrupt compression or non-compressed data", e);
return(data);
}
}
}
public List<String> TD_Request_NonAsyncChart_Snapshot(string _streamStockSymbol, string chartSource, int nDays)
{
List<String> cSortedLines = new List<string>();
try
{
string _streamerCommand = "S=" + chartSource.ToUpper() + "&C=GET&P=" + _streamStockSymbol.ToUpper() + ",0,610," + nDays.ToString() + "d,1m";
if (this.TD_loginStatus == true)
{
XMLHTTP xmlHttp_ = new XMLHTTP();
StringBuilder cpostdata = new StringBuilder();
string lcPostUrl = string.Empty;
cpostdata.Append("!U=" + _accountid);
cpostdata.Append("&W=" + _token);
cpostdata.Append("&A=userid=" + _accountid);
cpostdata.Append("&token=" + _token);
cpostdata.Append("&company=" + _company);
cpostdata.Append("&segment=" + _segment);
cpostdata.Append("&cddomain=" + _cdDomain);
cpostdata.Append("&usergroup=" + _usergroup);
cpostdata.Append("&accesslevel=" + _accesslevel);
cpostdata.Append("&authorized=" + _authorized);
cpostdata.Append("&acl=" + _acl);
cpostdata.Append("×tamp=" + _timestamp);
cpostdata.Append("&appid=" + _appid);
cpostdata.Append("|" + _streamerCommand);
string encodedString = Encode_URL(cpostdata.ToString());
cpostdata = new StringBuilder();
cpostdata.Append(encodedString);
lcPostUrl = "http://" + this._streamerurl + "/" + cpostdata;
/*/
* Read the response and decompress the chart data
*
/*/
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(lcPostUrl);
req.ContentType = "application/x-www-form-urlencoded";
req.Accept = "Accept image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-powerpoint, application/vnd.ms-excel, application/msword, application/x-shockwave-flash, */*";
req.Method = "GET";
req.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
req.Timeout = 60000;
req.ServicePoint.ConnectionLimit = 50;
//req.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
Stream respStream = resp.GetResponseStream();
byte[] chunk = new byte[65535 * 10];
byte[] ChartByteArray = new byte[65535 * 10];
int bytesRead = respStream.Read(ChartByteArray, 0, ChartByteArray.Length);
string compressedText = Convert.ToBase64String(ChartByteArray);
byte[] gzBuffer = Convert.FromBase64String(compressedText);
respStream.Flush();
resp.Close();
respStream.Close();
MemoryStream ms = new MemoryStream();
int nFieldNDX = 0;
int nStartPos = 21;
int msgLength = BitConverter.ToInt32(gzBuffer, 0);
ms.Write(gzBuffer, 64, gzBuffer.Length - 64);
byte[] nMsg = new byte[sizeof(Int32)];
/*/
* S = Streaming
* N = Snapshot
/*/
nMsg[0] = gzBuffer[nFieldNDX++];
string cRequestType = System.Text.Encoding.ASCII.GetString(nMsg, 0, 1);
// Skip these next 4 bytes
nFieldNDX = nFieldNDX + 4;
// Get message length
nMsg = new byte[sizeof(Int32)];
nMsg[0] = gzBuffer[nFieldNDX++];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[2] = gzBuffer[nFieldNDX++];
nMsg[3] = gzBuffer[nFieldNDX++];
Array.Reverse(nMsg);
string nTotalMessageLength = TD_GetResponseValue(100, nMsg, nStartPos, 0);
/*/
* 52 / 82 - NASDAQ Chart
* 53 / 83 - NYSE Chart
* 55 / 85 - Indices Chart
/*/
nMsg = new byte[sizeof(short)];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[0] = gzBuffer[nFieldNDX++];
int nSID = BitConverter.ToInt16(nMsg, 0);
string cStreamingRequestChart = string.Empty;
switch (nSID)
{
case 82:
cStreamingRequestChart = " NASDAQ Chart";
break;
case 83:
cStreamingRequestChart = " NYSE Chart";
break;
case 85:
cStreamingRequestChart = " Indices Chart";
break;
}
// Get stock symbol length
nMsg = new byte[sizeof(short)];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[0] = gzBuffer[nFieldNDX++];
int nSymbolLength = BitConverter.ToInt16(nMsg, 0);
// Get stock symbol
nStartPos = nFieldNDX;
nMsg = new byte[nSymbolLength];
Array.Copy(gzBuffer, nStartPos, nMsg, 0, nSymbolLength);
string cSymbol = TD_GetResponseValue(0, nMsg, 0, nSymbolLength);
nFieldNDX = nFieldNDX + nSymbolLength;
// Get status
nMsg = new byte[sizeof(short)];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[0] = gzBuffer[nFieldNDX++];
int nStatus = BitConverter.ToInt16(nMsg, 0);
// Get length of compressed data
nMsg = new byte[sizeof(Int32)];
nMsg[0] = gzBuffer[nFieldNDX++];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[2] = gzBuffer[nFieldNDX++];
nMsg[3] = gzBuffer[nFieldNDX++];
Array.Reverse(nMsg);
string nTotalLenOfCompressedData = TD_GetResponseValue(100, nMsg, nStartPos, 0);
ms.Close();
byte[] CompressedData = new byte[Convert.ToInt32(nTotalLenOfCompressedData)];
Array.Copy(gzBuffer, nFieldNDX, CompressedData, 0, Convert.ToInt32(nTotalLenOfCompressedData));
StringBuilder cTempData = new StringBuilder();
int totalLength = 0;
byte[] writeData = new byte[65535 * 10];
Stream s2 = new InflaterInputStream(new MemoryStream(CompressedData));
try
{
while (true)
{
int size = s2.Read(writeData, 0, writeData.Length);
if (size > 0)
{
totalLength += size;
cTempData.Append(System.Text.Encoding.ASCII.GetString(writeData, 0, size));
}
else
{
break;
}
}
s2.Close();
string[] cLines = cTempData.ToString().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string cs in cLines)
{
cSortedLines.Add(cs);
}
}
catch (Exception) { s2.Close(); return cSortedLines; }
}
GC.Collect();
}
catch (Exception) { }
return cSortedLines;
}
public void process_AsyncChartSnapshot(IAsyncResult asyncResult)
{
try
{
// Get the RequestState object from the asyncresult
RequestState rs = (RequestState)asyncResult.AsyncState;
if (rs.lNewStockSymbol == true)
{
rs.CloseStream(rs);
return;
}
if (rs.Request.ServicePoint.CurrentConnections > 0)
{
List<String> cSortedLines = new List<string>();
// Pull out the ResponseStream that was set in RespCallback
Stream responseStream = rs.ResponseStream;
// At this point rs.BufferRead should have some data in it.
// Read will tell us if there is any data there
int read = responseStream.EndRead(asyncResult);
if (read > 0)
{
// Make sure we store all the incoming data until we reach the end.
Array.Copy(rs.BufferRead, 0, ChartByteArray2, ChartByteArray2NDx, read);
ChartByteArray2NDx = ChartByteArray2NDx + read;
// Make another call so that we continue retrieving any all incoming data
IAsyncResult ar = responseStream.BeginRead(rs.BufferRead, 0, BUFFER_SIZE, new AsyncCallback(ReadCallBack), rs);
}
else
{
ChartByteArray2NDx = 0;
// If we have not more bytes read, then the server has finished sending us data.
if (read == 0)
{
string compressedText = Convert.ToBase64String(ChartByteArray2);
byte[] gzBuffer = Convert.FromBase64String(compressedText);
MemoryStream ms = new MemoryStream();
int nFieldNDX = 0;
int nStartPos = 21;
int msgLength = BitConverter.ToInt32(gzBuffer, 0);
ms.Write(gzBuffer, 64, gzBuffer.Length - 64);
byte[] nMsg = new byte[sizeof(Int32)];
/*/
* S = Streaming
* N = Snapshot
/*/
nMsg[0] = gzBuffer[nFieldNDX++];
string cRequestType = System.Text.Encoding.ASCII.GetString(nMsg, 0, 1);
// Skip these next 4 bytes
nFieldNDX = nFieldNDX + 4;
// Get message length
nMsg = new byte[sizeof(Int32)];
nMsg[0] = gzBuffer[nFieldNDX++];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[2] = gzBuffer[nFieldNDX++];
nMsg[3] = gzBuffer[nFieldNDX++];
Array.Reverse(nMsg);
string nTotalMessageLength = TD_GetResponseValue(100, nMsg, nStartPos, 0);
/*/
* 52 / 82 - NASDAQ Chart
* 53 / 83 - NYSE Chart
* 55 / 85 - Indices Chart
/*/
nMsg = new byte[sizeof(short)];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[0] = gzBuffer[nFieldNDX++];
int nSID = BitConverter.ToInt16(nMsg, 0);
string cStreamingRequestChart = string.Empty;
switch (nSID)
{
case 82:
cStreamingRequestChart = " NASDAQ Chart";
break;
case 83:
cStreamingRequestChart = " NYSE Chart";
break;
case 85:
cStreamingRequestChart = " Indices Chart";
break;
}
// Get stock symbol length
nMsg = new byte[sizeof(short)];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[0] = gzBuffer[nFieldNDX++];
int nSymbolLength = BitConverter.ToInt16(nMsg, 0);
// Get stock symbol
nStartPos = nFieldNDX;
nMsg = new byte[nSymbolLength];
Array.Copy(gzBuffer, nStartPos, nMsg, 0, nSymbolLength);
string cSymbol = TD_GetResponseValue(0, nMsg, 0, nSymbolLength);
nFieldNDX = nFieldNDX + nSymbolLength;
// Get status
nMsg = new byte[sizeof(short)];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[0] = gzBuffer[nFieldNDX++];
int nStatus = BitConverter.ToInt16(nMsg, 0);
// Get length of compressed data
nMsg = new byte[sizeof(Int32)];
nMsg[0] = gzBuffer[nFieldNDX++];
nMsg[1] = gzBuffer[nFieldNDX++];
nMsg[2] = gzBuffer[nFieldNDX++];
nMsg[3] = gzBuffer[nFieldNDX++];
Array.Reverse(nMsg);
string nTotalLenOfCompressedData = TD_GetResponseValue(100, nMsg, nStartPos, 0);
ms.Close();
byte[] CompressedData = new byte[Convert.ToInt32(nTotalLenOfCompressedData)];
Array.Copy(gzBuffer, nFieldNDX, CompressedData, 0, Convert.ToInt32(nTotalLenOfCompressedData));
StringBuilder cTempData = new StringBuilder();
int totalLength = 0;
byte[] writeData = new byte[BUFFER_SIZE];
Stream s2 = new InflaterInputStream(new MemoryStream(CompressedData));
try
{
while (true)
{
int size = s2.Read(writeData, 0, writeData.Length);
if (size > 0)
{
totalLength += size;
cTempData.Append(System.Text.Encoding.ASCII.GetString(writeData, 0, size));
}
else
{
break;
}
}
s2.Close();
string[] cLines = cTempData.ToString().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string cs in cLines)
{
cSortedLines.Add(cs);
}
rs.SendHistoricalChartData(cSortedLines, rs.stockSymbol, rs.ServiceName);
}
catch (Exception)
{
s2.Close();
}
}
}
}
}
catch (Exception exc) { }
}