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/StreamFactory.hpp>
#include <ers/Severity.hpp>
#include <ers/ers.hpp>
#include <ers/internal/Util.hpp>
#include <ers/internal/NullStream.hpp>
#include <ers/internal/PluginManager.hpp>
#include <ers/internal/macro.hpp>
#include <ers/internal/SingletonCreator.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;
}