private static IStateMachineBuilder GetClassifierBuilder(IEnumerable <WordWithValue> language)
{
var builder = new ClassifierBuilder();
builder.SetLanguage(language);
return(builder);
}
/// <summary>
/// Creates a file with all arrangements in the order that is used for the alphabet of the classifier.
/// </summary>
public IEnumerable <IList <Arrangement> > Create()
{
var orderedPath = Path.Combine(_workingDirectory, "OrderedArrangements.txt");
if (File.Exists(orderedPath))
{
return(File.ReadAllLines(orderedPath).Select(Arrangement.MultipleFromString).Select(a => a.ToList()));
}
var words = new ArrangementWordCreator(_workingDirectory).CreateUnordered();
var classifierBuilder = new ClassifierBuilder();
classifierBuilder.SetLanguage(words);
var nullTransitions = CountNullTransitions(classifierBuilder);
var ordered = nullTransitions.Select((n, i) => new { n, i }).OrderBy(p => p.n).Select(p => p.i).ToList();
var oldArrangements = new CompactAnalyzedDataCreator(_workingDirectory).GetUniqueArrangements().ToList();
var newArrangements = ordered.Select(i => oldArrangements[i]).ToList();
var lines = newArrangements.Select(a => string.Join("", a)).ToList();
File.WriteAllLines(orderedPath, lines);
return(newArrangements);
}
public static IEnumerable <ClassifierBuilder> MBaseClassifiers(this ClassifierBuilder cls)
{
var result = new HashSet <ClassifierBuilder>();
result.UnionWith(cls.MModel.Objects.MOfType <RealizationBuilder>().Where(d => d.Client.Contains(cls)).SelectMany(d => d.Supplier).OfType <ClassifierBuilder>());
result.UnionWith(cls.MModel.Objects.MOfType <GeneralizationBuilder>().Where(d => d.Specific == cls).Select(d => d.General).OfType <ClassifierBuilder>());
return(result);
}
public static IEnumerable <ClassifierBuilder> MAllBaseClassifiers(this ClassifierBuilder cls)
{
var result = new List <ClassifierBuilder>();
result.AddRange(cls.MBaseClassifiers());
for (int i = 0; i < result.Count; i++)
{
var baseCls = result[i];
foreach (var ancestorCls in baseCls.MBaseClassifiers())
{
if (!result.Contains(ancestorCls))
{
result.Add(ancestorCls);
}
}
}
return(result);
}
public IEnumerable <int> Create()
{
var path = Path.Combine(_workingDirectory, "UnweightedSuitTransitions.txt");
if (File.Exists(path))
{
return(File.ReadAllLines(path).Select(line => Convert.ToInt32(line, CultureInfo.InvariantCulture)));
}
var language = new CompactAnalyzedDataCreator(_workingDirectory).CreateSuitWords();
var fullLanguage = CreateFullLanguage(language);
var builder = new ClassifierBuilder();
builder.SetLanguage(fullLanguage, 5, 19);
var transitions = builder.Transitions;
var lines = transitions.Select(t => t.ToString(CultureInfo.InvariantCulture));
File.WriteAllLines(path, lines);
return(transitions);
}
public IEnumerable <int> Create()
{
var transitionsPath = Path.Combine(_workingDirectory, "TenpaiShapeTransitions.txt");
var valuesPath = Path.Combine(_workingDirectory, "TenpaiShapeValues.txt");
if (File.Exists(transitionsPath))
{
return(File.ReadAllLines(transitionsPath).Select(line => Convert.ToInt32(line, CultureInfo.InvariantCulture)));
}
var language = CreateLanguage().ToList();
var builder = new ClassifierBuilder();
builder.SetLanguage(language, 5, 9);
File.WriteAllLines(transitionsPath, builder.Transitions.Select(t => t.ToString(CultureInfo.InvariantCulture)));
File.WriteAllLines(valuesPath, _indexedValues.OrderBy(p => p.Value).Select(p => p.Key.ToString(CultureInfo.InvariantCulture)));
return(builder.Transitions);
}
public static IEnumerable <OperationBuilder> MAllOperations(this ClassifierBuilder cls)
{
var result = new List <OperationBuilder>();
if (cls is ClassBuilder @class)
{
result.AddRange(@class.OwnedOperation);
}
else if (cls is InterfaceBuilder intf)
{
result.AddRange(intf.OwnedOperation);
}
var allBaseClassifiers = cls.MAllBaseClassifiers().ToList();
foreach (var baseClassifier in allBaseClassifiers)
{
if (baseClassifier is InterfaceBuilder baseIntf)
{
foreach (var op in baseIntf.OwnedOperation)
{
if (!result.Contains(op))
{
result.Add(op);
}
}
}
if (baseClassifier is ClassBuilder baseCls)
{
foreach (var op in baseCls.OwnedOperation)
{
if (!result.Contains(op))
{
result.Add(op);
}
}
}
}
return(result);
}
public static OperationBuilder MResolveOperationBySignature(this ClassifierBuilder cls, string signature)
{
if (cls == null || signature == null)
{
return(null);
}
string operationName = signature;
var argNames = new List <string>();
int openParenIndex = signature.IndexOf('(');
if (openParenIndex > 0)
{
operationName = signature.Substring(0, openParenIndex);
var argList = signature.Substring(openParenIndex + 1);
int closeParenIndex = argList.IndexOf(')');
if (closeParenIndex > 0)
{
argList = argList.Substring(0, closeParenIndex);
int state = 0;
var argName = new StringBuilder();
foreach (var ch in argList)
{
if (state == 0)
{
if (ch == ',')
{
argNames.Add(argName.ToString());
argName.Clear();
}
else if (ch == '"')
{
argName.Append(ch);
state = 1;
}
else
{
argName.Append(ch);
}
}
else
{
argName.Append(ch);
if (ch == '"')
{
state = 0;
}
}
}
if (argName.Length > 0 || argNames.Count > 0)
{
argNames.Add(argName.ToString());
}
}
}
List <OperationBuilder> operations = cls.MAllOperations().Where(op => operationName.Equals(op.Name, StringComparison.InvariantCultureIgnoreCase)).ToList();
if (operations != null && operations.Count > 0)
{
if (operations.Count > 1)
{
operations = operations.Where(op => op.OwnedParameter.Where(p => p.Direction != ParameterDirectionKind.Return).Count() == argNames.Count).ToList();
}
if (operations.Count > 0)
{
return(operations[0]);
}
}
return(null);
}
