public Parameter(AmpAverageTest.Arguments arguments, IGeneratorContext context)
{
this.arguments = arguments;
this.context = context;
InitializeComponent();
}
protected override void ConfigureContext(IGeneratorContext context)
{
// Do nothing. Calling base will add all values into InputElements, which means EVERYTHING is checked to be
// implemented, which never makes sense for our list of event functions.
// This base class is essentially for a Quick Fix that is to implement missing members, while we're really
// using it like a Context Action
}
public Generator(IGeneratorContext context) : base(context)
{
FileStrategies = new Dictionary <SchemeGeneratePlace, IGeneratorFileStrategy>
{
{ SchemeGeneratePlace.SeparatedFile, new SeparateFileStrategy(GeneratorContext, GeneratorSettings) },
{ SchemeGeneratePlace.WithCode, new SingleFileStrategy(GeneratorContext, GeneratorSettings) },
{ SchemeGeneratePlace.AllSeparated, new AllSeparatedFileStrategy(GeneratorContext, GeneratorSettings) }
};
}
void IGeneratorEnumerator.Init(IGeneratorContext context)
{
Guard.ArgumentNotNull(context, "context");
this.context = context;
this.stack = new List <IGeneratorEnumerator>()
{
this
};
}
public override bool Validate(AmpAverageTest.Arguments argumentPackage, IGeneratorContext context, out string errorMessage)
{
errorMessage = "N/A";
// TODO: Please implement the validation logic for the argumentPackage.
// return true, when the given argumentPackage is valid.
// return false, and fill the errorMessage when the given argumentPackage is not valid.
return(true);
}
protected override void ConfigureContext(IGeneratorContext context)
{
// Don't call base. This will add all values into InputEvents which means all items are checked in the list.
// This is useful for a Quick Fix that is implementing missing members, but we're more of a Context Action.
// Try and set the anchor for where we want to generate the new members, if we have one
if (context is CSharpGeneratorContext csharpContext)
{
csharpContext.Anchor = myAnchor;
}
}
public object Generate(Type targetType, IGeneratorContext generatorContext)
{
var str = new StringBuilder();
var rand = new Random();
for (int i = 0; i < rand.Next(1, 50); i++)
{
str.Append((char)rand.Next(1, 255));
}
return(str.ToString());
}
public object Generate(Type targetType, IGeneratorContext generatorContext)
{
var result = (IList)Activator.CreateInstance(targetType);
var rand = new Random();
int elements = rand.Next(1, 5);
var listType = targetType.GetGenericArguments()[0];
//var addMethod = targetType.GetMethod("Add");
for (int i = 0; i < elements; i++)
{
var faker = new Faker(generatorContext);
result.Add(faker.Create(listType));
//addMethod.Invoke(result, new object[] { faker.Create(listType) });
}
return(result);
}
public object Generate(Type targetType, IGeneratorContext generatorContext)
{
var rand = new Random();
return((float)(rand.NextDouble() * (1 - 0.1) + 0.1));
}
public object Generate(Type targetType, IGeneratorContext generatorContext)
{
var rand = new Random();
return(rand.Next(1, 100));
}
public Faker(IGeneratorContext generatorContext)
{
_context = generatorContext;
_types = new Stack <Type>();
}
public void Init(IGeneratorContext context)
{
Guard.ArgumentNotNull(context, "context");
this.Context = context;
}
public object Generate(Type targetType, IGeneratorContext generatorContext)
{
var rand = new Random();
return(new DateTime(rand.Next(1950, 2021), rand.Next(1, 13), rand.Next(1, 32), rand.Next(0, 24), rand.Next(0, 60), rand.Next(0, 60)));
}
public MinimisingGenerator(IGeneratorContext context) : base(context)
{
}
public override SeismicAttributeInfo CreateSeismicAttributeInfo(AmpAverageTest.Arguments argumentPackage, IGeneratorContext context)
{
IList <Slb.Ocean.Petrel.DomainObject.Template> templates = new List <Slb.Ocean.Petrel.DomainObject.Template>();
IList <Range1 <float> > ranges = new List <Range1 <float> >();
templates.Add(Slb.Ocean.Petrel.DomainObject.Template.NullObject);
ranges.Add(new Range1 <float>(float.NaN, float.NaN));
return(new SeismicAttributeInfo(
templates,
ranges,
new Index3(1, 1, 1),
BorderProcessingMethod.Repeat));
}
public void Populate(IGeneratorContext context)
{
context.InputElements.AddRange(context.ProvidedElements.OfType <GeneratorDeclaredElement>()
.Where(e => myInputElements.Contains(e.DeclaredElement.ShortName)));
}
protected readonly GeneratorSettings GeneratorSettings = new GeneratorSettings(); // set up default options
protected GeneratorTemplate(IGeneratorContext context)
{
GeneratorContext = context;
}
private static ITypeElement GetDisposableInterface(IGeneratorContext context)
{
// retrieve ITypeElement for System.IDisposable interface, visible in current project
return(TypeFactory.CreateTypeByCLRName("System.IDisposable", context.PsiModule, context.Anchor.GetResolveContext()).GetTypeElement());
}
protected ContextDependedFileStrategy(IGeneratorContext context, GeneratorSettings settings)
{
Context = context;
Settings = settings;
}
private static ITypeElement GetDisposableInterface(IGeneratorContext context)
{
return(TypeFactory.CreateTypeByCLRName("System.IDisposable", context.PsiModule).GetTypeElement());
}
protected override IEnumerable <string> GetOutputLabels(AmpAverageTest.Arguments argumentPackage, IGeneratorContext context)
{
yield return("Output");
}
protected override void GenerateInternal(IRosvitaRuntime runtime, IConfiguration configuration, IGeneratorContext context, IGeneratorMessageCollection messages)
{
var project = runtime.Project.Current;
if (project == null)
{
throw new XamlaException("Project must not be null.", XamlaError.ArgumentNull);
}
// find matching components for this generator
var deviceConfigurations = configuration.Where(x => x.ConfigurationType == Configuration.ConfigurationType)
.OfType <IStandardComponent>()
.Select(x => (Configuration)x.GetConfiguration())
.Where(x => x.Enabled)
.ToList();
foreach (var device in deviceConfigurations)
{
LaunchFileDocument launchFile = GenerateLaunchFile(device);
string launchFilename = $"sample_device_{device.Name}.launch";
string launchTempFilePath = Path.Combine(context.TempOutputDirecotry, launchFilename);
string launchFilePath = Path.Combine(context.FinalOutputDirecotry, launchFilename);
launchFile.Save(launchTempFilePath);
context.LaunchFilesToInclude.Add(launchFilePath);
if (device.EnableSystemMonitoring)
{
context.SysMonElements.Add(new SystemMonitorNode {
Name = device.Name, Timeout = Math.Max(2.0, 2.0 / device.Rate), Type = SystemMonitorNodeType.Heartbeat
});
}
messages.AddInfo(this, $"Launch file'{project.MakeRelative(launchFilePath)}' written.");
}
}
/// <summary>
/// Parameterized constructor to set argument package and generator context
/// </summary>
/// <param name="arguments">Argument package</param>
/// <param name="context">Generator context</param>
public Generator(AmpAverageTest.Arguments arguments, IGeneratorContext generatorContext)
{
this.arguments = arguments;
this.generatorContext = generatorContext;
}
public SeparateFileStrategy(IGeneratorContext context, GeneratorSettings settings) : base(context, settings)
{
}
protected override System.Windows.Forms.Control CreateUI(AmpAverageTest.Arguments argumentPackage, IGeneratorContext context)
{
System.Windows.Forms.Control control = new Parameter(argumentPackage, context);
return(control);
}
/// <inheritdoc />
/// <remarks>
/// Calls abstract GetNextInstance() to build a tree of nodes until a given number of layouts is generated.
/// </remarks>
public List <TLayout> Generate(TLayout initialLayout, int count, int chainsCount, LayoutGeneratorFunction <TLayout> layoutGeneratorFunc, IGeneratorContext context)
{
// Initialization
this.initialLayout = initialLayout;
rows = new List <NodeRow>();
log = new List <LogEntry>();
nextId = 0;
this.layoutGeneratorFunc = layoutGeneratorFunc;
var layouts = new List <TLayout>();
BeforeGeneration();
AddZeroLevelNode();
while (layouts.Count < count)
{
if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
{
break;
}
if (context.IterationsCount > 1000000)
{
break;
}
// Gets next instance to be extended
var instance = GetNextInstance(rows);
var newDepth = instance.Depth + 1;
// The chosen instance must not be already finished
if (instance.IsFinished)
{
throw new InvalidOperationException();
}
// Tries to generate a new layout from the instance
var iterationsBefore = context.IterationsCount;
var hasLayout = instance.TryGetLayout(out var layout);
var iterationsToGenerate = context.IterationsCount - iterationsBefore;
instance.AddIterations(iterationsToGenerate);
// Layout being null means failure and the current iteration is skipped
if (!hasLayout)
{
log.Add(new LogEntry(LogType.Fail, instance, iterationsToGenerate));
continue;
}
// Check if the layout has already all the chains added
if (newDepth == chainsCount)
{
OnLayoutGenerated?.Invoke(layout);
layouts.Add(layout);
log.Add(new LogEntry(LogType.Final, instance, iterationsToGenerate));
AfterValid();
continue;
}
// A new instance is created from the generated layout and added to the tree.
var nextInstance = new Node(instance, GetLayouts(layout, newDepth), newDepth, iterationsToGenerate, nextId++);
instance.AddChild(nextInstance);
AddNode(nextInstance, newDepth);
log.Add(new LogEntry(LogType.Success, nextInstance, iterationsToGenerate));
}
AfterGeneration();
return(layouts);
}
public override SeismicAttributeGenerator CreateAttributeGenerator(AmpAverageTest.Arguments argumentPackage, IGeneratorContext context)
{
return(new AmpAverageTest.Generator(argumentPackage, context));
}
