public static void main(String[] args) {
if (genPeople) {
deleteDir(dirPeople);
Generator g = new Generator();
List<Person> people = g.generateRandom(100);
RdfFoafGenerator rdfGen = new RdfFoafGenerator(people);
for (Person p : people) {
writeRdf("people", p.getUid(), rdfGen.generatePerson(p));
}
}
if (genSkills) {
deleteDir(dirSkills);
for (String s : Skill.skills) {
writeRdf("skills", s.replaceAll("\\s", ""), SkillsRDFGenerator.generateSkill(s));
}
}
if (genLevels) {
deleteDir(dirLevels);
for (String l : Skill.levels) {
writeRdf("levels", l.replaceAll("\\s", ""), SkillsRDFGenerator.generateLevel(l));
}
}
System.out.println("End");
}
private void writeStart(PrintWriter writer) {
writer.printf("package %s;\n", getPackageName());
writer.println("");
// Super class. Inherit from ByteBuffer if none given.
String superClass = getSuperClass();
// Collect imports from generators
for (Generator generator : generators)
if (generator.getInclude() != null) includes.add(generator.getInclude());
// Generate imports
for (String include : includes) writer.printf("import %s;\n", include);
// Import superclass
if (superClass != null) writer.printf("import %s;\n", superClass);
// Blank line
if (includes.size() > 0 || superClass != null) writer.println("");
// Class declaration
writer.printf("public class %s", classElement.getSimpleName());
if (superClass != null)
writer.printf(" extends %s", superClass.substring(superClass.lastIndexOf('.') + 1));
writer.println("");
writer.println("{");
}
public static MethodDelegate create(Object target, String methodName, Class iface) {
Generator gen = new Generator();
gen.setTarget(target);
gen.setMethodName(methodName);
gen.setInterface(iface);
return gen.create();
}
@Override
public GeneratorInstance delete(GeneratorInstanceDeleteRequest request) {
Long id = request.getId();
GeneratorInstance generatorInstancePersistence = generatorInstanceRepository.selectById(id);
if (generatorInstancePersistence == null) {
throw new AppException("实例不存在");
}
Long userId = request.getAuthentication().getUserId();
if (!userId.equals(generatorInstancePersistence.getUser().getId())) {
throw new AppException("权限不足");
}
generatorInstanceRepository.delete(generatorInstancePersistence);
Long rootDataModelId = generatorInstancePersistence.getDataModel().getId();
DataModel rootDataModePersistence = dataModelRepository.selectById(rootDataModelId);
if (rootDataModePersistence == null) {
throw new AppException("rootDataMode不存在");
}
dataModelRepository.delete(rootDataModePersistence);
Generator generatorPersistence =
generatorRepository.selectById(generatorInstancePersistence.getGenerator().getId());
generatorPersistence.setInstanceCount(generatorPersistence.getInstanceCount() - 1);
generatorRepository.update(generatorPersistence);
return generatorInstancePersistence;
}
@Override
public GeneratorInstance versionSync(GeneratorInstanceVersionSyncRequest request) {
Long id = request.getId();
GeneratorInstance generatorInstancePersistence = generatorInstanceRepository.selectById(id);
if (generatorInstancePersistence == null) {
throw new AppException("实例不存在");
}
Long userId = request.getAuthentication().getUserId();
if (!userId.equals(generatorInstancePersistence.getUser().getId())) {
throw new AppException("权限不足");
}
Long generatorId = generatorInstancePersistence.getGenerator().getId();
Generator generatorPersistence = generatorRepository.selectById(generatorId);
if (generatorPersistence == null) {
throw new AppException("生成器不存在");
}
if (generatorInstancePersistence.getVersion() < generatorPersistence.getVersion()) {
generatorInstancePersistence.setVersion(generatorPersistence.getVersion());
generatorInstancePersistence.setModifyDate(new Date());
generatorInstanceRepository.update(generatorInstancePersistence);
}
return generatorInstancePersistence;
}
public static void simulateDataSet(DataListener mockModel, int dataSetIndex) {
initializeDataSets();
TextResource resource = dataSets.get(dataSetIndex).dataSetResource;
final Generator generator = new Generator(mockModel);
String[] events = resource.getText().split("\n");
generator.run(events);
}
/**
* Helper method to create a bean mixin. For finer control over the generated instance, use a new
* instance of <code>Mixin</code> instead of this static method. TODO
*/
public static Mixin createBean(ClassLoader loader, Object[] beans) {
Generator gen = new Generator();
gen.setStyle(STYLE_BEANS);
gen.setDelegates(beans);
gen.setClassLoader(loader);
return gen.create();
}
@Test
public void testParserAndGenerator() throws Exception {
WebSocketPolicy policy = WebSocketPolicy.newServerPolicy();
ByteBufferPool bufferPool = new MappedByteBufferPool();
Generator gen = new Generator(policy, bufferPool);
Parser parser = new Parser(policy, bufferPool);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
String message = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
ByteBuffer out = bufferPool.acquire(8192, false);
try {
// Generate Buffer
BufferUtil.flipToFill(out);
WebSocketFrame frame = WebSocketFrame.text(message);
out = gen.generate(frame);
// Parse Buffer
parser.parse(out);
} finally {
bufferPool.release(out);
}
// Validate
capture.assertNoErrors();
capture.assertHasFrame(OpCode.TEXT, 1);
WebSocketFrame txt = capture.getFrames().get(0);
Assert.assertThat("Text parsed", txt.getPayloadAsUTF8(), is(message));
}
public static List<SModelDescriptor> getLanguageModels(Language lang) {
List<SModelDescriptor> inputModels = new ArrayList<SModelDescriptor>();
for (LanguageAspect aspect : LanguageAspect.values()) {
SModelDescriptor model = aspect.get(lang);
if (model != null) {
inputModels.add(model);
}
}
Set<SModelDescriptor> ownModels = new HashSet<SModelDescriptor>(lang.getOwnModelDescriptors());
for (SModelDescriptor sm : lang.getAccessoryModels()) {
if (!SModelStereotype.isUserModel(sm)) continue;
if (!(sm instanceof EditableSModelDescriptor)) continue;
if (ownModels.contains(sm)) {
inputModels.add(((EditableSModelDescriptor) sm));
}
}
inputModels.addAll(lang.getUtilModels());
// add it from all generators
List<Generator> list = lang.getGenerators();
for (Generator generator : list) {
inputModels.addAll(generator.getGeneratorModels());
}
return inputModels;
}
public static void main(String[] args) {
boolean rendered = false;
MandelbrotGUI gui = new MandelbrotGUI();
Generator g = new Generator();
while (true) {
// wait for GUI command
switch (gui.getCommand()) {
case MandelbrotGUI.RENDER:
// render mandelbrot
g.render(gui);
rendered = true;
break;
case MandelbrotGUI.ZOOM:
// only allow if already rendered
if (rendered) {
g.render(gui);
}
break;
case MandelbrotGUI.RESET:
// reset everything to initial state
gui.resetPlane();
gui.clearPlane();
rendered = false;
break;
case MandelbrotGUI.QUIT:
// quit application
System.exit(0);
break;
default:
// STDERR if GUI command not yet implemented
System.err.println("Command not yet implented: NR(" + gui.getCommand() + ")");
break;
}
}
}
/**
* Create DDL Generator for specified database engine with given global and specific
* configurations.
*
* @param engine Database engine.
* @param globalConf Global configuration file.
* @param specificConf Specific configuration file for database engine.
* @return DDL generator for database engine.
* @throws GeneratorException If database engine has not been specified or no generator is
* available for the database engine.
*/
public static Generator createDDLGenerator(
final String engine, final String globalConf, final String specificConf)
throws GeneratorException {
DDLGenConfiguration config = new DDLGenConfiguration();
// load default global configuration
config.addProperties(Generator.GLOBAL_CONFIG_PATH + Generator.GLOBAL_CONFIG_NAME);
// overload with global configuration given on commandline
if (globalConf != null) {
config.addProperties(globalConf);
}
GeneratorRegistry registry = new GeneratorRegistry(config);
String eng = config.getStringValue(DDLGenConfiguration.DEFAULT_ENGINE_KEY, "");
if (engine != null) {
eng = engine;
}
Generator gen = registry.getGenerator(eng.toLowerCase());
// load default configuration for specific database engine
config.addProperties(gen.getEngineConfigPath() + gen.getEngineConfigName());
// overload with specific configuration given on commandline
if (specificConf != null) {
config.addProperties(specificConf);
}
// create key generator registry to be used by the generator
gen.setKeyGenRegistry(new KeyGeneratorRegistry(config));
// initialize generator
gen.initialize();
return gen;
}
public ArrayList<Shape> generateLevel(Document document, int maxDepth) {
lastTile = new Tile("");
TilesProcessor tilesProcessor = new TilesProcessor();
tilesProcessor.process(document);
levelTiles = new ArrayList<Tile>();
Map<String, Tile> tileMap = tilesProcessor.tileMap;
Generator generator = new Generator();
generator.tileMap = tileMap;
// System.out.println("max level depth "+ maxDepth);
ArrayList<String> generatedTiles = generator.generate(maxDepth);
for (int i = 0; i < generatedTiles.size(); i++) {
String tileId = generatedTiles.get(i);
addRight(tileMap.get(tileId));
}
ArrayList<Shape> shapes = new ArrayList<Shape>();
for (int i = 0; i < levelTiles.size(); i++) {
Tile tile = levelTiles.get(i);
for (int j = 0; j < tile.paths.size(); j++) {
Path path = tile.paths.get(j);
shapes.add(convertPathToShape(path));
}
}
return shapes;
}
public static KeyFactory create(ClassLoader loader, Class keyInterface, Customizer customizer) {
Generator gen = new Generator();
gen.setInterface(keyInterface);
gen.setCustomizer(customizer);
gen.setClassLoader(loader);
return gen.create();
}
private static void genForPart(
StringBuilder builder, GroovyPsiElement part, final Generator visitor) {
part.accept(visitor);
for (String statement : visitor.getContext().myStatements) {
builder.append(statement).append(", ");
}
builder.append(visitor.getBuilder());
}
/**
* Returns generated object.
*
* @param type parametrized type of generated object
* @param rootClazz root class of generated objects
* @param <T> type of generated object
* @return generated object
*/
@SuppressWarnings("unchecked")
public <T> T generateObject(final ParameterizedType type, final Class<?> rootClazz) {
for (final Generator generator : generators) {
if (generator.canGenerate((Class<?>) type.getRawType())) {
return (T) generator.generate(type, rootClazz, null, this);
}
}
return null;
}
/**
* Returns generated object.
*
* @param clazz class of generated object
* @param rootClazz root class of generated objects
* @param <T> type of generated object
* @return generated object
*/
@SuppressWarnings("unchecked")
public <T> T generateObject(final Class<T> clazz, final Class<?> rootClazz) {
for (final Generator generator : generators) {
if (generator.canGenerate(clazz)) {
return (T) generator.generate(clazz, rootClazz, null, this);
}
}
return null;
}
public static void main(String[] args) {
Generator gen = new RandomGenerator();
Generator aGen = new AlmostOrderedGenerator();
// for (int i = 0; i < 5; i++) {
System.out.println(
"Random array: " + Arrays.toString(gen.generateArray((int) Math.pow(2, 20))));
// System.out.println("Almost random array: " + Arrays.toString(aGen.generateArray(30)));
// }
}
@Override
public Cell value(Object value) {
if (value instanceof Generator) {
Generator generator = (Generator) value;
value = generator.nextValue();
}
this.value = value;
return this;
}
public static void main(String[] args) {
PropertyManager manager = PropertyManager.newInstance(args[0]);
try {
Generator generator = new JspToFaceletsTLD21Generator(manager);
generator.generate(GeneratorUtil.getConfigBean(args[1]));
} catch (Exception e) {
throw new RuntimeException(e);
}
} // END main
private void processByGeneratorModel(boolean isDelete, Generator g, GeneratorModel m)
throws Exception, FileNotFoundException {
try {
if (isDelete) g.deleteBy(m.templateModel, m.filePathModel);
else g.generateBy(m.templateModel, m.filePathModel);
} catch (GeneratorException ge) {
PrintUtils.printExceptionsSumary(
ge.getMessage(), getGenerator().getOutRootDir(), ge.getExceptions());
throw ge;
}
}
/**
* I want to figure out, if i need specialized generator for enum types, or i can use standard
* instantiator generator. It doesn't assert anything, it's only simple check. First condition in
* the InstantiatorGenerator has to be commented.
*/
@Test
public void TestInstantiator() {
GeneratorConfiguration gc = new GeneratorConfiguration();
gc.setInstantiatorClassIdentifier("Test%sInstantiator");
Generator generator = new InstantiatorGenerator(gc);
GeneratorJobConfiguration job = new GeneratorJobConfiguration();
job.setApiId("enum");
job.setOutputDir("output/tests/enum");
job.setOutputPackage("test.%s");
generator.generate(api, job);
}
public static void test(Class<?> surroundingClass) {
for (Class<?> type : surroundingClass.getClasses()) {
System.out.print(type.getSimpleName() + ": ");
try {
Generator<?> g = (Generator<?>) type.newInstance();
for (int i = 0; i < size; i++) System.out.printf(g.next() + " ");
System.out.println();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
@Test
public void e_e_hexadiene_permute() throws Exception {
String input = "C\\C(=C(\\C(=C(/[H])\\C)\\[H])/[H])\\[H]";
int[] p = new int[] {7, 2, 4, 1, 3, 6, 8, 9, 0, 5};
Graph g = Parser.parse(input);
Assert.assertThat(
Generator.generate(g.permute(p)),
CoreMatchers.is("[H]\\C(\\C(=C(/[H])\\C)\\[H])=C(\\[H])/C"));
Assert.assertThat(
Generator.generate(new RemoveUpDownBonds().apply(g.permute(p))),
CoreMatchers.is("[H]\\C(\\C(=C(/[H])C)[H])=C(\\[H])C"));
}
void frame(Generator gen) {
super.frame(gen);
if (!gen.hasFrame(m_left) || !gen.hasFrame(m_right)) {
return;
}
QFrame left = gen.getFrame(m_left);
QFrame right = gen.getFrame(m_right);
equate(gen, this, left, right);
}
private Object generate(Class<?> type, boolean alternative) {
for (Generator<?> generator : generators) {
ParameterizedType generic =
(ParameterizedType) generator.getClass().getGenericInterfaces()[0];
Class<?> restrained =
generic.getActualTypeArguments()[0] instanceof ParameterizedType
? (Class<?>) ((ParameterizedType) generic.getActualTypeArguments()[0]).getRawType()
: (Class<?>) generic.getActualTypeArguments()[0];
if (type.isAssignableFrom(restrained)) {
type = generator.generate();
}
}
return type == String.class ? alternative ? OTHER_STRING : DEFAULT_STRING : mock(type);
}
private void generateSource(
Generator.TemplateType mgrType, String template, String recordType, String outputPath)
throws MojoFailureException {
InputStream is = getClass().getClassLoader().getResourceAsStream(template);
if (is == null) {
throw new MojoFailureException("template '" + template + "' not found in classpath");
}
StringBuilder sb = new StringBuilder();
File outputFile = new File(outputPath + File.separator + recordType + template);
try {
getLog().info("generating " + outputFile.toString());
Generator.generateSource(mgrType, packageName, typeMap.get(recordType), is, sb, debug);
is.close();
FileWriter outWriter = new FileWriter(outputFile);
outWriter.write(sb.toString());
outWriter.close();
} catch (Exception ex) {
getLog().error(ex);
throw new MojoFailureException("failed to generate " + outputFile.toString());
}
}
public void upload(
String groupId, String artifactId, String version, String extension, Generator writer)
throws Exception {
File file =
File.createTempFile(
String.format("%s-%s-%s", groupId, artifactId, version), "." + extension);
try {
FileOutputStream out = new FileOutputStream(file);
try {
writer.write(out);
} finally {
out.close();
}
Artifact artifact =
new DefaultArtifact(groupId, artifactId, extension, version).setFile(file);
// Install the artifact locally
repositorySystem.install(session, new InstallRequest().addArtifact(artifact));
// Deploy the artifact remotely
DeployRequest deployRequest = new DeployRequest().addArtifact(artifact);
if (artifact.isSnapshot()) {
Preconditions.checkNotNull(snapshotsRepository, "snapshots repository uri is null");
deployRequest.setRepository(snapshotsRepository);
} else {
Preconditions.checkNotNull(releasesRepository, "releases repository uri is null");
deployRequest.setRepository(releasesRepository);
}
repositorySystem.deploy(session, deployRequest);
} finally {
file.delete();
}
}
/** Reactivate this choice point to return new results. */
public void pump() {
if (context instanceof Generator) {
((Generator) context).pump(this);
} else {
// The top level iterator is in charge and will restore and run this choice point itself
}
}
/**
* This is the reduce implementation
*
* @param rule the rule to reduce by
*/
private void reduce(int rule) throws SyntaxError {
// get the rule number to reduce by
int num = Math.abs(rule);
// this section is for generating code
if (num == 27 || num == 28 || num == 29 || num == 30 || num == 31 || num == 32 || num == 33
|| num == 37 || num == 39 || num == 41) {
gen.reduce(num);
}
// popping empty from the stack, just push
if (GrammarTable.grammar[num].length != 1) {
// start popping and matching stuff
int input = 0;
for (int i = GrammarTable.grammar[num].length - 1; i > 0; i--) {
stack.pop();
input = stack.pop();
if (GrammarTable.grammar[num][i] == input) {
continue;
} else {
throw new SyntaxError("Syntax error in source file on line " + scanner.getLine());
}
}
}
// push the LHS
curState = stack.peek();
// push the left hand side
stack.push(GrammarTable.getRule(num)[0]);
curState = pTable.getNextState(curState, GrammarTable.getRule(num)[0]);
stack.push(curState);
}
@Test
public void test_simple_with_equal_elements_permutation() {
List<List<Integer>> permutations =
Generator.permutation(Arrays.asList(1, 2, 2, 3))
.simple()
.stream()
.collect(Collectors.<List<Integer>>toList());
assertThat(permutations).hasSize(12);
System.out.println("Identical permutations of (1, 2, 2, 3):");
permutations.stream().forEach(System.out::println);
assertThat(permutations.get(0)).containsExactly(1, 2, 2, 3);
assertThat(permutations.get(1)).containsExactly(1, 2, 3, 2);
assertThat(permutations.get(2)).containsExactly(1, 3, 2, 2);
assertThat(permutations.get(3)).containsExactly(2, 1, 2, 3);
assertThat(permutations.get(4)).containsExactly(2, 1, 3, 2);
assertThat(permutations.get(5)).containsExactly(2, 2, 1, 3);
assertThat(permutations.get(6)).containsExactly(2, 2, 3, 1);
assertThat(permutations.get(7)).containsExactly(2, 3, 1, 2);
assertThat(permutations.get(8)).containsExactly(2, 3, 2, 1);
assertThat(permutations.get(9)).containsExactly(3, 1, 2, 2);
assertThat(permutations.get(10)).containsExactly(3, 2, 1, 2);
assertThat(permutations.get(11)).containsExactly(3, 2, 2, 1);
}
