public static UniTemplate GetInstance(TemplateInstanceType type, string evnt)
{
return(type switch
{
TemplateInstanceType.Init => new Init(evnt),
_ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
});
/// <summary>
/// </summary>
/// <param name="template"></param>
/// <returns>Return category into which template belongs.</returns>
/// <exception cref="Exception"></exception>
public static TemplateBookType GetTemplateBookType(this TemplateInstanceType template)
{
switch (template)
{
case TemplateInstanceType.Init:
case TemplateInstanceType.Exactly:
case TemplateInstanceType.Existence:
case TemplateInstanceType.Absence:
return(TemplateBookType.Existential);
case TemplateInstanceType.AlternatePrecedence:
case TemplateInstanceType.AlternateResponse:
case TemplateInstanceType.AlternateSuccession:
case TemplateInstanceType.ChainPrecedence:
case TemplateInstanceType.ChainResponse:
case TemplateInstanceType.ChainSuccession:
case TemplateInstanceType.Coexistence:
case TemplateInstanceType.Precedence:
case TemplateInstanceType.RespondedExistence:
case TemplateInstanceType.Response:
case TemplateInstanceType.Succession:
return(TemplateBookType.Relational);
case TemplateInstanceType.NotChainSuccession:
case TemplateInstanceType.NotCoexistence:
case TemplateInstanceType.NotSuccession:
return(TemplateBookType.NotRelational);
default:
throw new Exception("Wrong enum type");
}
}
/// <summary>
/// </summary>
/// <param name="template"></param>
/// <returns>Template type of specific instance type</returns>
public static TemplateTypes GetTemplateType(this TemplateInstanceType template)
{
switch (template)
{
case TemplateInstanceType.Init:
return(TemplateTypes.UniTemplate);
case TemplateInstanceType.Exactly:
case TemplateInstanceType.Existence:
case TemplateInstanceType.Absence:
return(TemplateTypes.Existence);
case TemplateInstanceType.AlternatePrecedence:
case TemplateInstanceType.AlternateResponse:
case TemplateInstanceType.AlternateSuccession:
case TemplateInstanceType.ChainPrecedence:
case TemplateInstanceType.ChainResponse:
case TemplateInstanceType.ChainSuccession:
case TemplateInstanceType.Coexistence:
case TemplateInstanceType.NotChainSuccession:
case TemplateInstanceType.NotCoexistence:
case TemplateInstanceType.NotSuccession:
case TemplateInstanceType.Precedence:
case TemplateInstanceType.RespondedExistence:
case TemplateInstanceType.Response:
case TemplateInstanceType.Succession:
return(TemplateTypes.BiTemplate);
default:
return(TemplateTypes.None);
}
}
public CreateTemplateWrap(string eventA, string eventB, TemplateInstanceType templateInstanceType,
TemplateTypes templateTypes)
{
EventA = eventA;
EventB = eventB;
TemplateInstanceType = templateInstanceType;
TemplateTypes = templateTypes;
}
public CreateTemplateWrap(string eventA, int occurrences, TemplateInstanceType templateInstanceType,
TemplateTypes templateTypes)
{
EventA = eventA;
Occurrences = occurrences;
TemplateInstanceType = templateInstanceType;
TemplateTypes = templateTypes;
}
public ParametrizedTemplate(TemplateInstanceType template, List <ITemplate> templateInstances, decimal poe = 100,
decimal poi = 100)
{
TemplateDescription = template.GetTemplateDescription();
TemplateInstances = templateInstances;
Poe = UtilMethods.CutIntoRange(poe, 1);
Poi = UtilMethods.CutIntoRange(poi, 1);
}
public static ExistenceTemplate GetInstance(TemplateInstanceType type, int amount, string evnt)
{
return(type switch
{
TemplateInstanceType.Absence => new Absence(amount, evnt),
TemplateInstanceType.Exactly => new Exactly(amount, evnt),
TemplateInstanceType.Existence => new Existence(amount, evnt),
_ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
});
public ParametrizedTemplate(List <ITemplate> templateInstances, TemplateInstanceType templateType,
decimal poe = 100, decimal poi = 100, bool checkVacuously = false)
{
TemplateInstances = templateInstances;
Poe = UtilMethods.CutIntoRange(poe, 1);
Poi = UtilMethods.CutIntoRange(poi, 1);
CheckVacuously = checkVacuously;
TemplateDescription = templateType.GetTemplateDescription();
}
public TemplateDescription(string readableName, string type, string description, string ltlExpression,
string activations, TemplateInstanceType templateType)
{
ReadableName = readableName;
Type = type;
Description = description;
LtlExpression = ltlExpression;
Activations = activations;
TemplateType = templateType;
TemplateCategory = templateType.GetTemplateBookType();
TemplateParametersType = templateType.GetTemplateType();
}
public static BiTemplate GetInstance(TemplateInstanceType type, string evnt1, string evnt2)
{
return(type switch
{
TemplateInstanceType.AlternatePrecedence => new AlternatePrecedence(evnt1, evnt2),
TemplateInstanceType.AlternateResponse => new AlternateResponse(evnt1, evnt2),
TemplateInstanceType.AlternateSuccession => new AlternateSuccession(evnt1, evnt2),
TemplateInstanceType.ChainPrecedence => new ChainPrecedence(evnt1, evnt2),
TemplateInstanceType.ChainResponse => new ChainResponse(evnt1, evnt2),
TemplateInstanceType.ChainSuccession => new ChainSuccession(evnt1, evnt2),
TemplateInstanceType.Coexistence => new Coexistence(evnt1, evnt2),
TemplateInstanceType.NotChainSuccession => new NotChainSuccession(evnt1, evnt2),
TemplateInstanceType.NotCoexistence => new NotCoexistence(evnt1, evnt2),
TemplateInstanceType.NotSuccession => new NotSuccession(evnt1, evnt2),
TemplateInstanceType.Precedence => new Precedence(evnt1, evnt2),
TemplateInstanceType.RespondedExistence => new RespondedExistence(evnt1, evnt2),
TemplateInstanceType.Response => new Response(evnt1, evnt2),
TemplateInstanceType.Succession => new Succession(evnt1, evnt2),
_ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
});
public CreateTemplateWrap(TemplateInstanceType templateInstanceType, TemplateTypes templateTypes)
{
TemplateInstanceType = templateInstanceType;
TemplateTypes = templateTypes;
}
public TemplateConverter(TemplateInstanceType type)
{
_type = type;
}
/// <summary>
/// Returns detailed template description based on on template instance type.
/// </summary>
/// <param name="template">Template type</param>
/// <returns>Template description</returns>
/// <exception cref="Exception">When enum out of defined range is passed</exception>
public static TemplateDescription GetTemplateDescription(this TemplateInstanceType template)
{
switch (template)
{
case TemplateInstanceType.Init:
return(new TemplateDescription(
"Init(A, B)",
"Existential",
"A is the first to occur",
"A",
"A",
template));
case TemplateInstanceType.Exactly:
return(new TemplateDescription(
"Exactly(n, A)",
"Existential",
"A occurs exactly n times",
"existence(n, A) && absence(n + 1, A)",
"A",
template));
case TemplateInstanceType.Existence:
return(new TemplateDescription(
"Existence(n, B)",
"Existential",
"A occurs at least n times",
"◇(A && ◯(Existence(n-1, A)))\n◇(A)",
"A",
template));
case TemplateInstanceType.Absence:
return(new TemplateDescription(
"Absence(n, B)",
"Relational",
"A occurs at most n - 1 times",
"!existence(n, A)",
"A",
template));
case TemplateInstanceType.RespondedExistence:
return(new TemplateDescription(
"Responded Existence(A, B)",
"Relational",
"A is the first to occur",
"A",
"A",
template));
case TemplateInstanceType.Precedence:
return(new TemplateDescription(
"Precedence(A, B)",
"Relational",
"B occurs only if preceded by A",
"(!B U A) || subsequent(!B)",
"B",
template));
case TemplateInstanceType.Response:
return(new TemplateDescription(
"Response(A, B)",
"Relational",
"If A occurs, then B occurs after A",
"subsequent(A => eventual(B))",
"A",
template));
case TemplateInstanceType.Succession:
return(new TemplateDescription(
"Succession(A, B)",
"Relational",
"A occurs if and only if B occurs after A",
"response(A, B) && precedence(A, B)",
"A, B",
template));
case TemplateInstanceType.AlternatePrecedence:
return(new TemplateDescription(
"Alternate Precedence(A, B)",
"Relational",
"Each time B occurs, it is preceded by A and no other B can recur in between",
"precedence(A, B) && subsequent(B => next(precedence(A, B)))",
"B",
template));
case TemplateInstanceType.AlternateResponse:
return(new TemplateDescription(
"Alternate Response(A, B)",
"Relational",
"Each time A occurs, then B occurs afterwards, before A recurs",
"subsequent(A => next(!A U B))",
"A",
template));
case TemplateInstanceType.AlternateSuccession:
return(new TemplateDescription(
"Alternate Succession(A, B)",
"Relational",
"A and B occur if and only if the latter follows the former, and they alternate each other",
"AlternateResponse(A, B) && AlternatePrecedence(A, B)",
"A, B",
template));
case TemplateInstanceType.ChainPrecedence:
return(new TemplateDescription(
"Chain Precedence(A, B)",
"Relational",
"Each time B occurs, then A occurs immediately before",
"subsequent(next(B) => A)",
"B",
template));
case TemplateInstanceType.ChainResponse:
return(new TemplateDescription(
"Chain Response(A, B)",
"Relational",
"Each time A occurs, then B occurs immediately after ",
"subsequent(A => next(B))",
"A",
template));
case TemplateInstanceType.ChainSuccession:
return(new TemplateDescription(
"Chain Succession(A, B)",
"Relational",
"A and B occur if and only if the latter immediately follows the former",
"subsequent(A <=> next(B))",
"A, B",
template));
case TemplateInstanceType.Coexistence:
return(new TemplateDescription(
"Coexistence(A, B)",
"Relational",
"If B occurs, then A occurs, and vice versa",
"eventual(A) <=> eventual(B)",
"A, B",
template));
case TemplateInstanceType.NotChainSuccession:
return(new TemplateDescription(
"Not Chain Succession(A, B)",
"Not Relational",
"A and B occur if and only if the latter does not immediately follow the former ",
"subsequent(A => next(!B))",
"A, B",
template));
case TemplateInstanceType.NotCoexistence:
return(new TemplateDescription(
"Not Coexistence(A, B)",
"Not Relational",
"A and B never occur together ",
"!(eventual(A) && eventual(B))",
"A, B",
template));
case TemplateInstanceType.NotSuccession:
return(new TemplateDescription(
"Not Succession(A, B)",
"Not Relational",
"A never occurs before B ",
"subsequent(A => !eventual(B))",
"A, B",
template));
default:
throw new Exception("Wrong enum type");
}
}
public ParametrizedTemplate(TemplateInstanceType template, decimal poe = 100, decimal poi = 100) : this(
template, new List <ITemplate>(), poe, poi)
{
}
