translator.hpp

Go to the documentation of this file.

/*
 *
 *                   _/_/_/    _/_/   _/    _/ _/_/_/    _/_/
 *                  _/   _/ _/    _/ _/_/  _/ _/   _/ _/    _/
 *                 _/_/_/  _/_/_/_/ _/  _/_/ _/   _/ _/_/_/_/
 *                _/      _/    _/ _/    _/ _/   _/ _/    _/
 *               _/      _/    _/ _/    _/ _/_/_/  _/    _/
 *
 *             ***********************************************
 *                              PandA Project
 *                     URL: http://panda.dei.polimi.it
 *                       Politecnico di Milano - DEIB
 *                        System Architectures Group
 *             ***********************************************
 *              Copyright (C) 2004-2024 Politecnico di Milano
 *
 *   This file is part of the PandA framework.
 *
 *   The PandA framework is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef TRANSLATOR_HPP
#define TRANSLATOR_HPP

#include <ios>
#include <list>
#include <string>
#include <vector>

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "refcount.hpp"
#include <boost/preprocessor/facilities/empty.hpp>
#include <boost/preprocessor/seq/for_each.hpp>

CONSTREF_FORWARD_DECL(Parameter);
enum class Parameters_FileFormat;
REF_FORWARD_DECL(XMLDomParser);

#define TEXT_FORMAT (text)(number)(exponential)

#define TF_ENUM(r, data, elem) BOOST_PP_CAT(TF_, elem),

#define COMPARISON_OPERATOR (abs_le)

#define CO_ENUM(r, data, elem) BOOST_PP_CAT(CO_, elem),

#define TOTAL_FORMAT (average)(overall)(none)

#define TOF_ENUM(r, data, elem) BOOST_PP_CAT(TOF_, elem),

class Translator
{
 private:
   const ParameterConstRef Param;

   int debug_level;

   class LatexColumnFormat
   {
    public:
      using TextFormat = enum { BOOST_PP_SEQ_FOR_EACH(TF_ENUM, BOOST_PP_EMPTY, TEXT_FORMAT) };

      using ComparisonOperator = enum { BOOST_PP_SEQ_FOR_EACH(CO_ENUM, BOOST_PP_EMPTY, COMPARISON_OPERATOR) };

      using TotalFormat = enum { BOOST_PP_SEQ_FOR_EACH(TOF_ENUM, BOOST_PP_EMPTY, TOTAL_FORMAT) };

    private:
      static CustomUnorderedMap<std::string, TextFormat> string_to_TF;

      static CustomUnorderedMap<std::string, ComparisonOperator> string_to_CO;

      static CustomUnorderedMap<std::string, TotalFormat> string_to_TOF;

    public:
      std::string column_name;

      std::vector<std::string> columns_prefix;

      std::string source_name;

      std::string column_alignment;

      TextFormat text_format;

      std::streamsize precision;

      CustomUnorderedSet<std::string> compared_columns;

      ComparisonOperator comparison_operator;

      TotalFormat total_format;

      LatexColumnFormat();

      static TextFormat get_TF(const std::string& string);

      static ComparisonOperator get_CO(const std::string& string);

      static TotalFormat GetTotalFormat(const std::string& string);

      static bool Compare(const long double A, const ComparisonOperator comparator, const long double B);
   };

   void get_normalization(CustomUnorderedMap<std::string, long double>& normalization) const;

   std::string get_exponential_notation(const std::string& input) const;

   static void replace_underscore(std::string& ioString);

   void read_column_formats(const XMLDomParserRef parser, std::list<LatexColumnFormat>& latex_column_formats,
                            size_t& max_column_width) const;

 public:
   explicit Translator(const ParameterConstRef Param);

   void
   write_to_csv(const std::map<std::string, CustomOrderedSet<std::string>>& tags,
                const CustomUnorderedMap<
                    std::string,
                    CustomUnorderedMapStable<std::string, CustomUnorderedMapStable<std::string, long double>>>& results,
                const std::string& file_name) const;

   void write_to_csv(const std::map<std::string, CustomMap<std::string, std::string>>& results,
                     const std::string& file_name) const;

   void
   write_to_pa(const std::map<std::string, CustomOrderedSet<std::string>>& tags,
               const CustomUnorderedMap<
                   std::string,
                   CustomUnorderedMapStable<std::string, CustomUnorderedMapStable<std::string, long double>>>& results,
               const std::string& file_name) const;

   void write_to_latex(std::map<std::string, CustomMap<std::string, std::string>>& results,
                       const Parameters_FileFormat input_format, const std::string& file_name) const;

   void merge_pa(
       const std::map<std::string, CustomOrderedSet<std::string>>& tags,
       const CustomUnorderedMap<std::string, CustomOrderedSet<std::string>>& keys,
       const CustomUnorderedMap<
           std::string, CustomUnorderedMapStable<std::string, CustomUnorderedMapStable<std::string, long double>>>&
           input_data,
       const CustomUnorderedMap<
           std::string, CustomUnorderedMapStable<std::string, CustomUnorderedMapStable<std::string, long double>>>&
           merge_data,
       CustomUnorderedMap<std::string,
                          CustomUnorderedMapStable<std::string, CustomUnorderedMapStable<std::string, long double>>>&
           output_data) const;

   static void AggregateAndClean(std::map<std::string, std::map<std::string, long double>>& data,
                                 CustomOrderedSet<std::string>& column_names, const ParameterConstRef param);
};

using TranslatorConstRef = refcount<const Translator>;
#endif