import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
private STGroupDir initSTGroup(Raml raml) {
    final STGroupDir group = loadGroupDir("guru/nidi/raml/doc/st-templates");

    group.registerModelAdaptor(Map.class, new EntrySetMapModelAdaptor());
    group.registerModelAdaptor(Raml.class, new RamlAdaptor());
    group.registerModelAdaptor(Resource.class, new ResourceAdaptor());
    group.registerModelAdaptor(Action.class, new ActionAdaptor(raml));
    group.registerModelAdaptor(SecuritySchemeDescriptor.class, new SecuritySchemeDescriptorAdaptor());
    group.registerModelAdaptor(Response.class, new ResponseAdaptor());

    group.registerRenderer(String.class, new StringRenderer(raml, config.getResourceCache()));
    group.registerRenderer(AbstractParam.class, new ParamRenderer());
    group.registerRenderer(Raml.class, new RamlRenderer());

    return group;
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
private STGroupDir loadGroupDir(String path) {
    try {
        return new STGroupDir(path, '$', '$');
    } catch (IllegalArgumentException e) {
        //websphere classloader needs a trailing / to find directories on the classpath
        //-> add it to check if it exists, and then remove it
        final STGroupDir stGroupDir = new STGroupDir(path + "/", '$', '$');
        final String url = stGroupDir.root.toExternalForm();
        try {
            stGroupDir.root = new URL(url.substring(0, url.length() - 1));
            return stGroupDir;
        } catch (MalformedURLException me) {
            throw new IllegalArgumentException(me);
        }
    }
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
/**
 * Generate the guice module with bindings.
 *
 * @throws IOException
 */
private void generateGuiceModule() throws IOException {
    final Set<Class<?>> classes = getServiceClasses();
    new STGroupDir(getClass().getPackage().getName().replaceAll("\\.", "/"));
    final File generatedSourceDirectory = getTargetSourceDirectory();

    final Map<String, String> stubProxyMap = new HashMap<>();
    for (final Class<?> klass : classes) {
        stubProxyMap.put(getStubClassName(klass), getProxyImplemenationName(klass));
    }

    log("Generating guice module", Project.MSG_ERR);

    final GuiceModuleGenerator moduleGenerator = new GuiceModuleGenerator();
    moduleGenerator.generateGuiceModule(destinationPackage, generatedSourceDirectory,
            stubProxyMap);
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
/**
 * Generate the proxy implementations for the services.
 *
 * @throws IOException
 */
private void generateProxyImplementations() throws IOException {
    final Set<Class<?>> classes = getServiceClasses();
    new STGroupDir(getClass().getPackage().getName().replaceAll("\\.", "/"));
    final File generatedSourceDirectory = getTargetSourceDirectory();

    log("Generating proxies", Project.MSG_ERR);

    final ProxyImplementationGenerator proxyGenerator = new ProxyImplementationGenerator();
    for (final Class<?> klass : classes) {
        proxyGenerator.generateProxy(getStubClassName(klass), getProxyImplemenationName(klass),
                destinationPackage, generatedSourceDirectory);
        log("Generated " + getProxyImplemenationName(klass), Project.MSG_INFO);
    }

}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
private final STGroupDir setupTemplateGroup(String templateRootFolder, StringTemplateConfiguration config) {
            
        //if in production or test
        // when reading the template from disk, do the minification at this point
        // so the STWriter does not have to handle that.
        // (This probably means something like extending STGroup and handle its caching
        // a little differently)
        boolean minimise = mode != Modes.DEV; // probably just as outputHtmlIndented
        
        STGroupDir group = new STFastGroupDir(templateRootFolder, config.delimiterStart, config.delimiterEnd, minimise);
        
        // add the user configurations
        config.adaptors.forEach(group::registerModelAdaptor);
        config.renderers.forEach(group::registerRenderer);
        
        // adding a fallback group that will try to serve from resources instead of webapp/WEB-INF/
//            STGroupDir fallbackGroup = new STRawGroupDir("views", config.delimiterStart, config.delimiterEnd);
//            group.importTemplates(fallbackGroup);
        
        return group;
    }
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
private void doGenerate(Raml raml, List<Raml> ramls) throws IOException {
    final STGroupDir group = initSTGroup(raml);

    if (raml == ramls.get(0)) {
        config.getTarget().mkdirs();
        if (!config.isForceDelete()) {
            checkTargetEmpty(config.getTarget(), config.getResourceCache().getBasedir(), ramls);
        }
        deleteAll(config.getTarget());
        generateBase(raml, group);
    }

    final File target = getTarget(raml);
    target.mkdirs();

    final ST main = group.getInstanceOf("main/main");
    main.add("ramls", ramls);
    main.add("baseUri", config.hasFeature(Feature.TRYOUT) ? config.getBaseUri(raml) : null);
    main.add("download", config.hasFeature(Feature.DOWNLOAD));
    main.add("docson", config.hasFeature(Feature.DOCSON));

    set(main, "raml", raml);
    render(main, "/main/doc", ".", new File(target, "index.html"));

    renderResources(raml, main, target);
    renderSecurity(raml, main, target);
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
private void generateBase(Raml raml, STGroupDir group) throws IOException {
    copyStaticResources(config.getTarget(), STATIC_FILES);
    copyCustomResources(config.getTarget(), CUSTOM_FILES);
    transformLessResources(config.getTarget());

    final ST index = group.getInstanceOf("main/index");
    index.add("firstIndex", filenameFor(raml) + "/index.html");
    render(index, new File(config.getTarget(), "index.html"));
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
@Inject
    public StringTemplateTemplateEngine(TemplateConfigProvider<StringTemplateConfiguration> templateConfig,
                                        JawnConfigurations properties,
                                        DeploymentInfo info,
                                        SiteConfigurationReader configReader) {
        log.warn("Starting the StringTemplateTemplateEngine");
        
        STGroupDir.verbose = false;
        Interpreter.trace = false;

        useCache = !properties.isDev();
        outputHtmlIndented = !properties.isProd();
        mode = properties.getMode();
        
        this.configReader = configReader;
        this.templateLoader = new ContentTemplateLoader<>(info, this);
        templateRootFolder = templateLoader.getTemplateRootFolder();
        
        StringTemplateConfiguration config = new StringTemplateConfiguration();
        
        // Add standard renderers
        // TODO Do some HTML escaping by standard
//        config.registerRenderer(String.class, new StringRenderer());
        
        TemplateConfig<StringTemplateConfiguration> stringTemplateConfig = templateConfig.get();
        if (stringTemplateConfig != null) {
            stringTemplateConfig.init(config);
        }
        
        group = setupTemplateGroup(templateRootFolder, config);
    }
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
public static void main(String[] args) {
	STGroupDir templates = new STGroupDir(".");
	ST st = templates.getInstanceOf("page");

	st.add("users", new MyUser(143, "parrt"));
	st.add("users", new MyUser(3, "tombu"));
	st.add("users", new MyUser(99, "kg9s"));

	Map<String,String> phones = new HashMap<String, String>();
	phones.put("parrt", "x5707");
	phones.put("tombu", "x5302");
	st.add("phones", phones);
	System.out.println(st.render());
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
public static void main(String[] args) {
	String[] names = {"Terence", "Jim", "Ketaki", "Siddharth"};
	String[] phones = {"x1", "x9", "x2", "x5"};
	User[] users = {new User("Tom", "x99"), new User("Jane","x1")};

	STGroup group = new STGroupDir(".");
	ST st = group.getInstanceOf("fill");
	st.add("names", names);
	st.add("phones", phones);
	st.add("users", users);
	System.out.println(st.toString());
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
public Generator(String pathToGenerate){
    this.symbolTable = new HashMap<>();
    group = new STGroupDir(STpath+"common",'$', '$');
    importsgroup = new STGroupDir(STpath+"imports",'$', '$');
    amgroup = new STGroupDir(STpath+"amchart",'$', '$');
    highgroup = new STGroupDir(STpath+"highchart",'$', '$');
    smartcampusgroup = new STGroupDir(STpath+"smartcampus",'$', '$');
    this.newSymbol("pathToGenerate",pathToGenerate);
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
public CodeGenerator() {
  try {
    URL url = this.getClass().getResource(TEMPLATES_BASEDIR);
    File dir = new File(url.toURI());
    mGroup = new STGroupDir(dir.getAbsolutePath());
  } catch (URISyntaxException e) {
    mLogger.error("Error finding the templates", e);
  }
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
/**
     * Retrieves the string template group.
     * @param path the path.
     * @param lookupPaths the lookup paths.
     * @param errorListener the {@link STErrorListener} instance.
     * @param charset the charset.
     * @return such instance.
     */
    @NotNull
    protected STGroup retrieveUncachedGroup(
        @NotNull final String path,
        @NotNull final List<String> lookupPaths,
        @NotNull final STErrorListener errorListener,
        @NotNull final Charset charset)
    {
        @NotNull final STGroupFile result = new STGroupFile(path, charset.displayName());
//        STGroup.verbose = true;

//        result.importTemplates(new STGroupDir("org/acmsl/queryj/dao", charset.displayName()));
//        result.importTemplates(new STGroupDir("org/acmsl/queryj/vo", charset.displayName()));
        for (@Nullable final String lookupPath : lookupPaths)
        {
            if (lookupPath != null)
            {
                result.importTemplates(new STGroupDir(lookupPath, charset.displayName()));
            }
        }
        result.isDefined(Literals.SOURCE);
        result.setListener(errorListener);

//        STGroup.registerGroupLoader(loader);
//        STroup.registerDefaultLexer(AngleBracketTemplateLexer.class);

//        result = STGroup.loadGroup(path);

        return result;
    }
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
public static void main(String[] args) {
	// all attributes are single-valued:
	ST query =
			new ST("SELECT <column> FROM <table>;");
	query.add("column", "name");
	query.add("table", "User");
	System.out.println("QUERY: "+query.render());

	// if column can be multi-valued, specify a separator
	query = new ST("SELECT <distinct> <column; separator=\", \"> FROM <table>;");
	query.add("column", "name");
	query.add("column", "email");
	query.add("table", "User");
	// uncomment next line to make "DISTINCT" appear in output
	query.add("distinct", "DISTINCT");
	System.out.println("QUERY: "+query.render());

	// specify a template to apply to an attribute
	// Use a template group so we can specify the start/stop chars
	ST list = new ST("<ul>$items$</ul>", '$', '$');
	// demonstrate setting arg to anonymous subtemplate
	// could use $item[i]$ in template, but want to show args here.
	ST item = new ST("$item:{x | <li>x</li>}$", '$', '$');
	item.add("item", "Terence");
	item.add("item", "Jim");
	item.add("item", "John");
	list.add("items", item); // nested template
	System.out.println("HTML: "+list.render());

	// Look for templates in CLASSPATH as resources
	STGroup mgroup = new STGroupDir(".");
	ST m = mgroup.getInstanceOf("method");
	// "method.st" references body() so "body.st" will be loaded too
	m.add("visibility", "public");
	m.add("name", "foobar");
       m.add("returnType", "void");
       System.out.println("Java: " +m.render());

       ST t = new ST("List:\n"+
                     "$names:{n | <br>$i$. $n$\n}$\n", '$', '$');
       t.add("names", "Terence");
       t.add("names", "Jim");
       t.add("names", "Sriram");
	System.out.println("HTML: " +t.render());
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
private FacadeTemplates(ServletContext context) {
	String realPath = context.getRealPath("tmpl4");
	_stGroupDir = new STGroupDir(realPath, "UTF-8", '$', '$');
}
 

import org.stringtemplate.v4.STGroupDir; //导入依赖的package包/类
/**
 * Constructs the source system query configuration class, based on system
 * settings.
 *
 * @param featureSettings
 *            Feature collector system settings
 */
public FeatureWidgetQueries(FeatureSettings featureSettings) {
	this.featureSettings = featureSettings;
	this.queryFolder = this.featureSettings.getQueryFolder();
	this.folder = new STGroupDir(queryFolder, '$', '$');
}