/// <summary>
/// Create new STempoCodes
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">Contain Data for this frame</param>
/// <param name="Length"></param>
public SynchronisedTempoFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
_TempoCodes = new FrameCollection <TempoCode>("Temnpo Codes");
TStream = new BreadPlayer.Tags.TagStreamUWP(FS);
_TimeStamp = (TimeStamps)TStream.ReadByte(FS);
if (IsValidEnumValue(_TimeStamp, ExceptionLevels.Error, FrameID))
{
return;
}
int Tempo;
uint Time;
while (Length > 4)
{
Tempo = TStream.ReadByte(FS);
Length--;
if (Tempo == 0xFF)
{
Tempo += TStream.ReadByte(FS);
Length--;
}
Time = TStream.ReadUInt(4);
Length -= 4;
_TempoCodes.Add(FrameID, new TempoCode(Tempo, Time));
}
}
/// <summary>
/// Create new SynchronisedTempoFrame from TimeStamps
/// </summary>
/// <param name="Flags">FrameFlags</param>
/// <param name="TimeStamp">TimeStamps for current SynchronisedTempoFrame</param>
public SynchronisedTempoFrame(FrameFlags Flags, TimeStamps TimeStamp, Stream FS)
: base("SYTC", Flags, FS)
{
_TempoCodes = new FrameCollection <TempoCode>("Tempo Codes");
this.TimeStampFormat = TimeStamp;
}
public SynchronisedTempoFrame(FrameFlags Flags, TimeStamps TimeStamp)
: base("SYTC", Flags)
{
_TempoCodes = new FramesCollection <TempoCode>();
this.TimeStampFormat = TimeStamp;
}
/// <summary>
/// create new PositionSynchronised frame
/// </summary>
/// <param name="Flags">Flags of frame</param>
/// <param name="TimeStamp">TimeStamp to use for frame</param>
/// <param name="Position">Position of frame</param>
public PositionSynchronisedFrame(FrameFlags Flags, TimeStamps TimeStamp,
long Position)
: base("POSS", Flags)
{
this.TimeStamp = TimeStamp;
_Position = Position;
}
private bool m_Dead; // = false;
public CLogFile(string path, int appendIfSmallerThan = 0)
{
m_Path = path;
bool keep = false;
if (appendIfSmallerThan > 0 && File.Exists(m_Path))
{
if (new FileInfo(m_Path).Length < appendIfSmallerThan)
{
keep = true;
}
}
m_fs = new StreamWriter(m_Path, keep)
{
AutoFlush = true
};
m_TimeStamp = TimeStamps.Date;
#if DEBUG
m_TimeStamp = TimeStamps.Time;
#endif
if (keep == false && appendIfSmallerThan > 0)
{
WriteLine("New file started. " + DateTime.Now.ToLongDateString());
}
}
public void runGameTick(SimulationParams simulationParams)
{
foreach (CelestialBody celestialBody in CurMap.celestialBodies)
{
celestialBody.X += celestialBody.VX * simulationParams.DeltaTime.TotalSeconds;
celestialBody.Y += celestialBody.VY * simulationParams.DeltaTime.TotalSeconds;
if (celestialBody.X > 800 - celestialBody.Radius)
{
celestialBody.VX = -celestialBody.VX;
celestialBody.X = 800 - celestialBody.Radius;
}
else if (celestialBody.X < 0 + celestialBody.Radius)
{
celestialBody.VX = -celestialBody.VX;
celestialBody.X = celestialBody.Radius;
}
if (celestialBody.Y > 600 - celestialBody.Radius)
{
celestialBody.VY = -celestialBody.VY;
celestialBody.Y = 600 - celestialBody.Radius;
}
else if (celestialBody.Y < 0 + celestialBody.Radius)
{
celestialBody.VY = -celestialBody.VY;
celestialBody.Y = celestialBody.Radius;
}
}
if (simulationParams.TotalTime > TimeSpan.FromMilliseconds(100))
{
Console.WriteLine("adding new timestamp at {0}", DateTime.UtcNow);
newTimeStamp(TimeStamps.LastOrDefault().Key + simulationParams.TotalTime);
simulationParams.TotalTime = TimeSpan.Zero;
}
}
private void GetColumnsAndValues(out StringBuilder columns, out StringBuilder values, params DbField[] skipFields)
{
columns = new StringBuilder();
values = new StringBuilder();
List <DbField> fields = new List <DbField> ();
foreach (List <DbColumnManager> managersList in columnManagers)
{
foreach (DbColumnManager manager in managersList)
{
bool skip = skipFields.Any(field => manager.DbField == field);
if (skip)
{
continue;
}
if (fields.Contains(manager.DbField))
{
continue;
}
if (columns.Length > 0)
{
columns.Append(", ");
values.Append(", ");
}
columns.Append(fTrans.GetFieldName(manager.DbField));
values.Append(TimeStamps.Contains(manager.DbField) && updateTimeStamp ?
CurrentDateTimeFunction : fTrans.GetParameterName(manager.DbField));
fields.Add(manager.DbField);
}
}
}
/// <summary>
/// create new PositionSynchronised frame
/// </summary>
/// <param name="Flags">Flags of frame</param>
/// <param name="TimeStamp">TimeStamp to use for frame</param>
/// <param name="Position">Position of frame</param>
public PositionSynchronisedFrame(FrameFlags Flags, TimeStamps TimeStamp,
long Position)
: base("POSS", Flags)
{
this.TimeStamp = TimeStamp;
_Position = Position;
}
/// <summary>
/// Create new STempoCodes
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">Contain Data for this frame</param>
/// <param name="Length"></param>
internal SynchronisedTempoFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_TempoCodes = new FramesCollection <TempoCode>();
_TimeStamp = (TimeStamps)Data.ReadByte();
if (IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
int Tempo;
uint Time;
while (Length > 4)
{
Tempo = Data.ReadByte();
Length--;
if (Tempo == 0xFF)
{
Tempo += Data.ReadByte();
Length--;
}
Time = Data.ReadUInt(4);
Length -= 4;
_TempoCodes.Add(new TempoCode(Tempo, Time));
}
}
public virtual void Test()
{
ITestableReplicationProviderInside providerA = A().Provider();
ITestableReplicationProviderInside providerB = B().Provider();
providerA.StoreNew(new Pilot());
providerA.Commit();
IReplicationSession replication = Replication.Begin(providerA, providerB, null, _fixtures
.reflector);
TimeStamps initialTimeStampsB = AssertTimeStampsForFirstReplication(providerB);
IObjectSet modifiedObjects = providerA.ObjectsChangedSinceLastReplication();
while (modifiedObjects.HasNext())
{
replication.Replicate(modifiedObjects.Next());
}
replication.Commit();
Pilot replicatedPilot = (Pilot)providerB.GetStoredObjects(typeof(Pilot)).Next();
long version = providerB.ObjectVersion(replicatedPilot);
Assert.AreEqual(initialTimeStampsB.Commit(), version);
replication = Replication.Begin(providerA, providerB, null, _fixtures.reflector);
TimeStamps timestampsBAfterReplication = AssertTimeStampsForSecondReplication(initialTimeStampsB
, providerB);
replication.Commit();
Pilot pilotStoredAfterReplication = new Pilot();
providerB.StoreNew(pilotStoredAfterReplication);
providerB.Commit();
providerB.WaitForPreviousCommits();
version = providerB.ObjectVersion(pilotStoredAfterReplication);
Assert.IsGreater(timestampsBAfterReplication.Commit(), version);
}
// if we are fixing a zip/7z file then we use zipFileOut to open an output compressed stream
// if we are just making a file then we use filenameOut to open an output filestream
private static ReturnCode OpenOutputStream(RvFile fileOut, RvFile fileIn, ICompress zipFileOut, string filenameOut, ushort compressionMethod, bool rawCopy, bool sourceTrrntzip, long?dateTime, out Stream writeStream, out string error)
{
writeStream = null;
if (fileOut.FileType == FileType.ZipFile || fileOut.FileType == FileType.SevenZipFile)
{
// if ZipFileOut == null then we have not open the output zip yet so open it from writing.
if (zipFileOut == null)
{
error = "zipFileOut cannot be null";
return(ReturnCode.FileSystemError);
}
if (zipFileOut.ZipOpen != ZipOpenType.OpenWrite)
{
error = "Output Zip File is not set to OpenWrite, Logic Error.";
return(ReturnCode.LogicError);
}
if (fileIn.Size == null)
{
error = "Null File Size found in Fixing File :" + fileIn.FullName;
return(ReturnCode.LogicError);
}
TimeStamps ts = null;
if (dateTime != null)
{
ts = new TimeStamps {
ModTime = dateTime
};
}
ZipReturn zr = zipFileOut.ZipFileOpenWriteStream(rawCopy, sourceTrrntzip, fileOut.Name, (ulong)fileIn.Size, compressionMethod, out writeStream, ts);
if (zr != ZipReturn.ZipGood)
{
error = "Error Opening Write Stream " + zr;
return(ReturnCode.FileSystemError);
}
}
else
{
if (File.Exists(filenameOut) && fileOut.GotStatus != GotStatus.Corrupt)
{
error = "Rescan needed, File Changed :" + filenameOut;
return(ReturnCode.RescanNeeded);
}
int errorCode = FileStream.OpenFileWrite(filenameOut, out writeStream);
if (errorCode != 0)
{
error = new Win32Exception(errorCode).Message + ". " + filenameOut;
return(ReturnCode.FileSystemError);
}
}
error = "";
return(ReturnCode.Good);
}
public void mapBackFiveSeconds()
{
var timestamp = TimeStamps.LastOrDefault().Key - TimeSpan.FromSeconds(5);
if (timestamp > TimeStamps.FirstOrDefault().Key)
{
TimeStamps = TimeStamps.Where(k => k.Key <= timestamp).ToList().ToDictionary(k => k.Key, v => v.Value);
CurMap = TimeStamps.LastOrDefault().Value;
}
}
public void ClearAll()
{
foreach (var ds in seriesList)
{
ds.Values.Clear();
lastTime = 0;
}
TimeStamps.Clear();
resetControllerOffset = true;
}
private void TimePlot_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
CurrentMoveOp = TentativeOp;
if (CurrentMoveOp == MoveOp.resetScale)
{
AutoScaleRequested = true;
}
if (CurrentMoveOp == MoveOp.goToZero)
{
if (TimeStamps.Count == 0)
{
xOffsetG = DrawPlotArea.Width;
}
else
{
xOffsetG = DrawPlotArea.Width - TimeStamps.Max() * XPPU;
}
needsRefresh = true;
}
if (CurrentMoveOp == MoveOp.xyPan)
{
Cursor = Cursors.NoMove2D;
}
else if (CurrentMoveOp == MoveOp.yZoom)
{
Cursor = Cursors.NoMove2D;
}
GAtMouseDown = e.Location;
VAtMouseDown = GtoV(e.Location);
}
else if (e.Button == MouseButtons.Right)
{
if (TentativeOp == MoveOp.selectSeries)
{
ContextMenuStrip = HoverOver.ContextMenuStrip;
ContextMenuStrip.Closed += ContextMenuStrip_Closed;
MenuStripIsShowing = HoverOver;
}
else if (TentativeOp == MoveOp.yZoom)
{
ContextMenuStrip = yScaleConextMenuStrip;
}
else
{
ContextMenuStrip_bkp = ContextMenuStrip;
ContextMenuStrip = null;
}
}
MouseDownAt = LastMouse;
}
private TimeStamps AssertTimeStampsForFirstReplication(ITestableReplicationProviderInside
provider)
{
TimeStamps timeStamps = provider.TimeStamps();
Assert.IsNotNull(timeStamps);
Assert.AreEqual(0, timeStamps.From());
Assert.IsGreater(0, timeStamps.To());
Assert.AreEqual(timeStamps.To() + 1, timeStamps.Commit());
return(timeStamps);
}
private TimeStamps AssertTimeStampsForSecondReplication(TimeStamps initialTimeStamps
, ITestableReplicationProviderInside provider)
{
TimeStamps timeStamps = provider.TimeStamps();
Assert.IsNotNull(timeStamps);
Assert.AreEqual(initialTimeStamps.Commit(), timeStamps.From());
Assert.IsGreater(timeStamps.From(), timeStamps.To());
Assert.AreEqual(timeStamps.To() + 1, timeStamps.Commit());
return(timeStamps);
}
public GraphData(GraphData Original)
{
void Clone(object CloneFrom, CloneType cloneType)
{
switch (cloneType)
{
case CloneType.Status:
{
if (CloneFrom is ObservableCollection <int> cf)
{
foreach (int status in cf)
{
StatusValues.Add(status);
}
}
break;
}
case CloneType.Latency:
{
if (CloneFrom is ObservableCollection <int> cf)
{
foreach (int latency in cf)
{
LatencyValues.Add(latency);
}
}
break;
}
case CloneType.TimeStamps:
{
if (CloneFrom is ObservableCollection <DateTime> cf)
{
foreach (DateTime dt in cf)
{
TimeStamps.Add(new DateTime(dt.Ticks));
}
}
break;
}
}
}
GroupName = Original.GroupName;
Label = Original.Label;
FromHost = Original.FromHost;
ToHost = Original.ToHost;
Clone(Original.TimeStamps, CloneType.TimeStamps);
Clone(Original.StatusValues, CloneType.Status);
Clone(Original.LatencyValues, CloneType.Latency);
}
/// <summary>
/// New Synchronised Text
/// </summary>
/// <param name="Flags">Frame Flags</param>
/// <param name="TextEncoding">TextEncoding use for texts</param>
/// <param name="Lang">Language of texts</param>
/// <param name="TimeStamp">TimeStamps that use for times</param>
/// <param name="ContentType">ContentType</param>
/// <param name="ContentDescriptor">Descriptor of Contents</param>
public SynchronisedText(FrameFlags Flags,
TextEncodings TextEncoding, string Lang, TimeStamps TimeStamp,
ContentTypes ContentType, string ContentDescriptor, Stream FS)
: base("SYLT", Flags, FS)
{
_Syllables = new FrameCollection <Syllable>("Syllables");
this.ContentType = ContentType;
this.TimeStamp = TimeStamp;
this.TextEncoding = TextEncoding;
Language = new Language(Lang);
this.Text = ContentDescriptor;
}
public void newTimeStamp(DateTime time)
{
if (TimeStamps.Count > 10000) //20 minuten een maximale heap van ruwweg 90mb met het maximale aantal bodies
{
//remove all elements except for the first that exceed 10000
var list = TimeStamps.ToList();
list.RemoveRange(1, list.Count - 10000); //we want to keep the first element so you can still go back
TimeStamps = list.ToDictionary(k => k.Key, v => v.Value);
Console.WriteLine("Edited map to contain {0} items...", TimeStamps.Count);
}
Console.WriteLine("saved {0} items", CurMap.celestialBodies.Count);
TimeStamps.Add(time, (Map)CurMap.Clone());
}
internal FATXEntry(string xNameIn, uint xStart, int xSizeIn, long xPosition, bool xFolder, ref FATXDrive xdrive)
{
int DT = TimeStamps.FatTimeInt(DateTime.Now);
xT1 = DT;
xT2 = DT;
xT3 = DT;
Name = xNameIn;
xStartBlock = xStart;
xSize = (xIsFolder = xFolder) ? 0 : xSizeIn;
xOffset = xPosition;
xIsValid = true;
xDrive = xdrive;
}
public virtual float AppendLog(float time, float[] values, float dt, bool ClearIfTimeSuspicious)
{
if (tMax < time)
{
tMax = time;
}
if (resetControllerOffset)
{
controllerOffset = time;
resetControllerOffset = false;
tMax = 0;
}
time -= controllerOffset;
if (time < 0 || time < lastTime) // controller has reset
{
if (ClearIfTimeSuspicious)
{
ClearAll();
return(0);
}
else
{
time = lastTime + dt - controllerOffset;
tMax = time;
}
}
if (seriesList.Count != values.Length)
{
throw new Exception("Data size mismatch");
}
for (int i = 0; i < values.Length; i++)
{
seriesList[i].Values.Add(values[i]);
}
if (TimeStamps.Count == 0)
{
TimeStamps.Add(time);
}
else
{
TimeStamps.Add(time);
}
var bkp = lastTime;
lastTime = time;
return(time - bkp);
}
/// <summary>
/// New SynchronisedText
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Frame Flag</param>
/// <param name="Data">FileStream contain current frame data</param>
/// <param name="Length">Maximum availabel length for this frame</param>
public SynchronisedText(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
_Syllables = new FrameCollection <Syllable>("Syllables");
TStream = new BreadPlayer.Tags.TagStreamUWP(FS);
TextEncoding = (TextEncodings)TStream.ReadByte(FS);
if (!IsValidEnumValue(TextEncoding, ExceptionLevels.Error, FrameID))
{
return;
}
Length--;
Language = new Language(TStream.FS);
Length -= 3;
_TimeStamp = (TimeStamps)TStream.ReadByte(FS);
if (!IsValidEnumValue(_TimeStamp, ExceptionLevels.Error, FrameID))
{
return;
}
Length--;
_ContentType = (ContentTypes)TStream.ReadByte(FS);
if (!IsValidEnumValue(_ContentType))
{
_ContentType = ContentTypes.Other;
}
Length--;
// use Text variable for descriptor property
Text = TStream.ReadText(Length, TextEncoding, ref Length, true);
string tempText;
uint tempTime;
while (Length > 5)
{
tempText = TStream.ReadText(Length, TextEncoding, ref Length, true);
tempTime = TStream.ReadUInt(4);
_Syllables.Add(FrameID, new Syllable(tempTime, tempText));
Length -= 4;
}
}
/// <summary>
/// New SynchronisedText
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Frame Flag</param>
/// <param name="Data">FileStream contain current frame data</param>
internal SynchronisedText(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Syllables = new FramesCollection <Syllable>();
TextEncoding = (TextEncodings)Data.ReadByte();
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
{
return;
}
Length--;
_Language = new Language(Data);
Length -= 3;
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
return;
}
Length--;
_ContentType = (ContentTypes)Data.ReadByte();
if (!IsValidEnumValue(_ContentType, ValidatingErrorTypes.Nothing))
{
_ContentType = ContentTypes.Other;
}
Length--;
// use Text variable for descriptor property
ContentDescriptor = Data.ReadText(Length, TextEncoding, ref Length, true);
string tempText;
uint tempTime;
while (Length > 5)
{
tempText = Data.ReadText(Length, TextEncoding, ref Length, true);
tempTime = Data.ReadUInt(4);
_Syllables.Add(new Syllable(tempTime, tempText));
Length -= 4;
}
}
public LocalFile(string filename, TimeStamps dateTime = null)
{
Zip64 = false;
GeneralPurposeBitFlag = 2; // Maximum Compression Deflating
_compressionMethod = 8; // Compression Method Deflate
if (dateTime?.ModTime == null)
{
_lastModFileTimeDate = ZipUtils.trrntzipDateTime;
}
else
{
_lastModFileTimeDate = (long)dateTime.ModTime;
}
FileName = filename;
}
internal ZipLocalFile(string filename, TimeStamps dateTime = null)
{
SetStatus(LocalFileStatus.Zip64, false);
GeneralPurposeBitFlag = 2; // Maximum Compression Deflating
_compressionMethod = 8; // Compression Method Deflate
if (dateTime?.ModTime == null)
{
HeaderLastModified = CompressUtils.TrrntzipDateTime;
}
else
{
HeaderLastModified = (long)dateTime.ModTime;
}
Filename = filename;
}
internal PositionSynchronisedFrame(string FrameID, FrameFlags Flags, FileStream Data, int Length)
: base(FrameID, Flags)
{
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
Length--;
byte[] Long = new byte[8];
byte[] Buf = new byte[Length];
Data.Read(Buf, 0, Length);
Buf.CopyTo(Long, 8 - Buf.Length);
Array.Reverse(Long);
_Position = BitConverter.ToInt64(Long, 0);
}
internal PositionSynchronisedFrame(string FrameID, FrameFlags Flags, FileStream Data, int Length)
: base(FrameID, Flags)
{
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
Length--;
byte[] Long = new byte[8];
byte[] Buf = new byte[Length];
Data.Read(Buf, 0, Length);
Buf.CopyTo(Long, 8 - Buf.Length);
Array.Reverse(Long);
_Position = BitConverter.ToInt64(Long, 0);
}
/// <summary>
/// Create new EventTimingCodeFrame
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Flags of frame</param>
/// <param name="Data">TagStream to read data from</param>
/// <param name="Length">Maximum available length</param>
public EventTimingCodeFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
_Events = new FrameCollection <EventCode>("EventCode");
TStream = new BreadPlayer.Tags.TagStreamUWP(FS);
_TimeStamp = (TimeStamps)TStream.ReadByte(FS);
if (!IsValidEnumValue(_TimeStamp, ExceptionLevels.Error, FrameID))
{
return;
}
Length--;
while (Length >= 5)
{
_Events.Add(FrameID, new EventCode(TStream.ReadByte(FS), TStream.ReadUInt(4)));
Length -= 5;
}
}
internal EventTimingCodeFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Events = new FramesCollection <EventCode>();
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
Length--;
while (Length >= 5)
{
_Events.Add(new EventCode(Data.ReadByte(), Data.ReadUInt(4)));
Length -= 5;
}
}
/// <summary>
/// Create new PositionSynchronisedFrame
/// </summary>
/// <param name="FrameID">FrameID for this frame</param>
/// <param name="Flags">Frame Flags</param>
/// <param name="Data">TagStream to read data from</param>
/// <param name="Length">Maximum available length for this frame</param>
public PositionSynchronisedFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
TStream = new TagStreamUWP(FS);
_TimeStamp = (TimeStamps)TStream.ReadByte(FS);
if (!IsValidEnumValue(_TimeStamp, ExceptionLevels.Error, FrameID))
{
return;
}
Length--;
byte[] Long = new byte[8];
byte[] Buf = new byte[Length];
TStream.FS.Read(Buf, 0, Length);
Buf.CopyTo(Long, 8 - Buf.Length);
Array.Reverse(Long);
_Position = BitConverter.ToInt64(Long, 0);
}
/// <summary>
/// New SynchronisedText
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Frame Flag</param>
/// <param name="Data">FileStream contain current frame data</param>
internal SynchronisedText(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Syllables = new FramesCollection<Syllable>();
TextEncoding = (TextEncodings)Data.ReadByte();
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
return;
Length--;
_Language = new Language(Data);
Length -= 3;
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
return;
Length--;
_ContentType = (ContentTypes)Data.ReadByte();
if (!IsValidEnumValue(_ContentType, ValidatingErrorTypes.Nothing))
_ContentType = ContentTypes.Other;
Length--;
// use Text variable for descriptor property
ContentDescriptor = Data.ReadText(Length, TextEncoding, ref Length, true);
string tempText;
uint tempTime;
while (Length > 5)
{
tempText = Data.ReadText(Length, TextEncoding, ref Length, true);
tempTime = Data.ReadUInt(4);
_Syllables.Add(new Syllable(tempTime, tempText));
Length -= 4;
}
}
public string GetSetStatement(params DbField [] skipFields)
{
StringBuilder ret = new StringBuilder();
List <DbField> fields = new List <DbField> ();
foreach (List <DbColumnManager> managersList in columnManagers)
{
foreach (DbColumnManager manager in managersList)
{
if (skipFields.Any(field => manager.DbField == field))
{
continue;
}
if (fields.Contains(manager.DbField))
{
continue;
}
ret.Append(ret.Length == 0 ? " SET " : ", ");
string fieldName = fTrans.GetFieldName(manager.DbField);
if (TimeStamps.Contains(manager.DbField) && updateTimeStamp)
{
ret.AppendFormat("{0} = {1}", fieldName, CurrentDateTimeFunction);
}
else
{
string paramName = fTrans.StripQuotationChars(fieldName);
ret.AppendFormat("{0} = @{1}", fieldName, paramName);
}
fields.Add(manager.DbField);
}
}
return(ret.ToString());
}
public SynchronisedTempoFrame(FrameFlags Flags, TimeStamps TimeStamp)
: base("SYTC", Flags)
{
_TempoCodes = new FramesCollection<TempoCode>();
this.TimeStampFormat = TimeStamp;
}
/// <summary>
/// Create new EventTimingCode frame
/// </summary>
/// <param name="Flags">Flags of frame</param>
/// <param name="TimeStamp">TimeStamp use for times</param>
public EventTimingCodeFrame(FrameFlags Flags, TimeStamps TimeStamp)
: base("ETCO", Flags)
{
this.TimeStamp = TimeStamp;
}
/// <summary>
/// New Synchronised Text
/// </summary>
/// <param name="Flags">Frame Flags</param>
/// <param name="TextEncoding">TextEncoding use for texts</param>
/// <param name="Lang">Language of texts</param>
/// <param name="TimeStamp">TimeStamps that use for times</param>
/// <param name="ContentType">ContentType</param>
/// <param name="ContentDescriptor">Descriptor of Contents</param>
public SynchronisedText(FrameFlags Flags,
TextEncodings TextEncoding, string Lang, TimeStamps TimeStamp,
ContentTypes ContentType, string ContentDescriptor)
: base("SYLT", Flags)
{
_Syllables = new FramesCollection<Syllable>();
this.ContentType = ContentType;
this.TimeStamp = TimeStamp;
this.TextEncoding = TextEncoding;
Language = new Language(Lang);
this.ContentDescriptor = ContentDescriptor;
}
internal EventTimingCodeFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Events = new FramesCollection<EventCode>();
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
Length--;
while (Length >= 5)
{
_Events.Add(new EventCode(Data.ReadByte(), Data.ReadUInt(4)));
Length -= 5;
}
}
private void OnDeserialized(StreamingContext context) => TimeStamps = _additionalData.GetTimeStamps();
/// <summary>
/// Create new STempoCodes
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">Contain Data for this frame</param>
/// <param name="Length"></param>
internal SynchronisedTempoFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_TempoCodes = new FramesCollection<TempoCode>();
_TimeStamp = (TimeStamps)Data.ReadByte();
if (IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
int Tempo;
uint Time;
while (Length > 4)
{
Tempo = Data.ReadByte();
Length--;
if (Tempo == 0xFF)
{
Tempo += Data.ReadByte();
Length--;
}
Time = Data.ReadUInt(4);
Length -= 4;
_TempoCodes.Add(new TempoCode(Tempo, Time));
}
}
