Java ImmutableMap.builder方法代码示例

import org.trimou.util.ImmutableMap; //导入方法依赖的package包/类
/**
 *
 * @param generatedId
 * @param name
 * @param engine
 * @param nestedTemplates
 */
public Template(Long generatedId, String name, MustacheEngine engine,
        List<Template> nestedTemplates) {
    this.generatedId = generatedId;
    this.name = name;
    this.engine = engine;
    this.globalExecutionContext = ExecutionContexts
            .newGlobalExecutionContext(engine.getConfiguration());
    if (nestedTemplates == null || nestedTemplates.isEmpty()) {
        this.nestedTemplates = Collections.emptyMap();
    } else {
        ImmutableMapBuilder<String, Template> builder = ImmutableMap
                .builder();
        for (Template template : nestedTemplates) {
            builder.put(template.getName(), template);
        }
        this.nestedTemplates = builder.build();
    }
}
 

import org.trimou.util.ImmutableMap; //导入方法依赖的package包/类
@Override
protected Map<String, Object> getMap(Options options) {
    ImmutableMapBuilder<String, Object> builder = ImmutableMap.builder();
    for (Entry<String, Object> entry : options.getHash().entrySet()) {
        if (entry.getValue() instanceof String) {
            // String is expected to be an EL expression
            builder.put(entry.getKey(), Expressions.eval(entry.getValue().toString(), options, configuration));
        } else {
            builder.put(entry.getKey(), entry.getValue());
        }
    }
    return builder.build();
}
 

import org.trimou.util.ImmutableMap; //导入方法依赖的package包/类
/**
 *
 * @return all collected data
 */
public Map<String, Map<Long, Long>> getData() {
    if (data.size() == 0) {
        return Collections.emptyMap();
    }
    ImmutableMapBuilder<String, Map<Long, Long>> builder = ImmutableMap
            .builder();
    for (Entry<String, ComputingCache<Long, AtomicLong>> entry : data
            .getAllPresent().entrySet()) {
        builder.put(entry.getKey(),
                getImmutableTemplateData(entry.getValue()));
    }
    return builder.build();
}
 

import org.trimou.util.ImmutableMap; //导入方法依赖的package包/类
private Map<Long, Long> getImmutableTemplateData(
        ComputingCache<Long, AtomicLong> templateData) {
    ImmutableMapBuilder<Long, Long> builder = ImmutableMap.builder();
    for (Entry<Long, AtomicLong> entry : templateData.getAllPresent()
            .entrySet()) {
        builder.put(entry.getKey(), entry.getValue().get());
    }
    return builder.build();
}
 

import org.trimou.util.ImmutableMap; //导入方法依赖的package包/类
@Override
public Map<K, V> getAllPresent() {
    ImmutableMapBuilder<K, V> builder = ImmutableMap.builder();
    for (Entry<K, CacheEntry<V>> entry : map.entrySet()) {
        if (!entry.getValue().isExpired(expirationTimeout)) {
            builder.put(entry.getKey(), entry.getValue().value);
        }
    }
    return builder.build();
}
 

import org.trimou.util.ImmutableMap; //导入方法依赖的package包/类
private HelpersBuilder() {
    this.builder = ImmutableMap.builder();
}
 

import org.trimou.util.ImmutableMap; //导入方法依赖的package包/类
/**
 *
 * @param name
 * @param configuration
 * @param segment
 * @return a handler for the given name or <code>null</code> if no such
 *         helper exists
 */
static HelperExecutionHandler from(String name, MustacheEngine engine,
        HelperAwareSegment segment) {

    // Split the name and detect unterminated literals
    Iterator<String> parts = splitHelperName(name, segment);

    Helper helper = engine.getConfiguration().getHelpers()
            .get(parts.next());

    if (helper == null) {
        // No helper with the given name found
        return null;
    }

    ImmutableListBuilder<Object> params = ImmutableList.builder();
    ImmutableMapBuilder<String, Object> hash = ImmutableMap.builder();
    LiteralSupport literalSupport = engine.getConfiguration()
            .getLiteralSupport();

    while (parts.hasNext()) {
        // Next part is a param or a hash entry
        String part = parts.next();
        if (Strings.isListLiteral(part)) {
            params.add(new ListValuePlaceholder(part, engine,
                    literalSupport, segment));
        } else {
            int equalsPosition = getFirstDeterminingEqualsCharPosition(
                    part);
            if (equalsPosition != -1) {
                String value = part.substring(equalsPosition + 1,
                        part.length());
                if (Strings.isListLiteral(value)) {
                    hash.put(part.substring(0, equalsPosition),
                            new ListValuePlaceholder(value, engine,
                                    literalSupport, segment));
                } else {
                    hash.put(part.substring(0, equalsPosition),
                            getLiteralOrPlaceholder(value, engine, segment,
                                    literalSupport));
                }
            } else {
                params.add(getLiteralOrPlaceholder(part, engine, segment,
                        literalSupport));
            }
        }
    }

    OptionsBuilder optionsBuilder = new OptionsBuilder(params.build(),
            hash.build(), segment, engine);

    // Let the helper validate the tag definition
    helper.validate(optionsBuilder);

    return new HelperExecutionHandler(helper, optionsBuilder);
}