StreamFactory.cpp

Go to the documentation of this file.

/*
 * DUNE DAQ modification notice:
 * This file has been modified from the original ATLAS ers source for the DUNE DAQ project.
 * Fork baseline commit: 8267df82a4f6fe6bf02c4014923eba19eddc4614 (2020-04-14).
 * Renamed since fork: yes (from src/StreamFactory.cxx to src/StreamFactory.cpp).
 *
 * Original copyright:
 * Copyright (C) 2001-2020 CERN for the benefit of the ATLAS collaboration.
 * Licensed under the Apache License, Version 2.0.
 */
 
/*
 *  StreamFactory.cxx
 *  ERS
 *
 *  Created by Serguei Kolos on 21.01.05.
 *  Modified by Serguei Kolos on 21.11.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include <iostream>
 
#include <ers/Issue.hpp>
#include <ers/OutputStream.hpp>
#include <ers/Severity.hpp>
#include <ers/StreamFactory.hpp>
#include <ers/ers.hpp>
#include <ers/internal/NullStream.hpp>
#include <ers/internal/PluginManager.hpp>
#include <ers/internal/SingletonCreator.hpp>
#include <ers/internal/Util.hpp>
#include <ers/internal/macro.hpp>

ers::StreamFactory&
ers::StreamFactory::instance()
{
  static ers::StreamFactory* instance = ers::SingletonCreator<ers::StreamFactory>::create();
 
  return *instance;
} // instance

ers::OutputStream*
ers::StreamFactory::create_out_stream(const std::string& format) const
{
  std::string key = format;
  std::string param;
  std::string::size_type start = format.find('(');
  if (start != std::string::npos) {
    key = format.substr(0, start);
    std::string::size_type end = format.find(')', start);
    if (end != std::string::npos)
      param = format.substr(start + 1, end - start - 1);
  }
 
  OutFunctionMap::const_iterator it = m_out_factories.find(key);
 
  if (it != m_out_factories.end()) {
    try {
      return it->second(param);
    } catch (ers::Issue& issue) {
      ERS_INTERNAL_ERROR(issue)
    }
  } else {
    ERS_INTERNAL_ERROR("Creator for the \"" << key << "\" stream is not found")
  }
 
  return 0;
}

ers::InputStream*
ers::StreamFactory::create_in_stream(const std::string& stream, const std::string& param) const
{
  return create_in_stream(stream, { param });
}

ers::InputStream*
ers::StreamFactory::create_in_stream(const std::string& stream, const std::initializer_list<std::string>& params) const
{
  InFunctionMap::const_iterator it = m_in_factories.find(stream);
 
  if (it != m_in_factories.end()) {
    try {
      return it->second(params);
    } catch (ers::Issue& issue) {
      throw ers::InvalidFormat(ERS_HERE, stream, issue);
    }
  }
 
  throw ers::InvalidFormat(ERS_HERE, stream);
}

void
ers::StreamFactory::register_in_stream(const std::string& name, InputStreamCreator callback)
{
  m_in_factories[name] = callback;
}

void
ers::StreamFactory::register_out_stream(const std::string& name, OutputStreamCreator callback)
{
  m_out_factories[name] = callback;
}
 
std::ostream&
ers::operator<<(std::ostream& out, const ers::StreamFactory& sf)
{
  StreamFactory::OutFunctionMap::const_iterator oit = sf.m_out_factories.begin();
  for (; oit != sf.m_out_factories.end(); ++oit) {
    out << oit->first << "\t\"" << oit->second << "\"" << std::endl;
  }
 
  StreamFactory::InFunctionMap::const_iterator iit = sf.m_in_factories.begin();
  for (; iit != sf.m_in_factories.end(); ++iit) {
    out << iit->first << "\t\"" << iit->second << "\"" << std::endl;
  }
  return out;
}