public static void StartWatcher(WatcherType watcherType, string fileName, IStreamReader streamReader, ISleeper sleeper)
{
var watcher = CreateWatcherInternal(watcherType, streamReader, sleeper);
watcher.Configuration = GetDefaultFileWatcherConfiguration(fileName);
AddWatcherToPool(watcher);
watcher.Start();
}
public static bool IsSharedStream(IStreamReader reader)
{
if (SUPPORT_SHARED_STREAMS)
return c_sharedStreams.ContainsKey(reader.Path);
else
return false;
}
public static void StartWatcher(WatcherType watcherType, FileWatchConfiguration fileWatchConfiguration,
IStreamReader streamReader, ISleeper sleeper)
{
var watcher = CreateWatcherInternal(watcherType, streamReader, sleeper);
watcher.Configuration = fileWatchConfiguration;
AddWatcherToPool(watcher);
watcher.Start();
}
private static IWatcher CreateWatcherInternal(WatcherType watcherType, IStreamReader streamReader, ISleeper sleeper)
{
switch (watcherType)
{
case WatcherType.File:
return new FileWatcher(streamReader, sleeper);
default:
throw new NotImplementedException($"Factory method for {watcherType} not implemented");
}
}
public async Task<IHttpRequest> Provide(IStreamReader reader)
{
// parse the http request
var request = await reader.ReadLine().ConfigureAwait(false);
if (request == null)
return null;
var firstSpace = request.IndexOf(' ');
var lastSpace = request.LastIndexOf(' ');
var tokens = new []
{
request.Substring(0, firstSpace),
request.Substring(firstSpace + 1, lastSpace - firstSpace - 1),
request.Substring(lastSpace + 1)
};
if (tokens.Length != 3)
{
return null;
}
var httpProtocol = tokens[2];
var url = tokens[1];
var queryString = GetQueryStringData(ref url);
var uri = new Uri(url, UriKind.Relative);
var headersRaw = new List<KeyValuePair<string, string>>();
// get the headers
string line;
while (!string.IsNullOrEmpty((line = await reader.ReadLine().ConfigureAwait(false))))
{
string currentLine = line;
var headerKvp = SplitHeader(currentLine);
headersRaw.Add(headerKvp);
}
IHttpHeaders headers = new HttpHeaders(headersRaw.ToDictionary(k => k.Key, k => k.Value, StringComparer.InvariantCultureIgnoreCase));
IHttpPost post = await GetPostData(reader, headers).ConfigureAwait(false);
string verb;
if (!headers.TryGetByName("_method", out verb))
{
verb = tokens[0];
}
var httpMethod = HttpMethodProvider.Default.Provide(verb);
return new HttpRequest(headers, httpMethod, httpProtocol, uri,
uri.OriginalString.Split(Separators, StringSplitOptions.RemoveEmptyEntries), queryString, post);
}
public static void WriteRecordToStream(StreamWriter writer, IStreamReader reader, Record record)
{
Int64 position = reader.Position;
reader.Position = record.Start;
while (reader.Position < record.End)
{
writer.WriteLine(reader.ReadLine());
}
reader.Position = position;
}
public PointCloudBinarySourceEnumerator(IPointCloudBinarySourceSequentialEnumerable source, ProgressManagerProcess process)
{
m_source = source;
m_stream = m_source.GetStreamReader();
m_buffer = process.AcquireBuffer(true);
m_process = process;
m_endPosition = m_source.PointDataOffset + m_source.Count * m_source.PointSizeBytes;
m_usableBytesPerBuffer = (m_buffer.Length / m_source.PointSizeBytes) * m_source.PointSizeBytes;
Reset();
}
/// <summary>
/// Initializes a new instance of the <see cref="PointCloudBinarySourceEnumerator"/> class.
/// This version does not use a process, so that it can be managed by a composite.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="buffer">The buffer.</param>
public PointCloudBinarySourceEnumerator(IPointCloudBinarySourceSequentialEnumerable source, BufferInstance buffer)
{
m_source = source;
m_stream = m_source.GetStreamReader();
m_buffer = buffer;
m_process = null;
m_endPosition = m_source.PointDataOffset + m_source.Count * m_source.PointSizeBytes;
m_usableBytesPerBuffer = (m_buffer.Length / m_source.PointSizeBytes) * m_source.PointSizeBytes;
Reset();
}
public override void SetInputSource(int index, IStreamReader stream)
{
if (index != 0)
throw new ArgumentOutOfRangeException(nameof(index));
if (stream == null)
throw new ArgumentNullException(nameof(stream));
if (mInput != null)
throw new InvalidOperationException();
mInput = stream;
}
/// <summary>
/// Initializes a new insance of the <see cref="RemoteFileSubscriptionStreamReader"/> class.
/// </summary>
/// <param name="source">The remote url to be downloaded via web client</param>
/// <param name="downloadDirectory">The local directory and destination of the download</param>
public RemoteFileSubscriptionStreamReader(string source, string downloadDirectory)
{
// create a hash for a new filename
var filename = source.ToMD5() + source.GetExtension();
var destination = Path.Combine(downloadDirectory, filename);
using (var client = new WebClient())
{
client.Proxy = WebRequest.GetSystemWebProxy();
client.DownloadFile(source, destination);
}
// now we can just use the local file reader
_streamReader = new LocalFileSubscriptionStreamReader(destination);
}
public async Task<IHttpRequest> Provide(IStreamReader streamReader)
{
var childValue = await _child.Provide(streamReader).ConfigureAwait(false);
if (childValue == null)
{
return null;
}
string methodName;
if (!childValue.Headers.TryGetByName("X-HTTP-Method-Override", out methodName))
{
return childValue;
}
return new HttpRequestMethodDecorator(childValue, HttpMethodProvider.Default.Provide(methodName));
}
public void WriteMatchedRecord(IStreamReader reader, Record record)
{
reader.VerifyThatObjectIsNotNull("Cannot write matched record. Parameter 'reader' is null.");
record.VerifyThatObjectIsNotNull("Cannot write matched record. Parameter 'record' is null.");
if (!this.DoWriteMatchedRecords)
{
throw new InvalidOperationException("Writer not set to write out matched record.");
}
if (this.matchedWriter == null)
{
this.matchedWriter = new StreamWriter(this.matchedFilePath);
}
this.statisticsCollector.RecordWrittenToOutputFile(this.matchedFilePath);
StreamWriteOperations.WriteRecordToStream(this.matchedWriter, reader, record);
}
public Record ReadRecord(IStreamReader reader)
{
Record record = null;
var lineIDStart = (Int32)this.descriptor.LineIDStart;
var lineIDLength = (Int32)this.descriptor.LineIDLength;
var termStart = (Int32)this.descriptor.Term.Start;
var termLength = (Int32)this.descriptor.Term.Length;
while (!reader.EndOfStream)
{
Int64 position = reader.Position;
var line = reader.ReadLine();
var lineID = line.Substring(lineIDStart, lineIDLength);
if (lineID == descriptor.HeaderID)
{
if (record == null)
{
record = new Record { Start = position };
}
else
{
record.End = position;
reader.Position = position;
return record;
}
}
if (lineID == descriptor.Term.LineID)
{
record.Term = line.Substring(termStart, termLength);
}
}
if (record != null)
{
record.End = reader.Position;
}
return record;
}
private void WriteRecordsToFile(IStreamReader reader, Record record, String outputPrefix)
{
reader.VerifyThatObjectIsNotNull("Cannot write record. Parameter 'reader' is null.");
record.VerifyThatObjectIsNotNull("Cannot write record. Parameter 'record' is null.");
StreamWriter writer;
String outputName = Path.GetDirectoryName(reader.Name) + @"\" + outputPrefix + Path.GetFileName(reader.Name);
if (!writers.ContainsKey(outputName))
{
writer = new StreamWriter(outputName);
writers.Add(outputName, writer);
}
else
{
writer = writers[outputName];
}
this.statisticsCollector.RecordWrittenToOutputFile(outputName);
StreamWriteOperations.WriteRecordToStream(writer, reader, record);
}
public Task EncodeAsync(IStreamReader input, IStreamWriter output, CancellationToken ct = default(CancellationToken))
{
lock (mSyncObject)
{
if (mDisposeTask != null)
throw new OperationCanceledException();
// TODO: make this wait async as well
while (mRunning)
{
Monitor.Wait(mSyncObject);
if (mDisposeTask != null)
throw new OperationCanceledException();
}
mRunning = true;
}
var task = Task.Run(async delegate {
var result = mEncoder.Lzma2Enc_Encode(new AsyncOutputProvider(output), new AsyncInputProvider(input), null);
if (result != LZMA.Master.LZMA.SZ_OK)
throw new InvalidOperationException();
await output.CompleteAsync().ConfigureAwait(false);
});
mEncoderTask = task.ContinueWith(delegate {
lock (mSyncObject)
{
System.Diagnostics.Debug.Assert(mRunning);
mRunning = false;
Monitor.PulseAll(mSyncObject);
}
}, CancellationToken.None, TaskContinuationOptions.DenyChildAttach, TaskScheduler.Default);
return task;
}
public Record ReadRecord(IStreamReader streamReader)
{
Record record = null;
while (!streamReader.EndOfStream)
{
Int64 position = streamReader.Position;
var line = streamReader.ReadLine();
var lineIDTerm = line.ExtractField(this.descriptor.Delimiter, this.descriptor.Qualifier, this.descriptor.LineIDIndex);
if (lineIDTerm == this.descriptor.HeaderID)
{
if (record == null)
{
record = new Record { Start = position };
}
else
{
record.End = position;
streamReader.Position = position;
return record;
}
}
if (lineIDTerm != this.descriptor.Term.LineID)
{
continue;
}
record.Term = line.ExtractField(this.descriptor.Delimiter, this.descriptor.Qualifier, this.descriptor.Term.Index);
}
if (record != null)
{
record.End = streamReader.Position;
}
return record;
}
/// <summary>
/// Fetch and set the location of the data from the user's BaseData factory:
/// </summary>
/// <param name="date">Date of the source file.</param>
/// <returns>Boolean true on successfully retrieving the data</returns>
public bool RefreshSource(DateTime date)
{
//Update the source from the getSource method:
_date = date;
// if the map file is an empty instance this will always return true
if (!_mapFile.HasData(date))
{
// don't even bother checking the disk if the map files state we don't have ze dataz
return(false);
}
// check for dividends and split for this security
CheckForDividend(date);
CheckForSplit(date);
var newSource = "";
//If we can find scale factor files on disk, use them. LiveTrading will aways use 1 by definition
if (_hasScaleFactors)
{
// check to see if the symbol was remapped
_mappedSymbol = _mapFile.GetMappedSymbol(date);
_config.MappedSymbol = _mappedSymbol;
// update our price scaling factors in light of the normalization mode
UpdateScaleFactors(date);
}
//Make sure this particular security is trading today:
if (!_security.Exchange.DateIsOpen(date))
{
_endOfStream = true;
return(false);
}
//Choose the new source file, hide the QC source file locations
newSource = GetSource(date);
//When stream over stop looping on this data.
if (newSource == "")
{
_endOfStream = true;
return(false);
}
//Log.Debug("SubscriptionDataReader.MoveNext(): Source Refresh: " + newSource);
if (_source != newSource && newSource != "")
{
//If a new file, reset the EOS flag:
_endOfStream = false;
//Set the new source.
_source = newSource;
//Close out the last source file.
Dispose();
//Load the source:
try
{
//Log.Debug("SubscriptionDataReader.RefreshSource(): Created new reader for source: " + source);
_reader = GetReader(_source);
}
catch (Exception err)
{
Log.Error("SubscriptionDataReader.RefreshSource(): Failed to get reader: " + err.Message);
//Engine.ResultHandler.DebugMessage("Failed to get a reader for the data source. There may be an error in your custom data source reader. Skipping date (" + date.ToShortDateString() + "). Err: " + err.Message);
return(false);
}
if (_reader == null)
{
Log.Error("Failed to get StreamReader for data source(" + _source + "), symbol(" + _mappedSymbol + "). Skipping date(" + date.ToShortDateString() + "). Reader is null.");
//Engine.ResultHandler.DebugMessage("We could not find the requested data. This may be an invalid data request, failed download of custom data, or a public holiday. Skipping date (" + date.ToShortDateString() + ").");
if (_isDynamicallyLoadedData)
{
Engine.ResultHandler.ErrorMessage("We could not fetch the requested data. This may not be valid data, or a failed download of custom data. Skipping source (" + _source + ").");
}
return(false);
}
//Reset the public properties so we can explicitly set them with lastBar data.
Current = null;
Previous = null;
//99% of time, populate the first "Current". 1% of of time no source file (getReader fails), so
// method sets the Subscription properties as if no data.
try
{
MoveNext();
}
catch (Exception err)
{
throw new Exception("SubscriptionDataReader.RefreshSource(): Could not MoveNext to init stream: " + _source + " " + err.Message + " >> " + err.StackTrace);
}
}
//Success:
return(true);
}
/// <summary> /// The stream version of the first entry in every stream. /// </summary> public static int FirstStreamVersion <T>(this IStreamReader <T> streamReader) => 1;
public void SetOutputStream(EncoderNode encoder, int index)
{
mEncoderOutputToConnectionInput = encoder.GetOutputSource(index);
if (mEncoderOutputToConnectionInput == null)
encoder.SetOutputSink(index, this);
}
internal AsyncInputProvider(IStreamReader stream)
{
mStream = stream;
}
public void Close()
{
if (m_inputStream != null)
{
m_inputStream.Dispose();
m_inputStream = null;
}
}
public static async Task<IHttpPost> Create(IStreamReader reader, int postContentLength, ILog logger)
{
byte[] raw = await reader.ReadBytes(postContentLength).ConfigureAwait(false);
return new HttpPost(raw, postContentLength);
}
private void WriteNothing(IStreamReader reader, Record record)
{
}
public XmlTkEndSurface(IStreamReader reader)
{
this.endSurface = new XmlTkEnd(reader);
}
public SupBook(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.ctab = this.Reader.ReadUInt16();
this.cch = this.Reader.ReadUInt16();
this.isselfreferencing = true;
this.isaddinreferencing = false;
this.isvirtpath = false;
this.isexternalworkbookreferencing = false;
this.isunusedsupportinglink = false;
// Check cch
if (this.cch == 0x0401)
{
this.isselfreferencing = true;
}
else if (this.cch == 0x3A01)
{
this.isaddinreferencing = true;
//0x0001 to 0x00ff (inclusive)
}
else if (this.cch >= 0x0001 && this.cch <= 0x00ff)
{
this.isvirtpath = true;
}
if (this.isvirtpath)
{
this.virtpathstring = "";
byte firstbyte = this.Reader.ReadByte();
int firstbit = firstbyte & 0x1;
for (int i = 0; i < this.cch; i++)
{
if (firstbit == 0)
{
this.virtpathstring += (char)this.Reader.ReadByte();
// read 1 byte per char
}
else
{
// read two byte per char
this.virtpathstring += System.BitConverter.ToChar(this.Reader.ReadBytes(2), 0);
}
}
this.virtpathstring = ExcelHelperClass.parseVirtualPath(this.virtpathstring);
}
if (this.virtpathstring != null)
{
if (this.virtpathstring.Equals(0x00))
{
this.isselfreferencing = true;
}
else if (this.virtpathstring.Equals(0x20))
{
this.isunusedsupportinglink = true;
}
else
{
this.isexternalworkbookreferencing = true;
}
}
if ((this.isexternalworkbookreferencing) || (this.isunusedsupportinglink))
{
this.rgst = new string[this.ctab];
for (int i = 0; i < this.ctab; i++)
{
ushort cch2 = this.Reader.ReadUInt16();
byte firstbyte = this.Reader.ReadByte();
int firstbit = firstbyte & 0x1;
for (int j = 0; j < cch2; j++)
{
if (firstbit == 0)
{
this.rgst[i] += (char)this.Reader.ReadByte();
// read 1 byte per char
}
else
{
// read two byte per char
this.rgst[i] += System.BitConverter.ToChar(this.Reader.ReadBytes(2), 0);
}
}
}
}
if (this.virtpathstring != null && this.virtpathstring.Length > 1)
{
this.isselfreferencing = false;
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public CustomViewSequence(IStreamReader reader)
: base(reader)
{
// CUSTOMVIEW = UserSViewBegin *Selection [HorizontalPageBreaks] [VerticalPageBreaks] [Header]
// [Footer] [HCenter] [VCenter] [LeftMargin] [RightMargin] [TopMargin] [BottomMargin]
// [Pls] [Setup] [PrintSize] [HeaderFooter] [AUTOFILTER] UserSViewEnd
// NOTE: UserSViewBegin and UserSViewEnd seem to be optional to!
// UserSViewBegin
if (BiffRecord.GetNextRecordType(reader) == RecordType.UserSViewBegin)
{
this.UserSViewBegin = (UserSViewBegin)BiffRecord.ReadRecord(reader);
}
// *Selection
this.Selections = new List <Selection>();
while (BiffRecord.GetNextRecordType(reader) == RecordType.Selection)
{
this.Selections.Add((Selection)BiffRecord.ReadRecord(reader));
}
// [HorizontalPageBreaks]
if (BiffRecord.GetNextRecordType(reader) == RecordType.HorizontalPageBreaks)
{
this.HorizontalPageBreaks = (HorizontalPageBreaks)BiffRecord.ReadRecord(reader);
}
// [VerticalPageBreaks]
if (BiffRecord.GetNextRecordType(reader) == RecordType.VerticalPageBreaks)
{
this.VerticalPageBreaks = (VerticalPageBreaks)BiffRecord.ReadRecord(reader);
}
// [Header]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Header)
{
this.Header = (Header)BiffRecord.ReadRecord(reader);
}
// [Footer]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Footer)
{
this.Footer = (Footer)BiffRecord.ReadRecord(reader);
}
// [HCenter]
if (BiffRecord.GetNextRecordType(reader) == RecordType.HCenter)
{
this.HCenter = (HCenter)BiffRecord.ReadRecord(reader);
}
// [VCenter]
if (BiffRecord.GetNextRecordType(reader) == RecordType.VCenter)
{
this.VCenter = (VCenter)BiffRecord.ReadRecord(reader);
}
// [LeftMargin]
if (BiffRecord.GetNextRecordType(reader) == RecordType.LeftMargin)
{
this.LeftMargin = (LeftMargin)BiffRecord.ReadRecord(reader);
}
// [RightMargin]
if (BiffRecord.GetNextRecordType(reader) == RecordType.RightMargin)
{
this.RightMargin = (RightMargin)BiffRecord.ReadRecord(reader);
}
// [TopMargin]
if (BiffRecord.GetNextRecordType(reader) == RecordType.TopMargin)
{
this.TopMargin = (TopMargin)BiffRecord.ReadRecord(reader);
}
// [BottomMargin]
if (BiffRecord.GetNextRecordType(reader) == RecordType.BottomMargin)
{
this.BottomMargin = (BottomMargin)BiffRecord.ReadRecord(reader);
}
// [Pls]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Pls)
{
this.Pls = (Pls)BiffRecord.ReadRecord(reader);
}
// [Setup]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Setup)
{
this.Setup = (Setup)BiffRecord.ReadRecord(reader);
}
// [PrintSize]
if (BiffRecord.GetNextRecordType(reader) == RecordType.PrintSize)
{
this.PrintSize = (PrintSize)BiffRecord.ReadRecord(reader);
}
// [HeaderFooter]
if (BiffRecord.GetNextRecordType(reader) == RecordType.HeaderFooter)
{
this.HeaderFooter = (HeaderFooter)BiffRecord.ReadRecord(reader);
}
// [AUTOFILTER]
if (BiffRecord.GetNextRecordType(reader) == RecordType.AutoFilterInfo)
{
this.AutoFilterSequence = new AutoFilterSequence(reader);
}
// UserSViewEnd
if (BiffRecord.GetNextRecordType(reader) == RecordType.UserSViewEnd)
{
this.UserSViewEnd = (UserSViewEnd)BiffRecord.ReadRecord(reader);
}
}
public XmlTkMinFrt(IStreamReader reader)
{
this.minScale = new XmlTkDouble(reader);
}
public XmlTkMajorUnitFrt(IStreamReader reader)
{
this.majorUnit = new XmlTkDouble(reader);
}
public XmlTkPerspectiveFrt(IStreamReader reader)
{
this.perspectiveAngle = new XmlTkDWord(reader);
}
/// <summary>
/// Creates a file with the content from the given stream.
/// </summary>
/// <param name="streamReader">input stream</param>
/// <param name="filePath">the file path where the output is written to.</param>
public void CreateFileFromStream(IStreamReader streamReader, string filePath)
{
if (streamReader == null || streamReader.BaseStream == null || streamReader.BaseStream.Length <= 0)
{
return;
}
using (var fileStreamWrap = new FileStreamWrap(filePath, FileMode.Create, FileAccess.Write))
{
fileStreamWrap.CopyFromStream(streamReader.BaseStream);
}
}
public Formula(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.val = new byte[8];
this.rw = reader.ReadUInt16();
this.col = reader.ReadUInt16();
this.ixfe = reader.ReadUInt16();
this.boolValueSet = false;
long oldStreamPosition = this.Reader.BaseStream.Position;
this.val = reader.ReadBytes(8); // read 8 bytes for the value of the formular
ProcessFormulaValue();
this.grbit = reader.ReadUInt16();
this.chn = reader.ReadUInt32(); // this is used for performance reasons only
this.cce = reader.ReadUInt16();
this.ptgStack = new Stack <AbstractPtg>();
// reader.ReadBytes(this.cce);
// check always calc mode
this.fAlwaysCalc = Utils.BitmaskToBool((int)this.grbit, 0x01);
// check if shared formula
this.fShrFmla = Utils.BitmaskToBool((int)this.grbit, 0x08);
// check if this should ignore error checking
this.fClearErrors = Utils.BitmaskToBool(this.grbit, 0x20);
oldStreamPosition = this.Reader.BaseStream.Position;
if (!this.fShrFmla)
{
try
{
this.ptgStack = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
}
catch (Exception ex)
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.Reader.BaseStream.Seek(this.cce, System.IO.SeekOrigin.Current);
TraceLogger.Error("Formula parse error in Row {0} Column {1}", this.rw, this.col);
TraceLogger.Debug(ex.StackTrace);
TraceLogger.Debug("Inner exception: {0}", ex.InnerException.StackTrace);
}
}
else
{
//If the next expression isn't 5 bytes long, it's not a PtgExp shared formula reference...just ignore for now
if (this.cce != 5)
{
reader.ReadBytes(this.cce);
}
//First 8 bits are reserved, must be 1 but we'll ignore them for now
byte ptg = reader.ReadByte();
//Next two bytes are the row containing the shared formula
sharedRow = reader.ReadUInt16();
//then the col containing the shared formula
sharedCol = reader.ReadUInt16();
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public AttachedLabelSequence(IStreamReader reader)
: base(reader)
{
//ATTACHEDLABEL = Text Begin Pos [FontX] [AlRuns] AI [FRAME] [ObjectLink] [DataLabExtContents] [CrtLayout12] [TEXTPROPS] [CRTMLFRT] End
//Text
this.Text = (Text)BiffRecord.ReadRecord(reader);
//Begin
this.Begin = (Begin)BiffRecord.ReadRecord(reader);
//Pos
if (BiffRecord.GetNextRecordType(reader) == RecordType.Pos)
{
this.Pos = (Pos)BiffRecord.ReadRecord(reader);
}
//[FontX]
if (BiffRecord.GetNextRecordType(reader) == RecordType.FontX)
{
this.FontX = (FontX)BiffRecord.ReadRecord(reader);
}
//[AlRuns]
if (BiffRecord.GetNextRecordType(reader) == RecordType.AlRuns)
{
this.AlRuns = (AlRuns)BiffRecord.ReadRecord(reader);
}
//AI
if (BiffRecord.GetNextRecordType(reader) == RecordType.BRAI)
{
this.AiSequence = new AiSequence(reader);
}
//[FRAME]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Frame)
{
this.FrameSequence = new FrameSequence(reader);
}
//[ObjectLink]
if (BiffRecord.GetNextRecordType(reader) == RecordType.ObjectLink)
{
this.ObjectLink = (ObjectLink)BiffRecord.ReadRecord(reader);
}
//[DataLabExtContents]
if (BiffRecord.GetNextRecordType(reader) == RecordType.DataLabExtContents)
{
this.DataLabExtContents = (DataLabExtContents)BiffRecord.ReadRecord(reader);
}
//[CrtLayout12]
if (BiffRecord.GetNextRecordType(reader) == RecordType.CrtLayout12)
{
this.CrtLayout12 = (CrtLayout12)BiffRecord.ReadRecord(reader);
}
//[TEXTPROPS]
if (BiffRecord.GetNextRecordType(reader) == RecordType.RichTextStream ||
BiffRecord.GetNextRecordType(reader) == RecordType.TextPropsStream)
{
this.TextPropsSequence = new TextPropsSequence(reader);
}
//[CRTMLFRT]
if (BiffRecord.GetNextRecordType(reader) == RecordType.CrtMlFrt)
{
this.CrtMlfrtSequence = new CrtMlfrtSequence(reader);
}
//End
this.End = (End)BiffRecord.ReadRecord(reader);
}
public override object ReadValue(IStreamReader reader, ISerializeContext context)
{
return(NullableRead(reader, () => reader.ReadBool()));
}
public static Stack <AbstractPtg> getFormulaStack(IStreamReader reader, ushort cce)
{
var ptgStack = new Stack <AbstractPtg>();
try
{
for (uint i = 0; i < cce; i++)
{
var ptgtype = (PtgNumber)reader.ReadByte();
AbstractPtg.PtgDataType dt = AbstractPtg.PtgDataType.REFERENCE;
if ((int)ptgtype > 0x5D)
{
ptgtype -= 0x40;
dt = AbstractPtg.PtgDataType.ARRAY;
}
else if ((int)ptgtype > 0x3D)
{
ptgtype -= 0x20;
dt = AbstractPtg.PtgDataType.VALUE;
}
AbstractPtg ptg = null;
if (ptgtype == PtgNumber.Ptg0x19Sub)
{
var ptgtype2 = (Ptg0x19Sub)reader.ReadByte();
switch (ptgtype2)
{
case Ptg0x19Sub.PtgAttrSum: ptg = new PtgAttrSum(reader, ptgtype2); break;
case Ptg0x19Sub.PtgAttrIf: ptg = new PtgAttrIf(reader, ptgtype2); break;
case Ptg0x19Sub.PtgAttrGoto: ptg = new PtgAttrGoto(reader, ptgtype2); break;
case Ptg0x19Sub.PtgAttrSemi: ptg = new PtgAttrSemi(reader, ptgtype2); break;
case Ptg0x19Sub.PtgAttrChoose: ptg = new PtgAttrChoose(reader, ptgtype2); break;
case Ptg0x19Sub.PtgAttrSpace: ptg = new PtgAttrSpace(reader, ptgtype2); break;
case Ptg0x19Sub.PtgAttrBaxcel1: ptg = new PtgAttrBaxcel(reader, ptgtype2, false); break;
case Ptg0x19Sub.PtgAttrBaxcel2: ptg = new PtgAttrBaxcel(reader, ptgtype2, true); break;
case Ptg0x19Sub.PtgNotDocumented: ptg = new PtgNotDocumented(reader, ptgtype2); break;
default: break;
}
}
else if (ptgtype == PtgNumber.Ptg0x18Sub)
{
}
else
{
switch (ptgtype)
{
case PtgNumber.PtgInt: ptg = new PtgInt(reader, ptgtype); break;
case PtgNumber.PtgAdd: ptg = new PtgAdd(reader, ptgtype); break;
case PtgNumber.PtgSub: ptg = new PtgSub(reader, ptgtype); break;
case PtgNumber.PtgMul: ptg = new PtgMul(reader, ptgtype); break;
case PtgNumber.PtgDiv: ptg = new PtgDiv(reader, ptgtype); break;
case PtgNumber.PtgParen: ptg = new PtgParen(reader, ptgtype); break;
case PtgNumber.PtgNum: ptg = new PtgNum(reader, ptgtype); break;
case PtgNumber.PtgArray: ptg = new PtgArray(reader, ptgtype); break;
case PtgNumber.PtgRef: ptg = new PtgRef(reader, ptgtype); break;
case PtgNumber.PtgRefN: ptg = new PtgRefN(reader, ptgtype); break;
case PtgNumber.PtgPower: ptg = new PtgPower(reader, ptgtype); break;
case PtgNumber.PtgPercent: ptg = new PtgPercent(reader, ptgtype); break;
case PtgNumber.PtgBool: ptg = new PtgBool(reader, ptgtype); break;
case PtgNumber.PtgGt: ptg = new PtgGt(reader, ptgtype); break;
case PtgNumber.PtgGe: ptg = new PtgGe(reader, ptgtype); break;
case PtgNumber.PtgLt: ptg = new PtgLt(reader, ptgtype); break;
case PtgNumber.PtgLe: ptg = new PtgLe(reader, ptgtype); break;
case PtgNumber.PtgEq: ptg = new PtgEq(reader, ptgtype); break;
case PtgNumber.PtgNe: ptg = new PtgNe(reader, ptgtype); break;
case PtgNumber.PtgUminus: ptg = new PtgUminus(reader, ptgtype); break;
case PtgNumber.PtgUplus: ptg = new PtgUplus(reader, ptgtype); break;
case PtgNumber.PtgStr: ptg = new PtgStr(reader, ptgtype); break;
case PtgNumber.PtgConcat: ptg = new PtgConcat(reader, ptgtype); break;
case PtgNumber.PtgUnion: ptg = new PtgUnion(reader, ptgtype); break;
case PtgNumber.PtgIsect: ptg = new PtgIsect(reader, ptgtype); break;
case PtgNumber.PtgMemErr: ptg = new PtgMemErr(reader, ptgtype); break;
case PtgNumber.PtgArea: ptg = new PtgArea(reader, ptgtype); break;
case PtgNumber.PtgAreaN: ptg = new PtgAreaN(reader, ptgtype); break;
case PtgNumber.PtgFuncVar: ptg = new PtgFuncVar(reader, ptgtype); break;
case PtgNumber.PtgFunc: ptg = new PtgFunc(reader, ptgtype); break;
case PtgNumber.PtgExp: ptg = new PtgExp(reader, ptgtype); break;
case PtgNumber.PtgRef3d: ptg = new PtgRef3d(reader, ptgtype); break;
case PtgNumber.PtgArea3d: ptg = new PtgArea3d(reader, ptgtype); break;
case PtgNumber.PtgNameX: ptg = new PtgNameX(reader, ptgtype); break;
case PtgNumber.PtgName: ptg = new PtgName(reader, ptgtype); break;
case PtgNumber.PtgMissArg: ptg = new PtgMissArg(reader, ptgtype); break;
case PtgNumber.PtgRefErr: ptg = new PtgRefErr(reader, ptgtype); break;
case PtgNumber.PtgRefErr3d: ptg = new PtgRefErr3d(reader, ptgtype); break;
case PtgNumber.PtgAreaErr: ptg = new PtgAreaErr(reader, ptgtype); break;
case PtgNumber.PtgAreaErr3d: ptg = new PtgAreaErr3d(reader, ptgtype); break;
case PtgNumber.PtgMemFunc: ptg = new PtgMemFunc(reader, ptgtype); break;
case PtgNumber.PtgMemArea: ptg = new PtgMemArea(reader, ptgtype); break;
case PtgNumber.PtgErr: ptg = new PtgErr(reader, ptgtype); break;
case PtgNumber.PtgRange: ptg = new PtgRange(reader, ptgtype); break;
default: break;
}
}
i += ptg.getLength() - 1;
ptg.dataType = dt;
ptgStack.Push(ptg);
}
}
catch (Exception ex)
{
throw new ExtractorException(ExtractorException.PARSEDFORMULAEXCEPTION, ex);
}
return(ptgStack);
}
public XmlTkTpb(IStreamReader reader)
{
this.textPropsStream = new XmlTkBlob(reader);
}
public XmlTkPieComboFrom12Frt(IStreamReader reader)
{
this.fPieCombo = new XmlTkBool(reader);
}
public void Open()
{
if (m_inputStream == null)
{
m_inputStream = StreamManager.OpenReadStream(FilePath, PointDataOffset);
}
}
public XmlTkFormatCodeFrt(IStreamReader reader)
{
this.stFormat = new XmlTkString(reader);
}
public XmlTkTickMarkSkipFrt(IStreamReader reader)
{
this.nInternal = new XmlTkDWord(reader);
}
public XmlTkTickLabelPositionFrt(IStreamReader reader)
{
this.xmltkHigh = new XmlTkToken(reader);
}
public abstract void SetInputSource(int index, IStreamReader stream);
public object ReadValue(IStreamReader reader, ISerializeContext context)
{
byte contentType = reader.ReadUInt8();
context.Key = this.Name;
if (contentType == ValueItem.CollectionObjectIdent)
{
int count = reader.ReadInt32();
if (isArray)
{
Array array = Array.CreateInstance(itemType, count);
if (isByteArray)
{
return(reader.ReadBytes(count).ToArray());
}
else
{
for (int i = 0; i < count; i++)
{
context.ArrayIndex = i;
var item = itemStructure.ReadValue(reader, context);
array.SetValue(item, i);
}
context.ArrayIndex = null;
}
return(array);
}
else if (implementsIList)
{
IList coll = (IList)TypeService.CreateInstance(targetCollectionType);
for (int i = 0; i < count; i++)
{
context.ArrayIndex = i;
var item = itemStructure.ReadValue(reader, context);
coll.Add(item);
}
context.ArrayIndex = null;
return(coll);
}
else
{
object specialColl = TypeService.CreateInstance(targetCollectionType);
for (int i = 0; i < count; i++)
{
context.ArrayIndex = i;
var item = itemStructure.ReadValue(reader, context);
specialCollAddMethod.Invoke(specialColl, new object[] { item });
}
context.ArrayIndex = null;
return(specialColl);
}
}
else if (contentType == ValueItem.NullValueIdent)
{
return(null);
}
else if (contentType == ValueItem.TypeMetaInfo)
{
TypeMetaStructure.SkipTypeMetaInfo(reader);
return(this.ReadValue(reader, context));
}
else
{
throw new InvalidOperationException($"Type ident {contentType} not expected!");
}
}
private static async Task<IHttpPost> GetPostData(IStreamReader streamReader, IHttpHeaders headers)
{
int postContentLength;
IHttpPost post;
if (headers.TryGetByName("content-length", out postContentLength) && postContentLength > 0)
{
post = await HttpPost.Create(streamReader, postContentLength, Logger).ConfigureAwait(false);
}
else
{
post = EmptyHttpPost.Empty;
}
return post;
}
public XmlTkColorMappingOverride(IStreamReader reader)
{
this.rgThemeOverride = new XmlTkBlob(reader);
}
public ChartSheetContentSequence(IStreamReader reader)
: base(reader)
{
// reset id counter for chart groups
ChartFormatIdGenerator.Instance.StartNewChartsheetSubstream();
ChartAxisIdGenerator.Instance.StartNewChartsheetSubstream();
// CHARTSHEETCONTENT = [WriteProtect] [SheetExt] [WebPub] *HFPicture PAGESETUP PrintSize [HeaderFooter] [BACKGROUND] *Fbi *Fbi2 [ClrtClient] [PROTECTION]
// [Palette] [SXViewLink] [PivotChartBits] [SBaseRef] [MsoDrawingGroup] OBJECTS Units CHARTFOMATS SERIESDATA *WINDOW *CUSTOMVIEW [CodeName] [CRTMLFRT] EOF
// [WriteProtect]
if (BiffRecord.GetNextRecordType(reader) == RecordType.WriteProtect)
{
this.WriteProtect = (WriteProtect)BiffRecord.ReadRecord(reader);
}
// [SheetExt]
if (BiffRecord.GetNextRecordType(reader) == RecordType.SheetExt)
{
this.SheetExt = (SheetExt)BiffRecord.ReadRecord(reader);
}
// [WebPub]
if (BiffRecord.GetNextRecordType(reader) == RecordType.WebPub)
{
this.WebPub = (WebPub)BiffRecord.ReadRecord(reader);
}
// *HFPicture
while (BiffRecord.GetNextRecordType(reader) == RecordType.HFPicture)
{
this.HFPictures.Add((HFPicture)BiffRecord.ReadRecord(reader));
}
// PAGESETUP
this.PageSetupSequence = new PageSetupSequence(reader);
// PrintSize
if (BiffRecord.GetNextRecordType(reader) == RecordType.PrintSize)
{
this.PrintSize = (PrintSize)BiffRecord.ReadRecord(reader);
}
// [HeaderFooter]
if (BiffRecord.GetNextRecordType(reader) == RecordType.HeaderFooter)
{
this.HeaderFooter = (HeaderFooter)BiffRecord.ReadRecord(reader);
}
// [BACKGROUND]
if (BiffRecord.GetNextRecordType(reader) == RecordType.BkHim)
{
this.BackgroundSequence = new BackgroundSequence(reader);
}
// *Fbi
this.Fbis = new List <Fbi>();
while (BiffRecord.GetNextRecordType(reader) == RecordType.Fbi)
{
this.Fbis.Add((Fbi)BiffRecord.ReadRecord(reader));
}
// *Fbi2
this.Fbi2s = new List <Fbi2>();
while (BiffRecord.GetNextRecordType(reader) == RecordType.Fbi2)
{
this.Fbi2s.Add((Fbi2)BiffRecord.ReadRecord(reader));
}
// [ClrtClient]
if (BiffRecord.GetNextRecordType(reader) == RecordType.ClrtClient)
{
this.ClrtClient = (ClrtClient)BiffRecord.ReadRecord(reader);
}
// [PROTECTION]
this.ProtectionSequence = new ProtectionSequence(reader);
// [Palette]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Palette)
{
this.Palette = (Palette)BiffRecord.ReadRecord(reader);
}
// [SXViewLink]
if (BiffRecord.GetNextRecordType(reader) == RecordType.SXViewLink)
{
this.SXViewLink = (SXViewLink)BiffRecord.ReadRecord(reader);
}
// [PivotChartBits]
if (BiffRecord.GetNextRecordType(reader) == RecordType.PivotChartBits)
{
this.PivotChartBits = (PivotChartBits)BiffRecord.ReadRecord(reader);
}
// [SBaseRef]
if (BiffRecord.GetNextRecordType(reader) == RecordType.SBaseRef)
{
this.SBaseRef = (SBaseRef)BiffRecord.ReadRecord(reader);
}
// [MsoDrawingGroup]
if (BiffRecord.GetNextRecordType(reader) == RecordType.MsoDrawingGroup)
{
this.MsoDrawingGroup = (MsoDrawingGroup)BiffRecord.ReadRecord(reader);
}
// OBJECTS
this.ObjectsSequence = new ObjectsSequence(reader);
// Units
this.Units = (Units)BiffRecord.ReadRecord(reader);
// CHARTFOMATS
this.ChartFormatsSequence = new ChartFormatsSequence(reader);
// SERIESDATA
this.SeriesDataSequence = new SeriesDataSequence(reader);
// *WINDOW
this.WindowSequences = new List <WindowSequence>();
while (BiffRecord.GetNextRecordType(reader) == RecordType.Window2)
{
this.WindowSequences.Add(new WindowSequence(reader));
}
// *CUSTOMVIEW
this.CustomViewSequences = new List <CustomViewSequence>();
// CUSTOMVIEW seems to be totally optional,
// so check for the existence of the next sequences
while (BiffRecord.GetNextRecordType(reader) != RecordType.CodeName &&
BiffRecord.GetNextRecordType(reader) != RecordType.CrtMlFrt &&
BiffRecord.GetNextRecordType(reader) != RecordType.EOF)
{
this.CustomViewSequences.Add(new CustomViewSequence(reader));
}
//this.CustomViewSequences = new List<CustomViewSequence>();
//while (BiffRecord.GetNextRecordType(reader) == RecordType.UserSViewBegin)
//{
// this.CustomViewSequences.Add(new CustomViewSequence(reader));
//}
// [CodeName]
if (BiffRecord.GetNextRecordType(reader) == RecordType.CodeName)
{
this.CodeName = (CodeName)BiffRecord.ReadRecord(reader);
}
// NOTE: The occurence of a HeaderFooter record at this position in the sequence
// is a deviation from the spec. However it has been encountered in certain
// test documents
//
// [HeaderFooter]
if (BiffRecord.GetNextRecordType(reader) == RecordType.HeaderFooter)
{
this.HeaderFooter = (HeaderFooter)BiffRecord.ReadRecord(reader);
}
// [CRTMLFRT]
if (BiffRecord.GetNextRecordType(reader) == RecordType.CrtMlFrt)
{
this.CrtMlfrtSequence = new CrtMlfrtSequence(reader);
}
// EOF
this.EOF = (EOF)BiffRecord.ReadRecord(reader);
}
public void WriteUnmatchedRecord(IStreamReader reader, Record record)
{
WriteRecordsToFile(reader, record, "Unmatched_From_");
}
public override void SetInputSource(int index, IStreamReader stream)
{
throw new InternalFailureException();
}
public int ReadTile(IStreamReader inputStream, byte[] inputBuffer)
{
return ReadTile(inputStream, inputBuffer, 0);
}
public CrtSequence(IStreamReader reader)
: base(reader)
{
// ChartFormat
// Begin
// (Bar / Line / (BopPop [BopPopCustom]) / Pie / Area / Scatter / Radar / RadarArea / Surf)
// CrtLink [SeriesList] [Chart3d] [LD] [2DROPBAR] *4(CrtLine LineFormat) *2DFTTEXT [DataLabExtContents] [SS] *4SHAPEPROPS
// End
// ChartFormat
this.ChartFormat = (ChartFormat)BiffRecord.ReadRecord(reader);
// Begin
this.Begin = (Begin)BiffRecord.ReadRecord(reader);
// (Bar / Line / (BopPop [BopPopCustom]) / Pie / Area / Scatter / Radar / RadarArea / Surf)
this.ChartType = BiffRecord.ReadRecord(reader);
if (BiffRecord.GetNextRecordType(reader) == RecordType.BopPopCustom)
{
this.BopPopCustom = (BopPopCustom)BiffRecord.ReadRecord(reader);
}
// CrtLink
this.CrtLink = (CrtLink)BiffRecord.ReadRecord(reader);
// [SeriesList]
if (BiffRecord.GetNextRecordType(reader) == RecordType.SeriesList)
{
this.SeriesList = (SeriesList)BiffRecord.ReadRecord(reader);
}
// [Chart3d]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Chart3d)
{
this.Chart3d = (Chart3d)BiffRecord.ReadRecord(reader);
}
// [LD]
if (BiffRecord.GetNextRecordType(reader) == RecordType.Legend)
{
this.LdSequence = new LdSequence(reader);
}
// [2DROPBAR]
if (BiffRecord.GetNextRecordType(reader) == RecordType.DropBar)
{
this.DropBarSequence = new DropBarSequence[2];
for (int i = 0; i < 2; i++)
{
this.DropBarSequence[i] = new DropBarSequence(reader);
}
}
//*4(CrtLine LineFormat)
this.CrtLineGroups = new List <CrtLineGroup>();
while (BiffRecord.GetNextRecordType(reader) == RecordType.CrtLine)
{
this.CrtLineGroups.Add(new CrtLineGroup(reader));
}
//*2DFTTEXT
this.DftTextSequences = new List <DftTextSequence>();
while (BiffRecord.GetNextRecordType(reader) == RecordType.DataLabExt ||
BiffRecord.GetNextRecordType(reader) == RecordType.DefaultText)
{
this.DftTextSequences.Add(new DftTextSequence(reader));
}
//[DataLabExtContents]
if (BiffRecord.GetNextRecordType(reader) == RecordType.DataLabExtContents)
{
this.DataLabExtContents = (DataLabExtContents)BiffRecord.ReadRecord(reader);
}
//[SS]
if (BiffRecord.GetNextRecordType(reader) == RecordType.DataFormat)
{
this.SsSequence = new SsSequence(reader);
}
//*4SHAPEPROPS
this.ShapePropsSequences = new List <ShapePropsSequence>();
while (BiffRecord.GetNextRecordType(reader) == RecordType.ShapePropsStream)
{
this.ShapePropsSequences.Add(new ShapePropsSequence(reader));
}
if (BiffRecord.GetNextRecordType(reader) == RecordType.CrtMlFrt)
{
var crtmlfrtseq = new CrtMlfrtSequence(reader);
}
this.End = (End)BiffRecord.ReadRecord(reader);
}
public XF(IStreamReader reader, RecordType id, UInt16 length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.ifnt = reader.ReadUInt16();
this.ifmt = reader.ReadUInt16();
this.ixfParent = reader.ReadUInt16();
this.fLocked = ((int)this.ixfParent & 0x01);
this.fHidden = ((int)this.ixfParent & 0x02) >> 1;
this.fStyle = ((int)this.ixfParent & 0x04) >> 2;
this.f123Prefix = ((int)this.ixfParent & 0x08) >> 3;
this.ixfParent = this.ixfParent & 0xFFF0;
/// create a buffer value
UInt32 buffer = reader.ReadUInt16();
/// alc - fWrap - alcV - fJustLast - trot
/// Offset 10
this.alc = (int)buffer & 0x00000007;
this.fWrap = (int)buffer & 0x00000008;
this.alcV = (int)(buffer & 0x00000070) >> 0x04;
this.fJustLast = (int)(buffer & 0x00000080) >> 0x07;
this.trot = (int)(buffer & 0x0000FF00) >> 0x08;
///
/// Offset 12
buffer = reader.ReadUInt16();
this.cIndent = (int)buffer & 0x0000000F;
this.fShrinkToFit = (int)(buffer & 0x00000010) >> 0x04;
this.fMergeCell = (int)(buffer & 0x00000020) >> 0x05;
this.iReadOrder = (int)(buffer & 0x000000C0) >> 0x06;
this.fAtrNum = (int)(buffer & 0x00000400) >> 0x0A;
this.fAtrFnt = (int)(buffer & 0x00000800) >> 0x0B;
this.fAtrAlc = (int)(buffer & 0x00001000) >> 0x0C;
this.fAtrBdr = (int)(buffer & 0x00002000) >> 0x0D;
this.fAtrPat = (int)(buffer & 0x00004000) >> 0x0E;
this.fAtrProt = (int)(buffer & 0x0008000) >> 0x0F;
///
/// Offset 14
buffer = reader.ReadUInt16();
this.dgLeft = (int)buffer & 0x0000000F;
this.dgRight = (int)(buffer & 0x000000F0) >> 0x04;
this.dgTop = (int)(buffer & 0x00000F00) >> 0x08;
this.dgBottom = (int)(buffer & 0x0000F000) >> 0x0C;
///
/// Offset 16
buffer = reader.ReadUInt16();
this.icvLeft = (int)buffer & 0x0000007F;
this.icvRight = (int)(buffer & 0x00003F80) >> 0x04;
this.grbitDiag = (int)(buffer & 0x0000C000) >> 0x0E;
///
/// Offset 18
buffer = reader.ReadUInt32();
this.icvTop = (int)buffer & 0x0000007F;
this.icvBottom = (int)(buffer & 0x00003F80) >> 0x04;
this.icvDiag = (int)(buffer & 0x001FC000) >> 0x0C;
this.dgDiag = (int)(buffer & 0x01E00000) >> 0x15;
this.fHasXFExt = (int)(buffer & 0x02000000) >> 0x18;
this.fls = (int)(buffer & 0xFC000000) >> 0x1A;
///
/// Offset 22
buffer = reader.ReadUInt16();
this.icvFore = (int)buffer & 0x0000007F;
this.icvBack = (int)(buffer & 0x00003F80) >> 0x07;
this.fSxButton = (int)(buffer & 0x00004000) >> 0x0C;
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public CrtLineGroup(IStreamReader reader)
{
// CrtLine LineFormat
this.CrtLine = (CrtLine)BiffRecord.ReadRecord(reader);
this.LineFormat = (LineFormat)BiffRecord.ReadRecord(reader);
}
public void AnsweredCorrectly_1(IStreamReader stream)
{
answeredName = stream.ReadString();
score += 1;
}
public Formula(IStreamReader reader, RecordType id, UInt16 length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.val = new byte[8];
this.rw = reader.ReadUInt16();
this.col = reader.ReadUInt16();
this.ixfe = reader.ReadUInt16();
this.boolValueSet = false;
long oldStreamPosition = this.Reader.BaseStream.Position;
this.val = reader.ReadBytes(8); // read 8 bytes for the value of the formular
if (this.val[6] == 0xFF && this.val[7] == 0xFF)
{
// this value is a string, an error or a boolean value
byte firstOffset = this.val[0];
if (firstOffset == 1)
{
// this is a boolean value
this.boolValue = val[2];
this.boolValueSet = true;
}
if (firstOffset == 2)
{
// this is a error value
this.errorValue = (int)val[2];
}
}
else
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.calculatedValue = reader.ReadDouble();
}
this.grbit = reader.ReadUInt16();
this.chn = reader.ReadUInt32(); // this is used for performance reasons only
this.cce = reader.ReadUInt16();
this.ptgStack = new Stack <AbstractPtg>();
// reader.ReadBytes(this.cce);
// check always calc mode
this.fAlwaysCalc = Utils.BitmaskToBool((int)grbit, 0x01);
// check if shared formula
this.fShrFmla = Utils.BitmaskToBool((int)grbit, 0x08);
oldStreamPosition = this.Reader.BaseStream.Position;
if (!fShrFmla)
{
try
{
this.ptgStack = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
}
catch (Exception ex)
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.Reader.BaseStream.Seek(this.cce, System.IO.SeekOrigin.Current);
TraceLogger.Error("Formula parse error in Row {0} Column {1}", this.rw, this.col);
TraceLogger.Debug(ex.StackTrace);
TraceLogger.Debug("Inner exception: {0}", ex.InnerException.StackTrace);
}
}
else
{
reader.ReadBytes(this.cce);
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public int ReadTile(IStreamReader inputStream, byte[] inputBuffer, int index)
{
if (PointCount == 0)
return 0;
if (index + StorageSize > inputBuffer.Length)
throw new ArgumentException("Tile data is larger than available buffer", "inputBuffer");
// seek if necessary (hopefully this is minimized)
var position = TileSet.TileSource.PointDataOffset + (PointOffset * TileSet.TileSource.PointSizeBytes);
if (inputStream.Position != position)
inputStream.Seek(position);
// read available points from main tile area and get low-res points from source
var localStorageSize = (PointCount - LowResCount) * TileSet.TileSource.PointSizeBytes;
var bytesRead = inputStream.Read(inputBuffer, index, localStorageSize);
//bytesRead += TileSet.TileSource.ReadLowResTile(this, inputBuffer, index + bytesRead);
var lowResPosition = TileSet.TileSource.PointDataOffset + ((TileSet.PointCount - TileSet.LowResCount + LowResOffset) * TileSet.TileSource.PointSizeBytes);
inputStream.Seek(lowResPosition);
var lowResStorageSize = LowResCount * TileSet.TileSource.PointSizeBytes;
bytesRead += inputStream.Read(inputBuffer, index + bytesRead, lowResStorageSize);
return bytesRead;
}
