basebaseprinter.hpp

Go to the documentation of this file.

//   GAMBIT: Global and Modular BSM Inference Tool
//   *********************************************

#ifndef __base_base_printer_hpp__
#define __base_base_printer_hpp__

// Standard libraries
#include <string>
#include <sstream>
#include <vector>

// Boost
#include <boost/preprocessor/seq/for_each.hpp>

// Gambit
#include "gambit/ScannerBit/printable_types.hpp"
#include "gambit/Utils/standalone_error_handlers.hpp"
#include "gambit/Printers/printer_id_tools.hpp"
#include "gambit/Utils/new_mpi_datatypes.hpp"

namespace Gambit
{
  // Forward declarations needed for some of the _print/_retrieve functions
  class ModelParameters;
  typedef std::map<std::string,double> map_str_dbl; // can't have commas in macro input


  namespace Printers
  {
    // Convenienece typedefs for printers
    typedef unsigned int      uint;
    typedef unsigned long int ulong;
    typedef long long int          longlong;
    typedef unsigned long long int ulonglong;

    template<class T>
    std::size_t getTypeID(void)
    {
       std::ostringstream err;
       err << "getTypeID failed! No typeID known for requested type! (with compiler name: "<<typeid(T).name()<<")";
       printer_error().raise(LOCAL_INFO,err.str());
       return 0;
    }

    class BaseBasePrinter
    {
      private:
        int rank;
        std::set<std::string> print_list; // List of names of data that may be printed (i.e. with printme=true)
        bool resume; // Flag to query to determine if printer is appending points to existing output
        bool printUnitcube; // Flag whether unitCubeParameters should be printed.

      public:
        BaseBasePrinter(): rank(0), printUnitcube(false), printer_enabled(true), printer_cooldown(-1) {}
        virtual ~BaseBasePrinter() {}
        //virtual void flush() {}; // TODO: needed?

        virtual void reset(bool force=false) = 0;

        virtual void flush() = 0;

        int  getRank() {return rank;}
        void setRank(int r) {rank = r;}

        // Retrieve and set the state of the 'printUnitcube' flag
        bool& get_printUnitcube() { return printUnitcube; }
        void set_printUnitcube(const bool& rflag) { printUnitcube = rflag; }

        std::set<std::string> getPrintList() {return print_list;}
        void                  setPrintList(const std::set<std::string>& in) {print_list = in;}
        void                  addToPrintList(const std::string& in) {print_list.insert(in);}

        // Get options required to construct a reader object that can read
        // the previous output of this printer.
        virtual Options resume_reader_options() = 0;

        bool get_resume() { return resume; }
        void set_resume(bool rflag) { resume = rflag; }

        virtual void finalise(bool abnormal=false) = 0;

        void disable(int n=-1)
        {
          if(printer_enabled)
            printer_cooldown = n;   
          printer_enabled = false;
        }

        void enable() { printer_enabled = true;  printer_cooldown = 0;}

        // Printer dispatch function. If a virtual function override exists for
        // the print type, info is passed on, otherwise the function call is resolved
        // to a default function which raises an informative runtime error explaining
        // that the type is not printable.
        template<typename T>
        void print(T const& in, const std::string& label,
                   const int vertexID, const uint rank,
                   const ulong pointID)
        {
          if(printer_enabled) _print(in, label, vertexID, rank, pointID);
          if(printer_cooldown > 0) printer_cooldown--; // if there's a cooldown, reduce it afer printing
          if(!printer_cooldown) printer_enabled = true; // if cooldown has ended, re-enable printer
        }

        // Overload which automatically determines a unique ID code
        // based on the label.
        template<typename T>
        void print(T const& in, const std::string& label,
                   const uint rank,
                   const ulong pointID)
        {
          if(printer_enabled) _print(in, label, rank, pointID);
          if(printer_cooldown > 0) printer_cooldown--; // if there's a cooldown, reduce it afer printing
          if(!printer_cooldown) printer_enabled = true; // if cooldown has ended, re-enable printer
        }

      protected:
        bool printer_enabled;

        int printer_cooldown;

        template<typename T>
        void _print(T const&, const std::string& label,
                    const int vertexID, const uint,
                    const ulong)
        {
          std::ostringstream err;

          err << "Attempted to print a functor whose return type "
              << "is not registered as being printable. "
              << "If you really want to print this functor, you must "
              << "add its return type to the PRINTABLE_TYPES sequence "
              << "in \"gambit/Elements/printable_types.hpp\". You will then have "
              << "to define a print function for it in whatever printer "
              << "you are using (see documentation for GAMBIT printers)."
              << "\n  Available info for this print attempt..."
              << "\n   Label      : " << label
              << "\n   vertexID   : " << vertexID
              << "\n   Type       : " << STRINGIFY(T);
          printer_error().raise(LOCAL_INFO,err.str());
        }

        template<typename T>
        void _print(T const& in, const std::string& label,
                    const uint rank,
                    const ulong pointID)
        {
           _print(in,label,rank,pointID);
        }


        // Virtual print methods for base printer classes
        #define VPRINT(r,data,elem)                                   \
        virtual void _print(elem const&, const std::string& label,    \
                           const int vertexID, const uint /*rank*/,   \
                           const ulong /*pointID*/)                   \
        {                                                             \
          std::ostringstream err;                                     \
                                                                      \
          err << "No print function override has been "               \
              << "\ndefined for this type (for whatever printer"      \
              << "\nclass the current printer comes from)"            \
              << "\n  Dumping available info..."                      \
              << "\n   Label      : " << label                        \
              << "\n   vertexID   : " << vertexID                     \
              << "\n   Type       : " << STRINGIFY(elem);             \
          printer_error().raise(LOCAL_INFO,err.str());                \
        }                                                             \
                                                                      \
        /* version that assigns vertexID automatically */             \
        virtual void _print(elem const& in, const std::string& label, \
                           const uint rank,                           \
                           const ulong pointID)                       \
        {                                                             \
           _print(in,label,get_param_id(label),rank,pointID);         \
        }

        #define ADD_VIRTUAL_PRINTS(TYPES) BOOST_PP_SEQ_FOR_EACH(VPRINT, , TYPES)

        // Add the base virtual functions for registered printable and
        // retrievable types, to be overloaded in each printer.
        ADD_VIRTUAL_PRINTS(SCANNER_PRINTABLE_TYPES)

    };



    class BaseBaseReader
    {
      public:
        virtual ~BaseBaseReader() {};

        virtual void reset() = 0; // Reset 'read head' position to first entry
        virtual ulong get_dataset_length() = 0; // Get length of input dataset (used e.g. by postprocessor to divide post-processing workload via MPI)
        virtual PPIDpair get_current_point() = 0; // Get current rank/ptID pair (i.e. whatever get_next_point() last output)
        virtual ulong    get_current_index() = 0; // Get a linear index which corresponds to the current rank/ptID pair in the iterative sense
        virtual PPIDpair get_next_point() = 0; // Get next rank/ptID pair in data file
        virtual bool eoi() = 0; // Check if 'current point' is past the end of the data file (and thus invalid!)

        template<typename T>
        bool retrieve(T& out, const std::string& label, const uint rank, const ulong pointID)
        {
          return _retrieve(out, label, rank, pointID);
        }

        template<typename T>
        bool retrieve(T& out, const std::string& label)
        {
          bool valid;
          PPIDpair pt = get_current_point();
          // Need to check if the current rank/pointID pair is valid before trying to retrieve from it
          if(pt==nullpoint)
          {
             valid = false;
          } 
          else 
          {
             valid = retrieve(out, label, pt.rank, pt.pointID);
          }
          return valid;
        }

        bool retrieve_and_print(const std::string& label, BaseBasePrinter& printer, const uint rank, const ulong pointID)
        {
           return retrieve_and_print(label, label, printer, rank, pointID);
        }

        virtual bool retrieve_and_print(const std::string& in_label, const std::string& out_label, BaseBasePrinter& printer, const uint rank, const ulong pointID) = 0;

        bool retrieve_and_print(const std::string& label, BaseBasePrinter& printer)
        {
           return retrieve_and_print(label, label, printer);
        }

        bool retrieve_and_print(const std::string& in_label, const std::string& out_label, BaseBasePrinter& printer)
        {
          bool valid;
          PPIDpair pt = get_current_point();
          // Need to check if the current rank/pointID pair is valid before trying to retrieve from it
          if(pt==nullpoint)
          {
             valid = false;
          } 
          else 
          {
             valid = retrieve_and_print(in_label, out_label, printer, pt.rank, pt.pointID);
          }
          return valid;
        }

        virtual std::size_t get_type(const std::string& label) = 0;

        virtual std::set<std::string> get_all_labels() = 0;

      protected:
        template<typename T>
        bool _retrieve(T&, const std::string& label, const uint, const ulong)
        {
          std::ostringstream err;

          err << "Attempted to retrieve a print result as an unregistered type!"
              << "If you really want to retrieve a result as this type, you must "
              << "add the type to the RETRIEVABLE_TYPES sequence "
              << "in \"gambit/Elements/printable_types.hpp\". You will then have "
              << "to define a retrieve function for it in whatever printer "
              << "you are using (see documentation for GAMBIT printers)."
              << "\n  Available info for this retrieve attempt..."
              << "\n   Label      : " << label
              << "\n   Type       : " << STRINGIFY(T);
          printer_error().raise(LOCAL_INFO,err.str());
          return false;
        }

        // Virtual retrieval methods for base printer classes
        #define VRETRIEVE(r,data,elem)                                      \
        virtual bool _retrieve(elem& /*output*/,                            \
                       const std::string& label,                            \
                       const uint /*rank*/,                                 \
                       const ulong /*pointID*/                              \
                       )                                                    \
        {                                                                   \
          std::ostringstream err;                                           \
                                                                            \
          err << "No retrieve function override has been "                  \
              << "\ndefined for this retrieval type (for whatever printer"  \
              << "\nclass the current printer comes from)"                  \
              << "\n  Dumping available info..."                            \
              << "\n   Label      : " << label                              \
              << "\n   Type       : " << STRINGIFY(elem);                   \
          printer_warning().raise(LOCAL_INFO,err.str());                    \
          return false;                                                     \
        }

        #define ADD_VIRTUAL_RETRIEVALS(TYPES) BOOST_PP_SEQ_FOR_EACH(VRETRIEVE, , TYPES)

        // Add the base virtual functions for registered printable and
        // retrievable types, to be overloaded in each printer.
        ADD_VIRTUAL_RETRIEVALS(SCANNER_RETRIEVABLE_TYPES)
    };

  } //end namespace Printers
} // end namespace Gambit


#endif //ifndef __base_base_printer_hpp__