public static bool OnBeatExclusive(this BeatObserver beat, SynchronizerData.BeatType type = BeatType.OnBeat)
{
if ((beat.beatMask & type) == type) {
return true;
} else {
return false;
}
}
protected SynchronizerData GetSynchronizerData(Vertex vertex)
{
SynchronizerData sd = (SynchronizerData)Synchronizers[vertex.Synchronizer];
if (sd == null)
{
sd = new SynchronizerData(vertex.Synchronizer);
Synchronizers.Add(vertex.Synchronizer, sd);
}
return(sd);
}
/// <summary>
/// Recursively traverses forward from a given vertex, adding the earliest-possible
/// arrival time to each vertex as it goes.
/// </summary>
/// <param name="vertex">the vertex forward from which we will probe.</param>
/// <param name="elapsedTime">the current elapsed time.</param>
protected void ProbeForward(Vertex vertex, long elapsedTime)
{
if (s_diagnostics)
{
_Debug.WriteLine(new DateTime(elapsedTime) + " : Probing forward to vertex " + vertex.Name + " at " + string.Format("{0:f2}", TimeSpan.FromTicks(elapsedTime).TotalMinutes));
}
if (VertexPegs != null && VertexPegs.Contains(vertex))
{
elapsedTime = (long)VertexPegs[vertex];
}
IList nextEdges;
VertexData vertexData = GetVertexData(vertex);
if (vertex.Synchronizer == null)
{
if (elapsedTime > vertexData.Earliest)
{
vertexData.Earliest = elapsedTime;
}
nextEdges = vertexData.GetNextEdgesForward();
}
else // There is a synchronizer.
{
SynchronizerData sd = GetSynchronizerData(vertex);
sd.RegisterForwardVisit(vertex, elapsedTime);
nextEdges = sd.NextEdgesForward(Vertices, ref elapsedTime); // PCB: Propagates earlier time?
}
if (s_diagnostics)
{
_Debug.WriteLine(vertex.Name + " earliest " + string.Format("{0:f2}", (new TimeSpan(vertexData.Earliest).TotalMinutes)));
}
m_traceStack.Push(vertex);
foreach (Edge edge in nextEdges)
{
EdgeData edgeData = GetEdgeData(edge);
if (edge is ISupportsCpmAnalysis)
{
edgeData.NominalDuration = ((ISupportsCpmAnalysis)edge).GetNominalDuration().Ticks;
}
if (s_diagnostics)
{
_Debug.WriteLine("From vertex " + vertex.Name + ", we look forward " + TimeSpan.FromTicks(edgeData.NominalDuration) + " to " + edge.PostVertex.Name + ".");
}
ProbeForward(edge.PostVertex, vertexData.Earliest + edgeData.NominalDuration);
}
Debug.Assert(m_traceStack.Pop() == vertex);
}
protected virtual void Dispose(SynchronizerData value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
try
{
value.Dispose();
}
catch (ObjectDisposedException)
{
if (_disposed)
{
throw;
}
}
}
public PathSynchronizer(string firstPath,
string fileFilter,
string secondPath,
bool includeSubdirectories = true,
string[] excludeSubDirectories = null,
string[] excludeFileExtensions = null,
int sysnchronizeDelayInMin = 60)
{
if (string.IsNullOrWhiteSpace(firstPath))
{
throw new ArgumentException(nameof(firstPath));
}
if (string.IsNullOrWhiteSpace(fileFilter))
{
throw new ArgumentException(nameof(fileFilter));
}
if (string.IsNullOrWhiteSpace(secondPath))
{
throw new ArgumentException(nameof(secondPath));
}
if (Directory.Exists(firstPath) == false)
{
Directory.CreateDirectory(firstPath);
}
if (Directory.Exists(secondPath) == false)
{
Directory.CreateDirectory(secondPath);
}
Data = new SynchronizerData(firstPath, fileFilter, secondPath, includeSubdirectories)
IncludeSubdirectories = includeSubdirectories;
_excludeSubDirectories.Add(StorageInfoFolder);
_excludeSubDirectories.AddRange(excludeSubDirectories ?? new string[0]);
_excludeFileExtensions.AddRange(excludeFileExtensions ?? new string[0]);
SynchronizeDelay = sysnchronizeDelayInMin * 1000;
}
/// <summary>
/// Recursively traverses backward from a given vertex, adding the latest-possible
/// arrival time to each vertex as it goes.
/// </summary>
/// <param name="vertex">The vertex from which the backward probing is to be done.</param>
/// <param name="elapsedTime">The time that has elapsed thus far in the backward traversal.</param>
protected void ProbeBackward(Vertex vertex, long elapsedTime)
{
string fromVertexName = m_traceStack.Count > 0?((Vertex)m_traceStack.Peek()).Name:"<root>";
// if ( vertex.Name.Equals("D : Sample4:Post") ) {
// Console.WriteLine("Tracing back to " + vertex.Name + " from ... ");
// foreach ( Vertex v in m_traceStack ) {
// Console.WriteLine("\t\t" + v.Name);
// }
// }
if (s_diagnostics)
{
Trace.Write(new DateTime(elapsedTime) + " : Probing backward from " + fromVertexName + " to vertex " + vertex.Name + " at "
+ string.Format("{0:f2}", TimeSpan.FromTicks(elapsedTime).TotalMinutes));
}
if (VertexPegs != null && VertexPegs.Contains(vertex))
{
elapsedTime = (long)VertexPegs[vertex];
}
IList nextEdges;
VertexData vertexData = GetVertexData(vertex);
if (vertex.Synchronizer == null)
{
if (elapsedTime < vertexData.Latest)
{
vertexData.Latest = elapsedTime;
}
nextEdges = vertexData.GetNextEdgesReverse();
if (s_diagnostics)
{
_Debug.WriteLine(nextEdges.Count > 0?" - authorized to proceed.":" - this vertex is not yet satisfied (" + vertexData.RevSatStatus + ").");
}
}
else
{
SynchronizerData sd = GetSynchronizerData(vertex);
if (vertexData.GetNextEdgesReverse().Count > 0)
{
sd.RegisterBackwardVisit(vertex, elapsedTime);
}
nextEdges = sd.NextEdgesBackward(Vertices, ref elapsedTime);
if (s_diagnostics)
{
_Debug.WriteLine(nextEdges.Count > 0?" - synchronizer authorized us to proceed.":" - this vertex has a synchronizer that is not yet satisfied.");
}
}
if (s_diagnostics)
{
_Debug.WriteLine("Setting " + vertex.Name + " latest to " + string.Format("{0:f2}", TimeSpan.FromTicks(elapsedTime).TotalMinutes));
}
m_traceStack.Push(vertex);
foreach (Edge edge in nextEdges)
{
EdgeData edgeData = (EdgeData)Edges[edge];
if (edgeData == null)
{
edgeData = new EdgeData(edge);
Edges.Add(edge, edgeData);
}
if (edge is ISupportsCpmAnalysis)
{
edgeData.NominalDuration = ((ISupportsCpmAnalysis)edge).GetNominalDuration().Ticks;
}
ProbeBackward(edge.PreVertex, vertexData.Latest - edgeData.NominalDuration);
}
Debug.Assert(m_traceStack.Pop() == vertex);
}
