Example usage for com.google.common.collect Maps.EntryTransformer Maps.EntryTransformer

Introduction

In this page you can find the example usage for com.google.common.collect Maps.EntryTransformer Maps.EntryTransformer.

Prototype

Maps.EntryTransformer

Source Link

Usage

From source file:com.shopzilla.hadoop.repl.HadoopREPL.java

protected Map<Call, Command> buildCommandMappings() {
    final Map<Call, Command> commands = ImmutableMap.<Call, Command>builder()
            .putAll(new SessionCommandProvider().apply(sessionState))
            .putAll(new FSShellCommandProvider().apply(sessionState)).build();
    return ImmutableMap.<Call, Command>builder().putAll(commands)
            .put(call("help", new DeferredStringsCompleter<Map<Call, Command>>(commandMappings,
                    new Function<Map<Call, Command>, TreeSet<String>>() {
                        @Override
                        public TreeSet<String> apply(final Map<Call, Command> calls) {
                            return Sets.newTreeSet(Maps.transformEntries(commandMappings,
                                    new Maps.EntryTransformer<Call, Command, String>() {
                                        @Override
                                        public String transformEntry(final Call key, final Command value) {
                                            return key.commandName();
                                        }
                                    }).values());
                        }/*from w w w.  j  av  a  2 s . com*/
                    })), new Command() {
                        @Override
                        public void execute(final CommandInvocation call, final SessionState sessionState)
                                throws REPL.ExitSignal {
                            if (call.args().length != 1) {
                                sessionState.output("Usage: help [command]");
                            } else {
                                final String command = call.args()[0];
                                if (commandMappings.containsKey(call(command))) {
                                    final Usage usage = commandMappings.get(call(command)).usage(sessionState);
                                    sessionState.output("Displaying help for \"%s\":\n", command);
                                    sessionState.outputUsage(usage);
                                } else {
                                    sessionState.error("Unknown command \"%s\"", command);
                                }
                            }
                        }

                        @Override
                        public Usage usage(final SessionState sessionState) {
                            return new Usage("help", "Displays help / usage information for the given command ",
                                    "<command>");
                        }
                    })
            .build();
}

---

From source file:com.madvay.tools.android.perf.common.Table.java

public Table<AggregateRow> groupAndAggregate(final String groupByColumn, final String weightColumn,
        final AggregationType aggregationType) {
    final RowAdapter<T> adapter = getAdapter();
    final boolean groupNumeric = adapter.types
            .get(adapter.columns.indexOf(groupByColumn)) == RowAdapter.CoerceType.NUMERIC;
    boolean weightNumeric = adapter.types
            .get(adapter.columns.indexOf(weightColumn)) == RowAdapter.CoerceType.NUMERIC;
    ImmutableListMultimap<Object, T> indexed = Multimaps.index(rows, new Function<T, Object>() {
        @Override/*from www  . ja  va2s . c  o m*/
        public Object apply(T input) {
            return adapter.get(input, groupByColumn).toString();
        }
    });
    Map<Object, Long> map = Maps.transformEntries(Multimaps.asMap(indexed),
            new Maps.EntryTransformer<Object, List<T>, Long>() {
                @Override
                public Long transformEntry(Object key, List<T> value) {
                    switch (aggregationType) {
                    case COUNT:
                        return (long) value.size();
                    case SUM: {
                        long l = 0;
                        for (T t : value) {
                            l += Long.parseLong(adapter.get(t, weightColumn).toString());
                        }
                        return l;
                    }
                    case UNIQUE: {
                        Set<String> set = new HashSet<>();
                        for (T t : value) {
                            set.add(adapter.get(t, weightColumn).toString());
                        }
                        return (long) set.size();
                    }
                    }
                    throw new IllegalArgumentException();
                }
            });
    List<AggregateRow> newRows = Lists.newArrayList(
            Iterables.transform(map.entrySet(), new Function<Map.Entry<Object, Long>, AggregateRow>() {
                @Override
                public AggregateRow apply(Map.Entry<Object, Long> input) {
                    return new AggregateRow(input.getValue(), input.getKey());
                }
            }));
    Table<AggregateRow> ret = new Table<AggregateRow>(newRows) {
        final RowAdapter<AggregateRow> adap = new AggregateRow.Adapter(groupNumeric);

        @Override
        public RowAdapter<AggregateRow> getAdapter() {
            return adap;
        }
    };
    return ret;
}

---