com.opengamma.integration.timeseries.snapshot.RedisLKVFileReader.java Source code

Introduction

Here is the source code for com.opengamma.integration.timeseries.snapshot.RedisLKVFileReader.java

Source

/**
 * Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.integration.timeseries.snapshot;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Map;

import org.apache.commons.io.IOUtils;
import org.fudgemsg.FudgeContext;
import org.fudgemsg.FudgeMsg;
import org.fudgemsg.wire.FudgeMsgReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.Maps;
import com.opengamma.OpenGammaRuntimeException;
import com.opengamma.id.ExternalId;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.fudgemsg.OpenGammaFudgeContext;
import com.opengamma.util.monitor.OperationTimer;

/**
 * Reads the last known values for all fields from a file written from Redis lkv values 
 * at a specific observation time
 */
public class RedisLKVFileReader {

    private static final Logger s_logger = LoggerFactory.getLogger(RedisLKVFileReader.class);
    private static final FudgeContext s_fudgeContext = OpenGammaFudgeContext.getInstance();

    private final File _inputFile;
    private final Map<String, Boolean> _dataFieldBlackList = Maps.newHashMap();
    private final Map<String, Boolean> _schemeBlackList = Maps.newHashMap();

    public RedisLKVFileReader(final File inputFile, final BlackList schemeBlackList,
            final BlackList dataFieldBlackList) {
        ArgumentChecker.notNull(inputFile, "input file");
        ArgumentChecker.notNull(schemeBlackList, "scheme black list");
        ArgumentChecker.notNull(dataFieldBlackList, "data field black list");

        _inputFile = inputFile;
        for (String dataField : dataFieldBlackList.getBlackList()) {
            _dataFieldBlackList.put(dataField.toUpperCase(), Boolean.TRUE);
        }
        for (String scheme : schemeBlackList.getBlackList()) {
            _schemeBlackList.put(scheme.toUpperCase(), Boolean.TRUE);
        }
    }

    /**
     * Gets the inputFile.
     * @return the inputFile
     */
    public File getInputFile() {
        return _inputFile;
    }

    public Map<ExternalId, Map<String, Double>> getLastKnownValues() {
        OperationTimer timer = new OperationTimer(s_logger, "Reading LKV from disk");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(getInputFile());
        } catch (FileNotFoundException ex) {
            throw new OpenGammaRuntimeException("Error opening file " + getInputFile().getAbsolutePath(), ex);
        }
        Map<ExternalId, Map<String, Double>> ticks = Maps.newHashMap();
        FudgeMsgReader reader = s_fudgeContext.createMessageReader(fis);
        try {
            while (reader.hasNext()) {
                FudgeMsg message = reader.nextMessage();
                ExternalId securityId = ExternalId.parse(message.getString(RedisLKVFileWriter.SECURITY));
                if (_schemeBlackList.containsKey(securityId.getScheme().getName())) {
                    continue;
                }
                FudgeMsg ticksMsg = message.getMessage(RedisLKVFileWriter.TICKS);
                Map<String, Double> secTicks = Maps.newHashMap();
                for (String fieldName : ticksMsg.getAllFieldNames()) {
                    if (_dataFieldBlackList.containsKey(fieldName.toUpperCase())) {
                        continue;
                    }
                    secTicks.put(fieldName, ticksMsg.getDouble(fieldName));
                }
                ticks.put(securityId, secTicks);
            }
        } finally {
            IOUtils.closeQuietly(fis);
        }
        timer.finished();
        return ticks;
    }

}