source: observatorio/simulacion/SimEscenariosEconomicos/indicatorGenerator.H

/*
  Copyright (C) 2012
  Alejandro Mujica (amujica@cenditel.gob.ve)
  Erwin Paredes (eparedes@cenditel.gob.ve)
  José Ruiz (jruiz@cenditel.gob.ve)
  Rodolfo Rangel (rrangel@cenditel.gob.ve)
  Julie Vera (jvera@cenditel.gob.ve)
 
  CENDITEL Fundación Centro Nacional de Desarrollo e Investigación en
  Tecnologías Libres
 
  Este programa es software libre; Usted puede usarlo bajo los términos de la
  licencia de software GPL versión 2.0 de la Free Software Foundation.
 
  Este programa se distribuye con la esperanza de que sea útil, pero SIN
  NINGUNA GARANTÍA; tampoco las implícitas garantías de MERCANTILIDAD o
  ADECUACIÓN A UN PROPÓSITO PARTICULAR.
  Consulte la licencia GPL para más detalles. Usted debe recibir una copia
  de la GPL junto con este programa; si no, escriba a la Free Software
  Foundation Inc. 51 Franklin Street,5 Piso, Boston, MA 02110-1301, USA.
*/

/*
  Autor:             Alejandro J. Mujica
  Fecha de creación: 25/11/2013
  Este archivo contiene las definiciones de las clases para la generación de
  indicadores.
*/

# ifndef INDICATOR_GENERATOR_H
# define INDICATOR_GENERATOR_H

# include <productionNetwork.H>

# include <ioManager.H>

class IndicatorGenerator {

public:
    virtual std::string generate(Graph & g, const std::string & path,
                                 const std::string & year) = 0;

};

class ProductionIndicatorGenerator : public IndicatorGenerator {

    static const std::string PRODUCT_INPUT_FILE_NAME;

    static const std::string PRODUCT_FILE_NAME;

    struct WriteLevels {

        std::string & levels;

        WriteLevels(std::string & _levels) : levels(_levels) {
            // Empty
        }

        void operator () (const long & level) {

            std::stringstream str;

            str << level << ", ";

            levels.append(str.str());
        }
    };

    /** Escribe una línea de información de un producto en un archivo.
     *
     * @param conn Conexión a la base de datos.
     * @param node nodo que contiene la informac1ión del producto.
     * @param file flujo de salida para el archivo.
     * @param mapPlantLocation buffer con ubicaciones de plantas.
     * @param mapPlantLocation buffer con ciiu de las empresas.
     */
     void writeProductLine(AutoConnection & conn,
                           Graph::Node * node, std::ofstream & file,
                           Map <long, PlantLocation> & mapPlantLocation,
                           Map <std::string, std::string> &
                           mapCompanyCiiu);

    /** Escribe una línea de información de un insumo en un archivo.
     *
     * @param conn Conexión a la base de datos.
     * @param arc arco del insumo.
     * @param file flujo de salida para el archivo.
     * @param mapPlantLocation buffer con ubicaciones de plantas.
     * @param mapPlantLocation buffer con ciiu de las empresas.
     */
    void writeInputLine(AutoConnection & conn, Graph & graph,
                        Graph::Arc * arc, std::ofstream & file,
                        Map <long, PlantLocation> & mapPlantLocation,
                        Map <std::string, std::string> &
                        mapCompanyCiiu, const std::string & year);

    /** Escribe un insumo vacío para productos que no tengan insumos.
     *
     * @param file flujo de salida para el archivo.
     */
    void writeEmptyInput(std::ofstream & file);


    /** Genera un archivo .csv con los indicadores de un grafo.
     *
     * @param conn Conexión a la base de datos.
     * @param graph grafo al que se le van a extraer los indicadores.
     * @param path ruta en la cual se va a almacenar el archivo.
     * @param fileName nombre del archivo sobre el cual se va a escribir.
     */
    bool writeProductInputsIndicators(AutoConnection & conn, Graph & graph,
                                      const std::string & path,
                                      const std::string & year);

    void writeProductionInfo(AutoConnection & conn, Graph & graph,
                             Graph::Node * node, const std::string & year,
                             std::ofstream & file);

    bool writeProductIndicators(AutoConnection & conn, Graph & graph,
                                const std::string & path,
                                const std::string & year);

public:
    std::string generate(Graph & g, const std::string & path,
                         const std::string & year);

};

class CostIndicatorGenerator : public IndicatorGenerator {

public:
    std::string generate(Graph & g, const std::string & path,
                         const std::string & year);

};

class IndicatorGeneratorFactory {

    static std::unique_ptr <IndicatorGeneratorFactory> instance;

    IndicatorGeneratorFactory();

public:
    static IndicatorGeneratorFactory & getInstance();

    std::unique_ptr <IndicatorGenerator>
    getIndicatorGenerator(const StudyType & type);
};

# endif // INDICATOR_GENERATOR_H