com.opengamma.financial.analytics.LabelledObjectMatrix1D.java Source code

Introduction

Here is the source code for com.opengamma.financial.analytics.LabelledObjectMatrix1D.java

Source

/**
 * Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.financial.analytics;

import java.util.Arrays;

import org.apache.commons.lang.Validate;

import com.opengamma.financial.analytics.QuickSorter.ArrayQuickSorter;

/**
 * @param <TKey>  the type of the keys
 * @param <TValue>  the type of the values
 * @param <TTolerance>  the type of the tolerance
 */
public abstract class LabelledObjectMatrix1D<TKey extends Comparable<? super TKey>, TValue, TTolerance> {

    private final String _labelsTitle;
    private final String _valuesTitle;
    private final TKey[] _keys;
    private final Object[] _labels;
    private final TValue[] _values;
    private final TTolerance _defaultTolerance;

    public LabelledObjectMatrix1D(final TKey[] keys, final TValue[] values, final TTolerance defaultTolerance) {
        this(keys, LabelledMatrixUtils.toString(keys), values, defaultTolerance);
    }

    public LabelledObjectMatrix1D(final TKey[] keys, final Object[] labels, final TValue[] values,
            final TTolerance defaultTolerance) {
        this(keys, labels, null, values, null, defaultTolerance);
    }

    public LabelledObjectMatrix1D(final TKey[] keys, final String labelsTitle, final TValue[] values,
            final String valuesTitle, final TTolerance defaultTolerance) {
        this(keys, LabelledMatrixUtils.toString(keys), labelsTitle, values, valuesTitle, defaultTolerance);
    }

    public LabelledObjectMatrix1D(TKey[] keys, Object[] labels, String labelsTitle, TValue[] values,
            String valuesTitle, TTolerance defaultTolerance) {
        Validate.notNull(keys, "labels");
        Validate.notNull(labels, "label names");
        Validate.notNull(values, "values");
        final int n = keys.length;
        Validate.isTrue(n == labels.length, "length of keys array must match length of label names array");
        Validate.isTrue(n == values.length, "length of keys array must match length of values array");
        _keys = Arrays.copyOf(keys, n);
        _labels = Arrays.copyOf(labels, n);
        _labelsTitle = labelsTitle;
        _values = Arrays.copyOf(values, n);
        _valuesTitle = valuesTitle;
        _defaultTolerance = defaultTolerance;
        quickSort();
    }

    public TKey[] getKeys() {
        return _keys;
    }

    public Object[] getLabels() {
        return _labels;
    }

    public String getLabelsTitle() {
        return _labelsTitle;
    }

    public TValue[] getValues() {
        return _values;
    }

    public String getValuesTitle() {
        return _valuesTitle;
    }

    public int size() {
        return _keys.length;
    }

    protected TTolerance getDefaultTolerance() {
        return _defaultTolerance;
    }

    /**
     * Compares two keys and indicates whether the first would be considered less than, equal to or greater than the
     * second.
     * 
     * @param key1  the first key to compare, not null
     * @param key2  the second key to compare, not null
     * @param tolerance  the tolerance for equality of the keys
     * @return the value 0 if {@code key1} is equal to {@code key2}; a value less than 0 if {@code key1} is less than
     *         {@code key2}; and a value greater than 0 if {@code key1} is greater than {@code key2}.
     */
    public abstract int compare(TKey key1, TKey key2, TTolerance tolerance);

    /**
     * Compares two keys using the default equality tolerance, and indicates whether the first would be considered less
     * than, equal to or greater than the second.
     * 
     * @param key1  the first key to compare, not null
     * @param key2  the second key to compare, not null
     * @return the value 0 if {@code key1} is equal to {@code key2}; a value less than 0 if {@code key1} is less than
     *         {@code key2}; and a value greater than 0 if {@code key1} is greater than {@code key2}.
     */
    public int compare(final TKey key1, final TKey key2) {
        return compare(key1, key2, getDefaultTolerance());
    }

    private void quickSort() {
        (new ArrayQuickSorter<TKey>(_keys) {

            @Override
            protected int compare(final TKey first, final TKey second) {
                return LabelledObjectMatrix1D.this.compare(first, second);
            }

            @Override
            protected void swap(final int first, final int second) {
                super.swap(first, second);
                swap(_labels, first, second);
                swap(_values, first, second);
            }

        }).sort();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + Arrays.hashCode(_keys);
        result = prime * result + Arrays.hashCode(_labels);
        result = prime * result + ((_labelsTitle == null) ? 0 : _labelsTitle.hashCode());
        result = prime * result + Arrays.hashCode(_values);
        result = prime * result + ((_valuesTitle == null) ? 0 : _valuesTitle.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final LabelledObjectMatrix1D<?, ?, ?> other = (LabelledObjectMatrix1D<?, ?, ?>) obj;
        if (!Arrays.equals(_keys, other._keys)) {
            return false;
        }
        if (!Arrays.equals(_labels, other._labels)) {
            return false;
        }
        if (_labelsTitle == null) {
            if (other._labelsTitle != null) {
                return false;
            }
        } else if (!_labelsTitle.equals(other._labelsTitle)) {
            return false;
        }
        if (!Arrays.equals(_values, other._values)) {
            return false;
        }
        if (_valuesTitle == null) {
            if (other._valuesTitle != null) {
                return false;
            }
        } else if (!_valuesTitle.equals(other._valuesTitle)) {
            return false;
        }
        return true;
    }

}