Method.h

/*
 * Method.h
 *
 *  Created on: Dec 16, 2016
 *      Author: wfg
 */

#ifndef METHOD_H_
#define METHOD_H_

/// \cond EXCLUDE_FROM_DOXYGEN
#include <vector>
#include <string>
#include <map>
/// \endcond

#include "ADIOSTypes.h"
#include "functions/adiosFunctions.h"

namespace adios
{

typedef enum {
    GLOBAL_READERS = 2, ROUNDROBIN_READERS = 3, FIFO_READERS = 4,
    OPEN_ALL_STEPS = 5
} ReadMultiplexPattern;

typedef enum { NOWAITFORSTREAM = 0, WAITFORSTREAM = 1 } StreamOpenMode; // default: wait for stream

/**
 * Serves as metadata to define an engine
 */
class Method
{

public:

    const std::string m_Name; ///< Method name (as defined in XML)
    const bool m_DebugMode = false; ///< true: on, throws exceptions and do additional checks, false: off, faster, but unsafe
    int m_nThreads;
    std::string m_Type; ///< Method's engine type
    std::map<std::string, std::string> m_Parameters; ///< method parameters
    std::vector< std::map<std::string, std::string> > m_TransportParameters; ///< each is a separate Transport containing their own parameters

    /**
     * Constructor
     * @param name is a label that can be used in the config file to set up the method at runtime
     */
    Method( const std::string name, const bool debugMode = false );

    ~Method( );

    /** Check if the method was defined by the user in the config file.
     * @return true if the method was user-defined, false otherwise when method is set with default parameters
     */
    bool isUserDefined();


    /**
     * Define the engine type
     * @param type must be a valid engine type
     */
    void SetEngine( const std::string type );


    /**
     * Set how many threads the engine can use for its operations (e.g. file io, compression, staging).
     * If 1 is allowed, no extra threads will be created during the ADIOS calls for asynchronous operations.
     * Note that some transports may require and use extra thread(s). See their documentation for their
     * requirements. E.g. some staging transports always create an extra thread for communication.
     * Set this parameter like you set it for OpenMP, i.e. count one thread for the main process that calls
     * ADIOS functions.
     * @param number of threads, minimum 1 is required
     */
    void AllowThreads( const int nThreads );

    /**
     * Sets parameters for the method in "parameter=value" format
     * @param args list of parameters with format "parameter1=value1", ..., "parameterN=valueN"
     */
    template< class ...Args>
    void SetParameters( Args... args )
    {
        std::vector<std::string> parameters = { args... };
        m_Parameters = BuildParametersMap( parameters, m_DebugMode );
    }

    /**
     * Adds a transport and its parameters for the method
     * @param type must be a supported transport type under /include/transport
     * @param args list of parameters for a transport with format "parameter1=value1", ..., "parameterN=valueN"
     */
    template< class ...Args>
    void AddTransport( const std::string type, Args... args )
    {
        std::vector<std::string> parameters = { args... };
        AddTransportParameters( type, parameters );
    }

    void SetReadMultiplexPattern( const ReadMultiplexPattern pattern );  // How to split stream content among readers
    void SetStreamOpenMode( const StreamOpenMode mode);  // In Read mode, should Open() wait for the first step appear  (default)

    void SetVerbose( const Verbose verbose = Verbose::WARN ) { m_Verbose = verbose; };
    Verbose GetVerbose( ) { return m_Verbose; };

private:
    Verbose m_Verbose = Verbose::WARN;

    void AddTransportParameters( const std::string type, const std::vector<std::string>& parameters );

};


} //end namespace

#endif /* METHOD_H_ */