com.opengamma.bbg.referencedata.statistics.Snapshot.java Source code

Introduction

Here is the source code for com.opengamma.bbg.referencedata.statistics.Snapshot.java

Source

/**
 * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.bbg.referencedata.statistics;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

import com.google.common.base.Supplier;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;
import com.opengamma.util.tuple.LongObjectPair;

/**
 * A snapshot of the statistics.
 */
public class Snapshot {
    private final long _totalLookups;
    private final List<LongObjectPair<String>> _lookupsBySecurity;
    private final List<LongObjectPair<String>> _lookupsByField;

    public Snapshot(Map<String, Long> lookupsBySecurity, Map<String, Long> lookupsByField) {
        super();
        _lookupsByField = reverseOrder(lookupsByField);
        _lookupsBySecurity = reverseOrder(lookupsBySecurity);

        //Assume that fields is smaller than security
        long lookups = 0;
        for (LongObjectPair<String> point : _lookupsByField) {
            lookups += point.getFirstLong();
        }
        _totalLookups = lookups;
    }

    private static final Supplier<ArrayList<String>> ARRAY_LIST_SUPPLIER = new Supplier<ArrayList<String>>() {
        @Override
        public ArrayList<String> get() {
            return new ArrayList<String>();
        }
    };
    private static final Comparator<Long> DESCENDING_COMPARATOR = new Comparator<Long>() {

        @Override
        public int compare(Long o1, Long o2) {
            return o2.compareTo(o1);
        }
    };

    private List<LongObjectPair<String>> reverseOrder(Map<String, Long> forward) {
        ListMultimap<Long, String> index = index(forward);
        int size = forward.size();
        return flatten(index, size);
    }

    private List<LongObjectPair<String>> flatten(ListMultimap<Long, String> index, int size) {
        List<LongObjectPair<String>> reverse = new ArrayList<LongObjectPair<String>>(size);
        for (Entry<Long, String> entry : index.entries()) {
            reverse.add(LongObjectPair.of((long) entry.getKey(), entry.getValue()));
        }
        return reverse;
    }

    private ListMultimap<Long, String> index(Map<String, Long> forward) {
        ListMultimap<Long, String> index = Multimaps
                .newListMultimap(new TreeMap<Long, Collection<String>>(DESCENDING_COMPARATOR), ARRAY_LIST_SUPPLIER);
        for (Entry<String, Long> e : forward.entrySet()) {
            index.put(e.getValue(), e.getKey());
        }
        return index;
    }

    public long getTotalLookups() {
        return _totalLookups;
    }

    public long getDistinctSecurities() {
        return _lookupsBySecurity.size();
    }

    /**
     * Gets the distinctFields field.
     * @return the distinctFields
     */
    public long getDistinctFields() {
        return _lookupsByField.size();
    }

    public List<LongObjectPair<String>> getLookupsBySecurity() {
        return _lookupsBySecurity;
    }

    public List<LongObjectPair<String>> getLookupsByField() {
        return _lookupsByField;
    }
}