private static void ConvertNotesToCsv(
IEnumerable <NoteWithCustomTimeAndLength> expectedNotes,
TempoMap tempoMap,
TimeSpanType timeType,
string[] expectedCsvLines,
NoteNumberFormat noteNumberFormat = NoteNumberFormat.NoteNumber,
TimeSpanType noteLengthType = TimeSpanType.Midi,
char delimiter = ',')
{
var filePath = Path.GetTempFileName();
var settings = new NoteCsvConversionSettings
{
TimeType = timeType,
NoteNumberFormat = noteNumberFormat,
NoteLengthType = noteLengthType
};
settings.CsvSettings.CsvDelimiter = delimiter;
try
{
new CsvConverter().ConvertNotesToCsv(expectedNotes.Select(n => n.GetNote(tempoMap)), filePath, tempoMap, true, settings);
var actualCsvLines = File.ReadAllLines(filePath);
CollectionAssert.AreEqual(expectedCsvLines, actualCsvLines, StringComparer.OrdinalIgnoreCase);
}
finally
{
File.Delete(filePath);
}
}
private static void ConvertCsvToNotes(
IEnumerable <NoteWithCustomTimeAndLength> expectedNotes,
TempoMap tempoMap,
TimeSpanType timeType,
string[] csvLines,
NoteNumberFormat noteNumberFormat = NoteNumberFormat.NoteNumber,
TimeSpanType noteLengthType = TimeSpanType.Midi,
char delimiter = ',')
{
var filePath = Path.GetTempFileName();
File.WriteAllLines(filePath, csvLines);
var settings = new NoteCsvConversionSettings
{
TimeType = timeType,
NoteNumberFormat = noteNumberFormat,
NoteLengthType = noteLengthType,
CsvDelimiter = delimiter
};
try
{
var actualNotes = new CsvConverter().ConvertCsvToNotes(filePath, tempoMap, settings).ToList();
_noteMethods.AssertCollectionsAreEqual(expectedNotes.Select(n => n.GetNote(tempoMap)), actualNotes);
ConvertNotesToFromCsv(actualNotes, tempoMap, filePath, settings);
}
finally
{
File.Delete(filePath);
}
}
public GeneralTimeSpanViewModel(TimeSpanType rpType) : base(rpType)
{
switch (rpType)
{
case TimeSpanType.All:
TimeSpanStart = "0";
TimeSpanEnd = "strftime('%s', 'now')";
break;
case TimeSpanType.Recent24Hours:
TimeSpanStart = "strftime('%s', 'now', '-1 days')";
TimeSpanEnd = "strftime('%s', 'now')";
break;
case TimeSpanType.Recent3Days:
TimeSpanStart = "strftime('%s', 'now', '-3 days')";
TimeSpanEnd = "strftime('%s', 'now')";
break;
case TimeSpanType.Recent7Days:
TimeSpanStart = "strftime('%s', 'now', '-7 days')";
TimeSpanEnd = "strftime('%s', 'now')";
break;
}
}
/// <summary>
/// Resizes group of notes by the specified ratio treating all notes as single object. For example,
/// resizing by ratio of 0.5 shrinks group of notes by two times.
/// </summary>
/// <param name="notes">Notes to resize.</param>
/// <param name="ratio">Ratio to resize notes by.</param>
/// <param name="distanceCalculationType">Type of distance calculations.</param>
/// <param name="tempoMap"></param>
/// <exception cref="ArgumentNullException"><paramref name="notes"/> is null. -or-
/// <paramref name="tempoMap"/> is null.</exception>
/// <exception cref="ArgumentException"><see cref="TimeSpanType.BarBeatTicks"/> or <see cref="TimeSpanType.BarBeatFraction"/>
/// is used for <paramref name="distanceCalculationType"/> which is unsupported.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="ratio"/> is negative.</exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="distanceCalculationType"/> specified an
/// invalid value.</exception>
public static void ResizeNotes(this IEnumerable <Note> notes,
double ratio,
TimeSpanType distanceCalculationType,
TempoMap tempoMap)
{
ThrowIfArgument.IsNull(nameof(notes), notes);
ThrowIfArgument.IsNegative(nameof(ratio), ratio, "Ratio is negative");
ThrowIfArgument.IsInvalidEnumValue(nameof(distanceCalculationType), distanceCalculationType);
ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap);
// Unable to calculate ratio between two bar/beat time spans
if (distanceCalculationType == TimeSpanType.BarBeatTicks || distanceCalculationType == TimeSpanType.BarBeatFraction)
{
throw new ArgumentException("BarBeat distance calculation type is not supported.", nameof(distanceCalculationType));
}
var notNullNotes = notes.Where(n => n != null);
if (!notNullNotes.Any())
{
return;
}
//
var minStartTime = notNullNotes.Select(n => n.Time).Min();
var startTime = TimeConverter.ConvertTo(minStartTime, distanceCalculationType, tempoMap);
ResizeNotesByRatio(notNullNotes, ratio, distanceCalculationType, tempoMap, startTime);
}
private static void ConvertMidiFileToCsv(
MidiFile midiFile,
MidiFileCsvLayout layout,
TimeSpanType timeType,
string[] expectedCsvLines,
NoteFormat noteFormat = NoteFormat.Events,
NoteNumberFormat noteNumberFormat = NoteNumberFormat.NoteNumber,
TimeSpanType noteLengthType = TimeSpanType.Midi)
{
var filePath = Path.GetTempFileName();
var settings = new MidiFileCsvConversionSettings
{
CsvLayout = layout,
TimeType = timeType,
NoteFormat = noteFormat,
NoteNumberFormat = noteNumberFormat,
NoteLengthType = noteLengthType
};
try
{
new CsvConverter().ConvertMidiFileToCsv(midiFile, filePath, true, settings);
var actualCsvLines = File.ReadAllLines(filePath);
CollectionAssert.AreEqual(expectedCsvLines, actualCsvLines, StringComparer.OrdinalIgnoreCase);
}
finally
{
File.Delete(filePath);
}
}
[Command(501)] // 4.0.0+
// CalculateSpanBetween(buffer<nn::time::sf::ClockSnapshot, 0x19>, buffer<nn::time::sf::ClockSnapshot, 0x19>) -> nn::TimeSpanType
public ResultCode CalculateSpanBetween(ServiceCtx context)
{
ClockSnapshot clockSnapshotA = ReadClockSnapshotFromBuffer(context, context.Request.PtrBuff[0]);
ClockSnapshot clockSnapshotB = ReadClockSnapshotFromBuffer(context, context.Request.PtrBuff[1]);
TimeSpanType result;
ResultCode resultCode = clockSnapshotA.SteadyClockTimePoint.GetSpanBetween(clockSnapshotB.SteadyClockTimePoint, out long timeSpan);
if (resultCode != ResultCode.Success)
{
resultCode = ResultCode.TimeNotFound;
if (clockSnapshotA.NetworkTime != 0 && clockSnapshotB.NetworkTime != 0)
{
result = TimeSpanType.FromSeconds(clockSnapshotB.NetworkTime - clockSnapshotA.NetworkTime);
resultCode = ResultCode.Success;
}
else
{
return(resultCode);
}
}
else
{
result = TimeSpanType.FromSeconds(timeSpan);
}
context.ResponseData.Write(result.NanoSeconds);
return(resultCode);
}
[Command(300)] // 4.0.0+
// CalculateMonotonicSystemClockBaseTimePoint(nn::time::SystemClockContext) -> s64
public ResultCode CalculateMonotonicSystemClockBaseTimePoint(ServiceCtx context)
{
SteadyClockCore steadyClock = _timeManager.StandardSteadyClock;
if (!steadyClock.IsInitialized())
{
return(ResultCode.UninitializedClock);
}
SystemClockContext otherContext = context.RequestData.ReadStruct <SystemClockContext>();
SteadyClockTimePoint currentTimePoint = steadyClock.GetCurrentTimePoint(context.Thread);
ResultCode result = ResultCode.TimeMismatch;
if (currentTimePoint.ClockSourceId == otherContext.SteadyTimePoint.ClockSourceId)
{
TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(context.Thread.Context.CntpctEl0, context.Thread.Context.CntfrqEl0);
long baseTimePoint = otherContext.Offset + currentTimePoint.TimePoint - ticksTimeSpan.ToSeconds();
context.ResponseData.Write(baseTimePoint);
result = ResultCode.Success;
}
return(result);
}
private static MidiFile ConvertCsvToMidiFile(
MidiFileCsvLayout layout,
TimeSpanType timeType,
string[] csvLines,
NoteFormat noteFormat = NoteFormat.Events,
NoteNumberFormat noteNumberFormat = NoteNumberFormat.NoteNumber,
TimeSpanType noteLengthType = TimeSpanType.Midi)
{
var filePath = Path.GetTempFileName();
File.WriteAllLines(filePath, csvLines);
var settings = new MidiFileCsvConversionSettings
{
CsvLayout = layout,
TimeType = timeType,
NoteFormat = noteFormat,
NoteNumberFormat = noteNumberFormat,
NoteLengthType = noteLengthType
};
try
{
var midiFile = new CsvConverter().ConvertCsvToMidiFile(filePath, settings);
ConvertMidiFileToFromCsv(midiFile, filePath, settings);
return(midiFile);
}
finally
{
File.Delete(filePath);
}
}
/// <summary>
/// Add a timed event to this container, if there is enough space
/// </summary>
public void AddTimedEvent(TimeSpanType type, int timeSpan, string message,
string parameter1, string parameter2)
{
for (int i = 0; i < size; i++)
{
ref var Tuple = ref events[i];
ref var Event = ref Tuple.timedEvent;
public void SetStandardSteadyClockRtcOffset(ITickSource tickSource, TimeSpanType rtcOffset)
{
StandardSteadyClock.SetSetupValue(rtcOffset);
TimeSpanType currentTimePoint = StandardSteadyClock.GetCurrentRawTimePoint(tickSource);
SharedMemory.SetSteadyClockRawTimePoint(tickSource, currentTimePoint);
}
/// <summary>
/// Converts time from one time type to another one.
/// </summary>
/// <param name="time">Time to convert.</param>
/// <param name="timeType">Type that will represent the time of an object.</param>
/// <param name="tempoMap">Tempo map used to convert <paramref name="time"/>.</param>
/// <returns>Time as an instance of time span defined by <paramref name="timeType"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="time"/> is null. -or-
/// <paramref name="tempoMap"/> is null.</exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="timeType"/> specified an invalid value.</exception>
public static ITimeSpan ConvertTo(ITimeSpan time, TimeSpanType timeType, TempoMap tempoMap)
{
ThrowIfArgument.IsNull(nameof(time), time);
ThrowIfArgument.IsInvalidEnumValue(nameof(timeType), timeType);
ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap);
return(TimeSpanConverter.ConvertTo(time, timeType, 0, tempoMap));
}
/// <summary>
/// Gets length of an <see cref="ILengthedObject"/> as an instance of type defined by the
/// specified time span type.
/// </summary>
/// <param name="obj">Object to get length of.</param>
/// <param name="lengthType">The type of time span to convert the length of <paramref name="obj"/> to.</param>
/// <param name="tempoMap">Tempo map to calculate length of the <paramref name="obj"/>.</param>
/// <returns>Time of the specified object as an instance of time span defined by the
/// <paramref name="lengthType"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="obj"/> is null. -or-
/// <paramref name="tempoMap"/> is null.</exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="lengthType"/> specified an invalid value.</exception>
public static ITimeSpan LengthAs(this ILengthedObject obj, TimeSpanType lengthType, TempoMap tempoMap)
{
ThrowIfArgument.IsNull(nameof(obj), obj);
ThrowIfArgument.IsInvalidEnumValue(nameof(lengthType), lengthType);
ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap);
return(LengthConverter.ConvertTo(obj.Length, lengthType, obj.Time, tempoMap));
}
// SetTestOffset(nn::TimeSpanType)
public ResultCode SetTestOffset(ServiceCtx context)
{
TimeSpanType testOffset = context.RequestData.ReadStruct <TimeSpanType>();
StandardSteadyClockCore.Instance.SetTestOffset(testOffset);
return(0);
}
[Command(201)] // 3.0.0-3.0.2
// SetInternalOffset(nn::TimeSpanType)
public ResultCode SetInternalOffset(ServiceCtx context)
{
TimeSpanType internalOffset = context.RequestData.ReadStruct <TimeSpanType>();
StandardSteadyClockCore.Instance.SetInternalOffset(internalOffset);
return(ResultCode.Success);
}
// SetStandardSteadyClockRtcOffset(nn::TimeSpanType rtc_offset)
public ResultCode SetStandardSteadyClockRtcOffset(ServiceCtx context)
{
TimeSpanType rtcOffset = context.RequestData.ReadStruct <TimeSpanType>();
_timeManager.SetStandardSteadyClockRtcOffset(context.Thread, rtcOffset);
return(ResultCode.Success);
}
public BufferSlot()
{
GraphicBuffer = new AndroidStrongPointer <GraphicBuffer>();
BufferState = BufferState.Free;
QueueTime = TimeSpanType.Zero;
PresentationTime = TimeSpanType.Zero;
IsPreallocated = false;
}
public void SetStandardSteadyClockRtcOffset(KThread thread, TimeSpanType rtcOffset)
{
StandardSteadyClock.SetSetupValue(rtcOffset);
TimeSpanType currentTimePoint = StandardSteadyClock.GetCurrentRawTimePoint(thread);
SharedMemory.SetSteadyClockRawTimePoint(thread, currentTimePoint);
}
/// <summary>
/// Gets time of an <see cref="ITimedObject"/> as an instance of time span defined by the
/// specified time span type.
/// </summary>
/// <param name="obj">Object to get time of.</param>
/// <param name="timeType">The type of time span to convert the time of <paramref name="obj"/> to.</param>
/// <param name="tempoMap">Tempo map to calculate time of the <paramref name="obj"/>.</param>
/// <returns>Time of the specified object as an instance of time span defined by the
/// <paramref name="timeType"/>.</returns>
/// <exception cref="ArgumentNullException">
/// <para>One of the following errors occured:</para>
/// <list type="bullet">
/// <item>
/// <description><paramref name="obj"/> is <c>null</c>.</description>
/// </item>
/// <item>
/// <description><paramref name="tempoMap"/> is <c>null</c>.</description>
/// </item>
/// </list>
/// </exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="timeType"/> specified an invalid value.</exception>
public static ITimeSpan TimeAs(this ITimedObject obj, TimeSpanType timeType, TempoMap tempoMap)
{
ThrowIfArgument.IsNull(nameof(obj), obj);
ThrowIfArgument.IsInvalidEnumValue(nameof(timeType), timeType);
ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap);
return(TimeConverter.ConvertTo(obj.Time, timeType, tempoMap));
}
public static ITimeSpan ConvertTo(ITimeSpan timeSpan, TimeSpanType timeSpanType, long time, TempoMap tempoMap)
{
if (timeSpan.GetType() == TimeSpansTypes[timeSpanType])
{
return(timeSpan.Clone());
}
return(ConvertTo(ConvertFrom(timeSpan, time, tempoMap), timeSpanType, time, tempoMap));
}
private static void ResizeNotesByRatio(IEnumerable <Note> notes,
IEnumerable <TimeAndLength> expectedTimesAndLengths,
double ratio,
TimeSpanType lengthType,
TempoMap tempoMap)
{
notes.ResizeNotes(ratio, lengthType, tempoMap);
CheckNotes(notes, expectedTimesAndLengths, tempoMap);
}
/// <summary>
/// Converts length from <see cref="long"/> to the specified length type.
/// </summary>
/// <param name="length">Length to convert.</param>
/// <param name="lengthType">Type that will represent the length of an object.</param>
/// <param name="time">Start time of an object to convert length of.</param>
/// <param name="tempoMap">Tempo map used to convert <paramref name="length"/>.</param>
/// <returns>Length as an instance of time span defined by <paramref name="lengthType"/>.</returns>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="length"/> is negative.</exception>
/// <exception cref="ArgumentNullException"><paramref name="time"/> is null. -or-
/// <paramref name="tempoMap"/> is null.</exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="lengthType"/> specified an invalid value.</exception>
public static ITimeSpan ConvertTo(long length, TimeSpanType lengthType, ITimeSpan time, TempoMap tempoMap)
{
ThrowIfLengthArgument.IsNegative(nameof(length), length);
ThrowIfArgument.IsInvalidEnumValue(nameof(lengthType), lengthType);
ThrowIfArgument.IsNull(nameof(time), time);
ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap);
return(TimeSpanConverter.ConvertTo(length, lengthType, TimeConverter.ConvertFrom(time, tempoMap), tempoMap));
}
public void SetSteadyClockRawTimePoint(ITickSource tickSource, TimeSpanType currentTimePoint)
{
SteadyClockContext context = ReadObjectFromSharedMemory <SteadyClockContext>(SteadyClockContextOffset, 4);
TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(tickSource.Counter, tickSource.Frequency);
context.InternalOffset = (ulong)(currentTimePoint.NanoSeconds - ticksTimeSpan.NanoSeconds);
WriteObjectToSharedMemory(SteadyClockContextOffset, 4, context);
}
public void SetSteadyClockRawTimePoint(KThread thread, TimeSpanType currentTimePoint)
{
SteadyClockContext context = ReadObjectFromSharedMemory <SteadyClockContext>(SteadyClockContextOffset, 4);
TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(thread.Context.CntpctEl0, thread.Context.CntfrqEl0);
context.InternalOffset = (ulong)(currentTimePoint.NanoSeconds - ticksTimeSpan.NanoSeconds);
WriteObjectToSharedMemory(SteadyClockContextOffset, 4, context);
}
// SetupStandardNetworkSystemClock(nn::time::SystemClockContext context, nn::TimeSpanType sufficient_accuracy)
public ResultCode SetupStandardNetworkSystemClock(ServiceCtx context)
{
SystemClockContext clockContext = context.RequestData.ReadStruct <SystemClockContext>();
TimeSpanType sufficientAccuracy = context.RequestData.ReadStruct <TimeSpanType>();
_timeManager.SetupStandardNetworkSystemClock(clockContext, sufficientAccuracy);
return(ResultCode.Success);
}
/// <summary>
/// Resizes group of notes to the specified length treating all notes as single object.
/// </summary>
/// <param name="notes">Notes to resize.</param>
/// <param name="length">New length of the notes collection.</param>
/// <param name="distanceCalculationType">Type of distance calculations.</param>
/// <param name="tempoMap"></param>
/// <exception cref="ArgumentNullException"><paramref name="notes"/> is null. -or-
/// <paramref name="length"/> is null. -or- <paramref name="tempoMap"/> is null.</exception>
/// <exception cref="ArgumentException"><see cref="TimeSpanType.BarBeat"/> used for <paramref name="distanceCalculationType"/>
/// with relative resizing.</exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="distanceCalculationType"/> specified an
/// invalid value.</exception>
public static void ResizeNotes(this IEnumerable <Note> notes,
ITimeSpan length,
TimeSpanType distanceCalculationType,
TempoMap tempoMap)
{
ThrowIfArgument.IsNull(nameof(notes), notes);
ThrowIfArgument.IsNull(nameof(length), length);
ThrowIfArgument.IsInvalidEnumValue(nameof(distanceCalculationType), distanceCalculationType);
ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap);
if (distanceCalculationType == TimeSpanType.BarBeat)
{
throw new ArgumentException("BarBeat length type is not supported for relative resizing.", nameof(distanceCalculationType));
}
if (!notes.Any())
{
return;
}
//
var minStartTime = long.MaxValue;
var maxEndTime = 0L;
foreach (var note in notes.Where(n => n != null))
{
var noteStartTime = note.Time;
var noteEndTime = noteStartTime + note.Length;
minStartTime = Math.Min(minStartTime, noteStartTime);
maxEndTime = Math.Max(maxEndTime, noteEndTime);
}
var totalLength = maxEndTime - minStartTime;
//
var oldLength = LengthConverter.ConvertTo(totalLength, distanceCalculationType, minStartTime, tempoMap);
var newLength = LengthConverter.ConvertTo(length, distanceCalculationType, minStartTime, tempoMap);
var ratio = TimeSpanUtilities.Divide(newLength, oldLength);
var startTime = TimeConverter.ConvertTo(minStartTime, distanceCalculationType, tempoMap);
foreach (var note in notes.Where(n => n != null))
{
var noteLength = note.LengthAs(distanceCalculationType, tempoMap);
var noteTime = note.TimeAs(distanceCalculationType, tempoMap);
var scaledShiftFromStart = noteTime.Subtract(startTime, TimeSpanMode.TimeTime).Multiply(ratio);
note.Time = TimeConverter.ConvertFrom(startTime.Add(scaledShiftFromStart, TimeSpanMode.TimeLength), tempoMap);
var scaledLength = noteLength.Multiply(ratio);
note.Length = LengthConverter.ConvertFrom(scaledLength, note.Time, tempoMap);
}
}
public void SetupStandardSteadyClock(KThread thread, UInt128 clockSourceId, TimeSpanType setupValue, TimeSpanType internalOffset, TimeSpanType testOffset, bool isRtcResetDetected)
{
SetupInternalStandardSteadyClock(clockSourceId, setupValue, internalOffset, testOffset, isRtcResetDetected);
TimeSpanType currentTimePoint = StandardSteadyClock.GetCurrentRawTimePoint(thread);
SharedMemory.SetupStandardSteadyClock(thread, clockSourceId, currentTimePoint);
// TODO: propagate IPC late binding of "time:s" and "time:p"
}
// SetStandardSteadyClockRtcOffset(nn::TimeSpanType rtc_offset)
public ResultCode SetStandardSteadyClockRtcOffset(ServiceCtx context)
{
TimeSpanType rtcOffset = context.RequestData.ReadStruct <TimeSpanType>();
ITickSource tickSource = context.Device.System.TickSource;
_timeManager.SetStandardSteadyClockRtcOffset(tickSource, rtcOffset);
return(ResultCode.Success);
}
public UtilityImpl(ITickSource tickSource)
{
_x = 123456789;
_y = 362436069;
TimeSpanType time = TimeManager.Instance.TickBasedSteadyClock.GetCurrentRawTimePoint(tickSource);
_w = (uint)(time.NanoSeconds & uint.MaxValue);
_z = (uint)((time.NanoSeconds >> 32) & uint.MaxValue);
}
/// <summary>
/// Gets the duration of the specified <see cref="MidiFile"/>. Duration is
/// defined by the time of last MIDI event of the file.
/// </summary>
/// <param name="midiFile"><see cref="MidiFile"/> to get duration of.</param>
/// <param name="durationType">The type of time span representing the duration of <paramref name="midiFile"/>.</param>
/// <returns>An implementation of <see cref="ITimeSpan"/> representing
/// duration of <paramref name="midiFile"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="midiFile"/> is <c>null</c>.</exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="durationType"/> specified an invalid value.</exception>
public static ITimeSpan GetDuration(this MidiFile midiFile, TimeSpanType durationType)
{
ThrowIfArgument.IsNull(nameof(midiFile), midiFile);
ThrowIfArgument.IsInvalidEnumValue(nameof(durationType), durationType);
var tempoMap = midiFile.GetTempoMap();
return(midiFile.GetTimedEvents().LastOrDefault()?.TimeAs(durationType, tempoMap) ??
TimeSpanUtilities.GetZeroTimeSpan(durationType));
}
/// <summary>
/// Adds a playback to the list of ones to watch current times of.
/// </summary>
/// <param name="playback">Playback to watch current time of.</param>
/// <param name="timeType">Type of current time to convert to.</param>
/// <exception cref="ArgumentNullException"><paramref name="playback"/> is <c>null</c>.</exception>
/// <exception cref="InvalidEnumArgumentException"><paramref name="timeType"/> specified an invalid value.</exception>
/// <exception cref="ObjectDisposedException">The current <see cref="PlaybackCurrentTimeWatcher"/>
/// is disposed.</exception>
public void AddPlayback(Playback playback, TimeSpanType timeType)
{
ThrowIfArgument.IsNull(nameof(playback), playback);
ThrowIfArgument.IsInvalidEnumValue(nameof(timeType), timeType);
EnsureIsNotDisposed();
lock (_playbacksLock)
{
_playbacks[playback] = timeType;
}
}
private TypeScriptType GetTypeScriptType(Type type)
{
TypeScriptType tst;
if (TypeHelper.Is(type, typeof(string)))
{
tst = new StringType();
}
else if (TypeHelper.Is(type, typeof(bool)))
{
tst = new BooleanType();
}
else if (TypeHelper.Is(type, typeof(int),
typeof(decimal),
typeof(double),
typeof(long),
typeof(float),
typeof(short),
typeof(byte),
typeof(uint),
typeof(ushort),
typeof(ulong),
typeof(sbyte)
))
{
tst = new NumberType();
}
else if (TypeHelper.Is(type, typeof(DateTime)))
{
tst = new DateTimeType();
}
else if (TypeHelper.Is(type, typeof(TimeSpan)))
{
tst = new TimeSpanType();
}
else if (type.IsGenericParameter)
{
tst = new GenericTypeParameter();
}
else if (TypeHelper.IsDictionary(type))
{
tst = new DictionaryType();
}
else if (TypeHelper.IsEnumerable(type))
{
tst = new ArrayType();
}
else if (TypeHelper.IsEnum(type))
{
tst = new EnumType();
}
else
{
var processType = _options.TypeFilter(type);
if (processType)
{
if (type.IsInterface)
{
tst = new InterfaceType(type);
}
else
{
tst = new CustomType(type);
}
}
else
{
tst = new AnyType();
}
}
if (TypeHelper.IsNullableValueType(type))
{
((ValueType)tst).IsNullable = true;
type = Nullable.GetUnderlyingType(type);
}
tst.ClrType = type;
return tst;
}
