public static PropertyDeclarationSyntax?Generate(IHandleTypeNamedWrapper handle, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Nullability currentNullability, int level)
{
if (!(handle is PropertyWrapper property))
{
return(null);
}
var accessorList = new List <AccessorDeclarationSyntax>(2);
if (property.Getter != null && property.Getter.ShouldIncludeEntityAccessibility())
{
accessorList.Add(AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, GeneratorFactory.Generate(property.Getter.Attributes, excludeMembersAttributes, excludeAttributes), property.Getter.GetModifiers(property)));
}
if (property.Setter != null && property.Setter.ShouldIncludeEntityAccessibility())
{
accessorList.Add(AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, GeneratorFactory.Generate(property.Setter.Attributes, excludeMembersAttributes, excludeAttributes), property.Setter.GetModifiers(property)));
}
property.Attributes.TryGetNullable(out var nullability);
var returnType = property.ReturnType.GetTypeSyntax(property, currentNullability, nullability);
return(PropertyDeclaration(returnType, property.Name, GeneratorFactory.Generate(property.Attributes, excludeMembersAttributes, excludeAttributes), property.GetModifiers(), accessorList, level));
}
public static ParameterSyntax?Generate(IHandleNameWrapper nameWrapper, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Nullability currentNullability, bool isExtensionMethod)
{
if (!(nameWrapper is ParameterWrapper parameterWrapper))
{
return(null);
}
EqualsValueClauseSyntax?equals = null;
if (parameterWrapper.HasDefaultValue)
{
var valueSyntax = SyntaxHelper.GetValueExpression(parameterWrapper.ParameterType, parameterWrapper.DefaultValue !);
if (valueSyntax != null)
{
equals = EqualsValueClause(valueSyntax);
}
}
parameterWrapper.Attributes.TryGetNullable(out var nullability);
var name = parameterWrapper.Name;
var attributes = GeneratorFactory.Generate(parameterWrapper.Attributes, excludeMembersAttributes, excludeAttributes);
var modifiers = parameterWrapper.GetModifiers(isExtensionMethod);
var parameterType = parameterWrapper.ParameterType.GetTypeSyntax(nameWrapper, currentNullability, nullability, false);
return(Parameter(attributes, modifiers, parameterType, name, equals !));
}
static void Main()
{
var observableStream1 = GeneratorFactory.CreateGenerator(0, 100, 1, 500);
var observableStream2 = GeneratorFactory.CreateGenerator(1000, 1100, 1, 2000);
var observableStream3 = GeneratorFactory.CreateGenerator(10000, 11000, 1, 250);
var observableProvider = new ObservableProvider();
observableProvider.ConsoleKey.BreakWhenKey(ConsoleKey.Enter);
var combineLatestStream = observableStream1.CombineLatest(
observableStream2,
observableStream3,
observableProvider.ConsoleKey,
(a, b, c, d) => new
{
A = a,
B = b,
C = c,
D = d.Key
});
var combineLatestSubscribent = combineLatestStream.DefaultPrint("CombineLatest");
Console.WriteLine("Pres any key to show results.");
observableProvider.ConsoleKey.Start();
observableProvider.Dispose();
combineLatestSubscribent.Dispose();
}
public static void Main(string[] args)
{
var config = new Config
{
BackgroundColour = Color.FromArgb(0, 0, 0),
ImageFormat = ImageFormat.Png,
Mode = Mode.Horizontal,
OutputDirectory = Path.Combine
(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
"Desktop",
"WallpaperGenerator"
),
RectangleColour = Color.FromArgb(255, 0, 0),
RectangleExternalSize = new Size(10, 10),
RectangleInternalSize = new Size(5, 5),
RectangleThickness = 5,
Size = new Size(1920, 1080)
};
var generator = new GeneratorFactory().CreateGenerator(config.Mode);
using (var image = generator.Generate(config))
{
generator.Save(config, image);
}
}
/// <summary>
/// Creates an <see cref="IAdaptiveFeatureGenerator"/> from a the describing XML element.
/// </summary>
/// <param name="generatorElement">The element which contains the configuration.</param>
/// <param name="provider">The resource provider which could be used to access referenced resources.</param>
/// <returns>The configured <see cref="IAdaptiveFeatureGenerator"/> </returns>
public override IAdaptiveFeatureGenerator Create(XmlElement generatorElement,
FeatureGeneratorResourceProvider provider)
{
var nestedGeneratorElement = generatorElement.ChildNodes.OfType <XmlElement>().Select(childNode => childNode).FirstOrDefault();
if (nestedGeneratorElement == null)
{
throw new InvalidFormatException("window feature generator must contain an aggregator element");
}
var nestedGenerator = GeneratorFactory.CreateGenerator(nestedGeneratorElement, provider);
var prevLengthString = generatorElement.GetAttribute("prevLength");
int prevLength;
if (!int.TryParse(prevLengthString, out prevLength))
{
throw new InvalidFormatException("prevLength attribute is not a number!");
}
var nextLengthString = generatorElement.GetAttribute("nextLength");
int nextLength;
if (!int.TryParse(nextLengthString, out nextLength))
{
throw new InvalidFormatException("prevLength attribute is not a number!");
}
return(new WindowFeatureGenerator(nestedGenerator, prevLength, nextLength));
}
private SmartDataGenerator <T> Set <U>(Expression <Func <T, U> > expression, DataTypes type, U[] data)
{
MemberExpression body = expression.Body as MemberExpression;
if (body == null)
{
throw new ArgumentException();
}
var propertyInfo = (PropertyInfo)body.Member;
var propertyName = propertyInfo.Name;
var setting = new Settings()
{
DataType = type,
};
_settings[propertyName] = setting;
if (data != null)
{
setting.Generator = new CustomDataGenerator <U>(data);
}
else
{
if (!_generators.ContainsKey(setting.DataType))
{
_generators[setting.DataType] = GeneratorFactory.GetGenerator(setting.DataType);
}
setting.Generator = _generators[setting.DataType];
}
return(this);
}
public void GenerateDataProvider_BadArgumentsTestCase_ShouldBeException(long collectionSize, Wrapper wrapper)
{
var generatorFactory = new GeneratorFactory(_logger);
var generator = generatorFactory.GetGenerator(ProviderType.MemoryMappedFile);
CheckInvalidParameters(generator, collectionSize, wrapper.Params);
}
public static BaseMethodDeclarationSyntax?Generate(IHandleWrapper handle, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Nullability currentNullability, int level)
{
if (!(handle is MethodWrapper method))
{
return(null);
}
if (method.Attributes.TryGetNullableContext(out var nullableContext))
{
currentNullability = nullableContext;
}
var attributes = GeneratorFactory.Generate(method.Attributes, excludeMembersAttributes, excludeAttributes);
var modifiers = method.GetModifiers();
var parameters = GetParameters(method, excludeMembersAttributes, excludeAttributes, currentNullability);
var(constraints, typeParameters) = method.GetTypeParameters(excludeMembersAttributes, excludeAttributes, currentNullability);
var name = method.Name;
method.ReturnAttributes.TryGetNullable(out var returnNullability);
switch (method.MethodKind)
{
case SymbolMethodKind.Constructor:
return(ConstructorDeclaration(attributes, modifiers, parameters, method.DeclaringType.Name, level));
case SymbolMethodKind.Destructor:
return(DestructorDeclaration(attributes, modifiers, method.DeclaringType.Name, level));
case SymbolMethodKind.ExplicitInterfaceImplementation:
{
var explicitInterface = ExplicitInterfaceSpecifier(method.ExplicitType !.ReflectionFullName);
var returnType = method.ReturningType.GetTypeSyntax(method, currentNullability, returnNullability);
return(MethodDeclaration(attributes, default !, returnType, explicitInterface, name, parameters, constraints, typeParameters, level));
}
public void Init(long millis)
{
Debug.WriteLine($"Initializing {Type}: {millis}, {TagCount}");
Generator = GeneratorFactory.Create(this);
if (TagCount == 0)
{
TagCount = 1;
}
_Tags = new List <TrackingTag>();
for (int i = 0; i < TagCount; i++)
{
var tag = new TrackingTag
{
IsBall = UseBalls,
Timestamp = millis,
Used = false,
InUse = false,
X = QueuePoint.X0,
Y = QueuePoint.Y0
};
_Tags.Add(tag);
}
// get to the queue point
_MaxMillis = millis - 100;
State = ActivityState.Waiting;
//GeneratePath(millis, false);
}
//var generator = GeneratorFactory.Create(DataProviderTypes.PostgreSql);
//var metadataProvider = MetadataProviderFactory.Create(MetadataProviderTypes.PostgreSql);
//var schema = metadataProvider.Import("User ID=postgres;Password=1234;Host=localhost;Port=5432;Database=TaxService;");
private static void Main(string[] args)
{
var columns = new[] { new Column()
{
Name = "column1", Type = new DataType()
{
Name = "INTEGER"
}
}, new Column()
{
Name = "column2", Type = new DataType()
{
Name = "VARCHAR", Length = 2000
}
} };
var parameters = new[] { new Parameter()
{
Name = "p_column1", Type = new DataType()
{
Name = "INTEGER"
}
}, new Parameter()
{
Name = "p_column2", Type = new DataType()
{
Name = "VARCHAR", Length = 2000
}
} };
var table = new Table()
{
Name = "tableName", Columns = columns
};
var generatorParameters = new GeneratorParameters()
{
Name = "test_procedure",
Columns = table.Columns,
Parameters = parameters,
TableName = "test_table_name",
FilterColumns = new[] { columns[0] },
FilterParameters = new[] { new Parameter()
{
Name = "p_column3", Type = new DataType()
{
Name = "INTEGER"
}
} }
};
var serializer = new XmlSerializer(typeof(Table));
serializer.Serialize(Console.Out, table);
Console.WriteLine("\r\n");
var generator = GeneratorFactory.Create(DataProviderTypes.Oracle);
Console.WriteLine(generator.GenerateProcedureScript(ProcedureActionTypes.Add, generatorParameters));
Console.WriteLine();
Console.WriteLine(generator.GenerateProcedureScript(ProcedureActionTypes.Modify, generatorParameters));
Console.WriteLine();
Console.WriteLine(generator.GenerateProcedureScript(ProcedureActionTypes.Remove, generatorParameters));
}
public static MemberDeclarationSyntax?Generate(TypeWrapper type, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Func <TypeWrapper, bool> excludeFunc, int level)
{
if (excludeFunc(type))
{
return(null);
}
if (!type.TryGetEnumType(out var enumType))
{
return(null);
}
var enumKnownType = enumType.KnownType;
var members = type.Fields.Where(x => x.ShouldIncludeEntity(excludeMembersAttributes, excludeAttributes) && x.IsStatic && x.Accessibility == EntityAccessibility.Public).Select(field =>
{
var memberName = field.Name;
var constant = field.DefaultValue;
return(EnumMemberDeclaration(GeneratorFactory.Generate(field.Attributes, excludeMembersAttributes, excludeAttributes), memberName, constant == null ? null ! : EqualsValueClause(SyntaxHelper.GetValueExpressionForKnownType(enumKnownType, constant) !)));
}).ToList();
string?enumName = null;
if (enumKnownType != KnownTypeCode.Int32)
{
enumName = enumType.FullName;
}
return(EnumDeclaration(type.Name, GeneratorFactory.Generate(type.Attributes, excludeMembersAttributes, excludeAttributes), members, type.GetModifiers(), enumName, level));
}
public static RestFileInfo Split(string targetDir, string filePath, string swaggerRelativePath, string serviceId, string serviceName, string subGroupName, OperationGroupMapping operationGroupMapping, OrgsMappingFile orgsMappingFile, RepoFile repoFile, string version)
{
if (!Directory.Exists(targetDir))
{
throw new ArgumentException($"{nameof(targetDir)} '{targetDir}' should exist.");
}
if (!File.Exists(filePath))
{
throw new ArgumentException($"{nameof(filePath)} '{filePath}' should exist.");
}
var sourceSwaggerFilePath = Utility.GetSourceSwaggerFilePath(filePath);
IDictionary <string, int> lineNumberMappingDict = new Dictionary <string, int>();
using (var streamReader = File.OpenText(sourceSwaggerFilePath))
{
using (var reader = new JsonTextReader(streamReader))
{
var rootJObj = JObject.Load(reader);
lineNumberMappingDict = GetLineNumberMappingInfo(rootJObj);
}
}
var restFileInfo = new RestFileInfo();
using (var streamReader = File.OpenText(filePath))
{
using (var reader = new JsonTextReader(streamReader))
{
reader.DateParseHandling = DateParseHandling.None;
var rootJObj = JObject.Load(reader);
// Resolve $ref with json file instead of definition reference in the same swagger
var refResolver = new RefResolver(rootJObj, filePath);
refResolver.Resolve();
if (orgsMappingFile.NeedResolveXMsPaths)
{
var xMsPathsResolver = new XMsPathsResolver(rootJObj);
xMsPathsResolver.Resolve();
}
rootJObj["x-internal-service-id"] = serviceId;
rootJObj["x-internal-service-name"] = serviceName;
rootJObj["x-internal-sub-group-name"] = subGroupName;
var generator = GeneratorFactory.CreateGenerator(rootJObj, targetDir, filePath, operationGroupMapping, orgsMappingFile, lineNumberMappingDict, repoFile, swaggerRelativePath, version);
var fileNameInfos = generator.Generate().ToList();
if (fileNameInfos.Any())
{
restFileInfo.FileNameInfos = fileNameInfos;
}
restFileInfo.TocTitle = GetInfoTitle(rootJObj);
}
}
return(restFileInfo);
}
private static void Main()
{
using (var sf = new SqlServerFactory(ConfigurationManager.AppSettings["tokenCacheConnection"]))
{
var gf = new GeneratorFactory(sf);
gf.BuildTable("SecurityTokenCache", NameSpace, BasePath);
var m = new Model(gf, NameSpace);
var securityTokenCache = GetTableSimple(m, "SecurityTokenCache");
securityTokenCache.PrimaryKey = new PrimaryKey("pk", "_ContextID", "_EndpointID");
securityTokenCache.Add(new TableMethod("FindAllByEndpointIDAndContextID", MethodType.list, new[] { "_EndpointID", "_ContextID" }));
securityTokenCache.Add(new TableMethod("FindByEndpointIDContextIDAndKeyGeneration", MethodType.find, new[] { "_EndpointID", "_ContextID", "_KeyGeneration" }));
securityTokenCache.Add(new TableMethod("FindByEndpointIDAndContextID", MethodType.find, new[] { "_EndpointID", "_ContextID" }));
securityTokenCache.Parameters.Add(new Parameter("CurrentTime", typeof(System.DateTime)));
gf.BuildTable("TokenReplayCache", NameSpace, BasePath);
var tokenReplayCache = GetTableSimple(m, "TokenReplayCache");
tokenReplayCache.PrimaryKey = new PrimaryKey("pk", "_TokenKey");
tokenReplayCache.Add(new TableMethod("FindByKey", MethodType.find, new[] { "_TokenKey" }));
m.BuildCode(gf, ExtendedPath);
}
}
public void StepGeneratorCreatesOneScenarioTwoDuplicateSteps()
{
IList <NodeFeature> features;
features = new List <NodeFeature>();
//Add scenario 1
NodeScenario scenario1 = new NodeScenario("Scenario1");
scenario1.Steps.Add(new NodeStep("GivenMethod1"));
scenario1.Steps.Add(new NodeStep("GivenMethod1"));
//Add feature
NodeFeature feature1 = new NodeFeature("Feature1");
feature1.Scenarios.Add(scenario1);
features.Add(feature1);
var files = GeneratorFactory.Generate(GeneratorType.StepDefinitionGenerator, features);
string[] stringsExpected = new string[] {
"#include \"Feature1.h\"",
"",
"namespace CppUnitTest",
"{",
"\tvoid Feature1::GivenMethod1()",
"\t{",
"\t\tAssert::Fail(L\"Pending implementation...\");",
"\t}",
"}"
};
AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
}
static void Main()
{
var observableProvider = new ObservableProvider();
var observableGenerator1 = GeneratorFactory.CreateGenerator(0, 100, 1, 100);
var observableGenerator2 = GeneratorFactory.CreateGenerator(1000, 2000, 2, 600);
var observableGenerator3 = GeneratorFactory.CreateGenerator(10000, 15000, 51, 1000);
Console.WriteLine("Press any keys, enter to end ConsoleKey stream.");
var observableMerge1 = Observable.Merge(
observableProvider.ConsoleKey.Select(x => (int)x.Key),
observableGenerator1,
observableGenerator2,
observableGenerator3
);
var consoleKeySubscribent = observableProvider.ConsoleKey.Subscribe(
key =>
{
if (key.Key != ConsoleKey.Enter)
{
return;
}
observableProvider.ConsoleKey.Stop();
Console.WriteLine("Press any key to stop program.");
});
var subscribent1 = observableMerge1.Subscribe(
item =>
{
Console.WriteLine($"Merge1: {item}");
},
exception => Console.WriteLine(exception));
var observableMerge2 = GeneratorFactory.CreateGenerator(-1000, 0, 1, 10);
observableMerge2
.Merge(observableGenerator1)
.Merge(observableGenerator2)
.Merge(observableGenerator3);
var subscribent2 = observableMerge2.Subscribe(
item =>
{
Console.WriteLine($"Merge2: {item}");
},
exception => Console.WriteLine(exception));
observableProvider.ConsoleKey.Start();
Console.ReadKey();
subscribent1.Dispose();
subscribent2.Dispose();
consoleKeySubscribent.Dispose();
observableProvider.Dispose();
}
public void TestGeneratedValues()
{
var generatorFactory = new GeneratorFactory(_logger);
var generator = generatorFactory.GetGenerator(ProviderType.Array);
CheckInvalidParameters(generator, 7, null);
}
public void ShouldGetAllGenerators()
{
foreach (string dataType in supportedDatatypes)
{
var gens = GeneratorFactory.GetAllGeneratorsForType(new ColumnDataTypeDefinition(dataType, true));
Assert.That(gens.Count, Is.GreaterThan(0), dataType);
foreach (var gen in gens)
{
if (gen.IsTakingValueFromOtherColumn)
{
gen.GeneratorParameters["Value From Column"].Value = new ColumnEntity();
}
try
{
Assert.That(gen.GeneratorName, Is.Not.Empty, dataType);
Assert.That(gen.GeneratorName, Is.Not.Null, dataType);
Assert.That(gen.GenerateValue(1), Is.Not.Null, dataType);
}
catch (Exception e)
{
Assert.Fail(string.Format("ERROR Generating value for [{0}], generator: [{1}], message : {2}", dataType, gen.GeneratorName, e.ToString()));
}
}
}
}
static void Main()
{
var observableStream1 = GeneratorFactory.CreateGenerator(0, 100, 1, 100);
var observableStream2 = GeneratorFactory.CreateGenerator(0, 100, 1, 60);
var observableStream3 = GeneratorFactory.CreateGenerator(0, 100, 1, 120);
var observableProvider = new ObservableProvider();
observableProvider.ConsoleKey.BreakWhenKey(ConsoleKey.Enter);
var whenAndThenSequence = Observable.When(observableStream1
.And(observableStream2)
.And(observableStream3)
.And(observableProvider.ConsoleKey)
.And(observableProvider.TimeCounter)
.Then((first, second, third, consoleKey, time) =>
new {
One = first,
Two = second,
Three = third,
Key = consoleKey.Key,
Time = time
})
);
Console.WriteLine("Pres any key to show results.");
var whenAndThenSubscribent = whenAndThenSequence.DefaultPrint("WhenAndThen");
observableProvider.ConsoleKey.Start();
observableProvider.Dispose();
whenAndThenSubscribent.Dispose();
}
public void Run(CommandLineOptions options)
{
if (!File.Exists(options.Source))
{
_logger.LogError($"File not found: {options.Source}");
return;
}
ISource source = SourceFactory.GetSource(Path.GetExtension(options.Source).Substring(1));
_logger.LogInformation($"TableName: {_template.TableName}");
_logger.LogInformation($"Source: {options.Source}");
_logger.LogInformation($"Target: {options.Target}");
_logger.LogInformation($"WorksheetName: {options.WorkSheetName}");
source.Load(options.Source);
var generator = GeneratorFactory.GetGenerator(source.GetReader(), source.TableDef);
TextWriter output;
if (string.IsNullOrEmpty(options.Target))
{
output = Console.Out;
}
else
{
output = new StreamWriter(options.Target);
}
generator.Generate(output);
}
public string Post([FromBody] Models.CreateGeneratorRequest value)
{
string id = Guid.NewGuid().ToString();
cache.Add(id, GeneratorFactory.BuildGenerator(value), DateTime.Now.AddMinutes(30));
return(id);
}
private string GenerateText(Expression expression, ExpressionSourceType source)
{
IGenerator template = GeneratorFactory.CreateGenerator(_type, _ruleSetValidator);
//TODO: can most likely remove this templateInitialization and replace with constructor in partial class
var templateInitialization = new Dictionary <string, object>
{
{ "objectExpression", expression },
{ "maxDepth", _maxDepth },
};
template.Session = templateInitialization;
//Set the conversion source
if (source == ExpressionSourceType.Locals)
{
template.Converter = _localsConverter;
}
else
{
template.Converter = _customExpressionConverter;
}
template.Initialize();
template.Clear();
string transformedText = template.TransformText();
return(transformedText);
}
/// <summary>
/// Main loop.
/// </summary>
public static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("No argument provided. Please input LO7 or DSA.");
Environment.Exit(1);
}
Generator generator = null;
switch (args[0].ToUpper())
{
case DsaArg:
generator = GeneratorFactory.Get(GeneratorFactory.Type.Dsa);
break;
case Lo7Arg:
generator = GeneratorFactory.Get(GeneratorFactory.Type.Lo7);
break;
default:
Console.WriteLine("Invalid argument provided. Please input LO7 or DSA.");
Environment.Exit(2);
break;
}
// accelerate heat death of the universe
while (true)
{
Console.WriteLine(generator.Get());
}
}
public void TestCreationWithUnknownElement()
{
using (var config = Tests.OpenFile("/opennlp/tools/util/featuregen/FeatureGeneratorConfigWithUnkownElement.xml")) {
var never = GeneratorFactory.Create(config, null);
Assert.Fail("No exception :(");
}
}
void EntityCheck_CheckedChanged(object sender, EventArgs e)
{
if (EntityCheck.Checked)
{
Template.Text = GeneratorFactory.GetGeneratorByName(GeneratorEnum.EntityGenerator)._templateText;
//Template.AppendText(DTOCheck.Text + "\n");
}
}
public Faker(int maxLevel)
{
rand = new Random();
resolver = new CircularReferencesResolver(maxLevel);
generators = GeneratorFactory.CraeteBaseTypesGenerators();
generators.Add(new DateGenerator());
LoadPlugins();
}
private void InitializeNewPlane(DetectedPlane detectedPlane)
{
var anchor = detectedPlane.CreateAnchor(detectedPlane.CenterPose);
anchor.transform.SetParent(planeRoot.transform);
var plane = GameObject.Instantiate(planePrefab, anchor.transform);
var planeController = plane.GetComponent <PlaneController>();
planeController.Initialize(detectedPlane);
var performerType = performerSelector.GetNextPerformerType();
planeController.instrument.SetSample(performerType.sample);
planeController.generator = GeneratorFactory.CreateGenerator(planeController.instrument,
performerType.generatorName);
// TEST //
if (performerType.generatorName == "Drums")
{
var generator = planeController.generator as Drums;
if (performerType.sample.name.Contains("kick"))
{
generator.drumType = DrumType.KICK;
}
else if (performerType.sample.name.Contains("snare"))
{
generator.drumType = DrumType.SNARE;
}
else if (performerType.sample.name.Contains("clap"))
{
generator.drumType = DrumType.CLAP;
}
else if (performerType.sample.name.Contains("closed"))
{
generator.drumType = DrumType.HH_CLOSED;
}
else if (performerType.sample.name.Contains("open"))
{
generator.drumType = DrumType.HH_OPEN;
}
}
else if (performerType.generatorName != "SimpleBassline")
{
planeController.instrument.noteOffset = Random.Range(-8, 8); // noteOffsetGenerator.CurrentState;
//noteOffsetGenerator.GenerateNextState();
}
if (performerType.generatorName == "OneBarNote")
{
(planeController.generator as OneBarNote).beatOffset = 0.5 * Random.Range(0, 8);
}
if (performerType.generatorName == "SimpleBassline")
{
(planeController.generator as SimpleBassline).beatOffset = Random.Range(0, 4);
}
}
private void ExpectMoreNullableThanRegular(string datatype, int expectedGens)
{
var gens = GeneratorFactory.GetAllGeneratorsForType(new ColumnDataTypeDefinition(datatype, false));
Assert.That(gens.Count, Is.GreaterThanOrEqualTo(expectedGens), datatype);
var nullable = GeneratorFactory.GetAllGeneratorsForType(new ColumnDataTypeDefinition(datatype, true));
Assert.That(nullable.Count, Is.GreaterThan(gens.Count), datatype);
}
/// <summary>
/// Register a GeneratorFactory delegation faactory.
/// </summary>
/// <param name="ID">Unique ID of the generator to register</param>
/// <param name="factory">The delegate factory for Generator creation</param>
/// <returns>true if the delgation factory was registered, false if there was already a registered delegation factory with the same ID</returns>
public bool RegisterFactory(String ID, GeneratorFactory factory)
{
if (RegistryMap.ContainsKey(ID))
{
return(false);
}
RegistryMap[ID] = factory;
return(true);
}
public static TypeParameterSyntax?Generate(IHandleWrapper handle, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes)
{
if (!(handle is GenericParameterWrapper typeParameterWrapper))
{
return(null);
}
return(TypeParameter(GeneratorFactory.Generate(typeParameterWrapper.Attributes, excludeMembersAttributes, excludeAttributes), GetVarianceToken(typeParameterWrapper.Variance), typeParameterWrapper.Name));
}
public void ShouldCreateInstanceOfDecimalUpCounter()
{
var dt = new ColumnDataTypeDefinition("decimal(19, 6)", false);
var gen = GeneratorFactory.CreateInstance(typeof(CountingUpDecimalGenerator), dt);
Assert.That(gen, Is.Not.Null);
var value = gen.GenerateValue(1);
Assert.That(value, Is.Not.Null);
}
static void Main(string[] args)
{
if (args == null || args.Length == 0)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ProxyGeneratorForm());
}
else
{
GeneratorFactory gf = new GeneratorFactory();
//程序集路径
gf.AssemblyPath = args[0];
//命名空间
gf.NameSpace = args[1];
//目标文件夹
gf.TargetFolder = args[2];
gf.FillClasses();
gf.GenerateCode();
}
}
//[DebuggerStepThrough]
public Context()
{
Out = Console.Out;
GeneratorName = String.Empty;
WorkingDirectory = Directory.GetCurrentDirectory();
Generators = new List<Generator>();
var factory = new GeneratorFactory(this);
var generatorsDirectory = new DirectoryInfo(GeneratorsDirectory);
if (!Directory.Exists(generatorsDirectory.FullName))
{
Directory.CreateDirectory(generatorsDirectory.FullName);
}
foreach (var directory in generatorsDirectory.GetDirectories())
{
var generator = factory.Create(directory.Name);
Generators.Add(generator);
}
}
public void Initialize(string name)
{
GeneratorName = name;
var factory = new GeneratorFactory(this);
Generator = factory.Create(GeneratorName);
}
public ProxyGeneratorForm()
{
InitializeComponent();
gf = new GeneratorFactory();
}
