Java StringTemplateGroup.getInstanceOf方法代码示例

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
public static StringTemplate createIndexTemplate(String typeName, String sdkName, String packageName, List<IndexedAnnotation> indices,
        Map<String, String> fieldNameToType, StringTemplateGroup templateLib) {
    AbstractTTree.STAttrMap attrMap = new AbstractTTree.STAttrMap().put("name", typeName).put("sdkName", sdkName).put("package", packageName);

    List<StringTemplate> functionCalls = new LinkedList<StringTemplate>();
    List<StringTemplate> functionDefinitions = new LinkedList<StringTemplate>();
    for (IndexedAnnotation indexedAnnotation : indices) {
        StringTemplate createIndexDefinition = createIndexDefinitionTemplate(templateLib, packageName, typeName, indexedAnnotation, fieldNameToType);
        functionDefinitions.add(createIndexDefinition);

        StringTemplate indexCall = createIndexCallTemplate(templateLib, indexedAnnotation);
        functionCalls.add(indexCall);
    }

    if (indices.size() > 0) {
        attrMap.put("functionDefinitions", functionDefinitions);
        attrMap.put("functionCalls", functionCalls);
    }

    return templateLib.getInstanceOf("beanIndexInfoClass", attrMap);
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
private String getHtml()
{
	final StringTemplateGroup templates = new StringTemplateGroup( "manager" );
	final StringTemplate t = templates.getInstanceOf( "templates/manager" );

	t.setAttribute( "bytesSent", getByteSizeString( statHandler.getResponsesBytesTotal() ) );
	t.setAttribute( "msgPerSec", connectorStats.getMessagesOutPerSecond() );
	t.setAttribute( "openConnections", connectorStats.getConnectionsOpen() );
	t.setAttribute( "maxOpenConnections", connectorStats.getConnectionsOpenMax() );

	getContexts();

	t.setAttribute( "contexts", contexts );

	t.setAttribute( "noDataSets", noDataSets );
	t.setAttribute( "sizeDataSets", getByteSizeString( sizeDataSets ) );

	t.setAttribute( "statHtml", statHandler.toStatsHTML() );

	return t.toString();
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
private void createPackageIndexPage(final PackageSummaryData psData) {
  final StringTemplateGroup group = new StringTemplateGroup("mutation_test");
  final StringTemplate st = group
      .getInstanceOf("templates/mutation/package_index");

  final Writer writer = this.outputStrategy.createWriterForFile(psData
      .getPackageDirectory() + File.separator + "index.html");
  st.setAttribute("packageData", psData);
  try {
    writer.write(st.toString());
    writer.close();
  } catch (final IOException e) {
    e.printStackTrace();
  }

}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
public StringTemplate genExpr(CodeGenerator generator,
							  StringTemplateGroup templates,
							  DFA dfa)
{
	StringTemplate eST = null;
	if ( templates!=null ) {
		eST = templates.getInstanceOf("orPredicates");
	}
	else {
		eST = new StringTemplate("($first(operands)$$rest(operands):{o | ||$o$}$)");
	}
	for (Iterator it = operands.iterator(); it.hasNext();) {
		SemanticContext semctx = (SemanticContext) it.next();
		eST.setAttribute("operands", semctx.genExpr(generator,templates,dfa));
	}
	return eST;
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
@Override
protected void compile(ProtoModule module, Proto proto) throws IOException
{
    String javaPackageName = proto.getJavaPackageName();
    StringTemplateGroup group = getSTG(getOutputId());

    String fileName = resolveFileName(proto);
    Writer writer = CompilerUtil.newWriter(module, javaPackageName,
            "Schema" + fileName + ".java");

    AutoIndentWriter out = new AutoIndentWriter(writer);
    StringTemplate protoOuterBlock = group.getInstanceOf("proto_block");

    protoOuterBlock.setAttribute("proto", proto);
    protoOuterBlock.setAttribute("module", module);
    protoOuterBlock.setAttribute("options", module.getOptions());

    protoOuterBlock.write(out);
    writer.close();
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
protected void writeMessages(ProtoModule module, Proto proto, String javaPackageName, StringTemplateGroup group)
        throws IOException
{
    for (Message m : proto.getMessages())
    {
        Writer writer = CompilerUtil.newWriter(module,
                javaPackageName, m.getName() + ".java");
        AutoIndentWriter out = new AutoIndentWriter(writer);

        StringTemplate messageBlock = group.getInstanceOf("message_block");
        messageBlock.setAttribute("message", m);
        messageBlock.setAttribute("module", module);
        messageBlock.setAttribute("options", module.getOptions());

        messageBlock.write(out);
        writer.close();
    }
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
protected void writeEnums(ProtoModule module, Proto proto, String javaPackageName, StringTemplateGroup group)
        throws IOException
{
    for (EnumGroup eg : proto.getEnumGroups())
    {
        Writer writer = CompilerUtil.newWriter(module,
                javaPackageName, eg.getName() + ".java");
        AutoIndentWriter out = new AutoIndentWriter(writer);

        StringTemplate enumBlock = group.getInstanceOf("enum_block");
        enumBlock.setAttribute("eg", eg);
        enumBlock.setAttribute("module", module);
        enumBlock.setAttribute("options", module.getOptions());

        enumBlock.write(out);
        writer.close();
    }
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
private static StringTemplate createIndexDefinitionTemplate(StringTemplateGroup templateLib, String packageName, String className,
        IndexedAnnotation indexedAnnotation,
        Map<String, String> fieldNameToType) {
    List<StringTemplate> fields = createIndexFieldsTemplates(templateLib, packageName, className, indexedAnnotation, fieldNameToType);
    Map<?, ?> definitionMap = new AbstractTTree.STAttrMap().put("name", indexedAnnotation.getName()).put("fields", fields);
    return templateLib.getInstanceOf("createIndexDefinition", definitionMap);
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
/**
 * Runs the code generation for all templates.
 */
public void run() throws PstException {
  List<PstException.TemplateException> exceptions = Lists.newArrayList();
  for (File template : templates) {
    try {
      MessageProperties properties = createProperties(template);
      String groupName = stripSuffix(".st", template.getName());
      String templateName = properties.hasTemplateName() ?
          properties.getTemplateName() : "";
      StringTemplateGroup group = new StringTemplateGroup(groupName + "Group", dir(template));
      StringTemplate st = group.getInstanceOf(groupName);
      for (Descriptor messageDescriptor : fd.getMessageTypes()) {
        Message message = new Message(messageDescriptor, templateName, properties);
        st.reset();
        st.setAttribute("m", message);
        write(st, new File(
            outputDir.getPath() + File.separator +
            message.getFullJavaType().replace('.', File.separatorChar) + "." +
            (properties.hasFileExtension() ? properties.getFileExtension() : "java")));
      }
    } catch (Exception e) {
      exceptions.add(new PstException.TemplateException(template.getPath(), e));
    }
  }
  if (!exceptions.isEmpty()) {
    throw new PstException(exceptions);
  }
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
public StringTemplate genExpr(CodeGenerator generator,
							  StringTemplateGroup templates,
							  DFA dfa)
{
	if ( templates!=null ) {
		return templates.getInstanceOf("true");
	}
	return new StringTemplate("true");
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
private void createIndexPages() {

    final StringTemplateGroup group = new StringTemplateGroup("mutation_test");
    final StringTemplate st = group
        .getInstanceOf("templates/mutation/mutation_package_index");

    final Writer writer = this.outputStrategy.createWriterForFile("index.html");
    final MutationTotals totals = new MutationTotals();

    final List<PackageSummaryData> psd = new ArrayList<>(
        this.packageSummaryData.values());
    Collections.sort(psd);
    for (final PackageSummaryData psData : psd) {
      totals.add(psData.getTotals());
      createPackageIndexPage(psData);
    }

    st.setAttribute("totals", totals);
    st.setAttribute("packageSummaries", psd);
    try {
      writer.write(st.toString());
      writer.close();
    } catch (final IOException e) {
      e.printStackTrace();
    }

  }
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
protected String genClassHeader(StringTemplateGroup group, String junitFileName) {
	StringTemplate classHeaderST = group.getInstanceOf("classHeader");
	if ( grammarInfo.getHeader()!=null ) {	// Set up class package if there is
		classHeaderST.setAttribute("header", "package "+grammarInfo.getHeader()+";");
	}
	classHeaderST.setAttribute("junitFileName", junitFileName);
	return classHeaderST.toString();
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
protected String genSupportingMethods(StringTemplateGroup group, String lexerName, String parserName) {
	StringTemplate supportingMethodST;
	String parserPath;
	String treeParserPath;
	/** Set up appropriate class path for parser/tree parser if using package */
	if ( grammarInfo.getHeader()!=null ) {
		parserPath = grammarInfo.getHeader()+"."+parserName;
		treeParserPath = grammarInfo.getHeader()+"."+grammarInfo.getTreeGrammarName();
	}
	else {
		parserPath = parserName;
		treeParserPath = grammarInfo.getTreeGrammarName();
	}
	/** Set up different parser executer for parser grammar and tree grammar */
	if ( grammarInfo.getTreeGrammarName()!=null ) {	// Load template for testing tree grammar
		supportingMethodST = group.getInstanceOf("execTreeParser");
		supportingMethodST.setAttribute("treeParserName", grammarInfo.getTreeGrammarName());
		supportingMethodST.setAttribute("treeParserPath", treeParserPath);
	}
	else {	// Load template for testing grammar
		supportingMethodST = group.getInstanceOf("execParser");
	}
	supportingMethodST.setAttribute("lexerName", lexerName);
	supportingMethodST.setAttribute("parserName", parserName);
	supportingMethodST.setAttribute("parserPath", parserPath);
	return supportingMethodST.toString();
}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
public void writeConfigurations ( ) throws FileNotFoundException , IOException {
	StringTemplateGroup templateGroup = new StringTemplateGroup( "ch.epfl.gsn" );
	StringTemplate st = templateGroup.getInstanceOf( "ch.epfl.gsn/gui/templates/templateConf" );
	st.setAttribute( "db_user" , storage.getJdbcUsername( ) );
	st.setAttribute( "db_password" , storage.getJdbcPassword( ) );
	st.setAttribute( "db_driver" , storage.getJdbcDriver( ) );
	st.setAttribute( "db_url" , storage.getJdbcURL( ) );

	FileWriter writer = new FileWriter( gsnConfigurationFileName );
	writer.write( st.toString( ) );
	writer.close( );

}
 

import org.antlr.stringtemplate.StringTemplateGroup; //导入方法依赖的package包/类
public TedsToVirtualSensor ( String templateDir , String templateFile ) {
   this.templateDir = templateDir;
   this.templatefile = templateFile;
   StringTemplateGroup grp = new StringTemplateGroup( "myGroup" , templateDir );
   vstmp = grp.getInstanceOf( templateFile );
   
}