mixins.h

Go to the documentation of this file.

// This file is part of HermesCommon
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://www.hpfem.org/.
//
// Hermes2D 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 2 of the License,
// or (at your option) any later version.
//
// Hermes2D 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 Hermes2D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#ifndef __HERMES_COMMON_MIXINS_H
#define __HERMES_COMMON_MIXINS_H

#include "common.h"
#include "exceptions.h"
#include "api.h"

namespace Hermes
{
  namespace Mixins
  {
    class HERMES_API StateQueryable
    {
    public:
      virtual bool isOkay() const = 0;

      virtual std::string getClassName() const = 0;

      void check() const;
    };

    class HERMES_API Loggable
    {
    private:
      typedef void(*callbackFn)(const char*);

    public:
      Loggable(bool verbose_output = false, callbackFn verbose_callback = NULL, bool add_newline = true);

      void set_file_output_only(bool onOff);
      void set_timestamps(bool onOff);
      void set_erase_on_beginning(bool onOff);
      void set_logFile_name(const char* filename);
      void set_logFile_name(std::string filename);
      static void set_static_logFile_name(const char* filename);
      static void set_static_logFile_name(std::string filename);

      void info(const char* msg, ...) const;
      void info_if(bool cond, const char* msg, ...) const;
      void warn(const char* msg, ...) const;
      void warn_if(bool cond, const char* msg, ...) const;
      void error(const char* msg, ...) const;
      void error_if(bool cond, const char* msg, ...) const;

      virtual void set_verbose_output(bool to_set);

      bool get_verbose_output() const;

      virtual void set_verbose_callback(callbackFn callback);

      callbackFn get_verbose_callback() const;

      class HERMES_API Static
      {
      public:
        static void info(const char* msg, ...);
        static void warn(const char* msg, ...);
        static void error(const char* msg, ...);
      };

      char* logFileName;
      static char* staticLogFileName;
    protected:

      /* file operations */
      void hermes_fwrite(const void* ptr, size_t size, size_t nitems, FILE* stream) const;
      void hermes_fread(void* ptr, size_t size, size_t nitems, FILE* stream) const;

    private:

      bool write_console(const char code, const char* text) const;

      class HERMES_API HermesLogEventInfo
      {
      public:
        HermesLogEventInfo(const char code, const char* src_function, const char* src_file, const int src_line);
        const char code;
        const char* src_function;
        const char* src_file;
        const int src_line;
      };

      HermesLogEventInfo* hermes_build_log_info(char event) const;

      static std::map<std::string, bool> logger_written;


      void hermes_log_message(const char code, const char* msg) const;

      bool verbose_output;

      bool file_output_only;

      callbackFn verbose_callback;

      bool print_timestamps;

      bool erase_on_beginning;

      bool log_file_written;

      bool add_newline;
    };

    class HERMES_API TimeMeasurable
    {
    public:
      TimeMeasurable(const char *name = nullptr);

      enum TimerPeriodTickType
      {
        HERMES_ACCUMULATE, 
        HERMES_SKIP 
      };

      const TimeMeasurable& reset();
      const TimeMeasurable& tick_reset();
      const TimeMeasurable& tick(TimeMeasurable::TimerPeriodTickType type = HERMES_ACCUMULATE);

      const std::string& name() const;

      double accumulated() const;

      std::string accumulated_str() const;


      double last() const;

      std::string last_str() const;

    private:
#ifdef _WINDOWS //Windows
      typedef uint64_t SysTime;
      double frequency;
#else //Linux
      typedef timespec SysTime;
#endif
      const std::string period_name;
      double last_period;
      SysTime last_time;
      double accum;

      SysTime get_time() const;
      double period_in_seconds(const SysTime& begin, const SysTime& end) const;
      std::string to_string(const double time) const;
    };

    class HERMES_API IntegrableWithGlobalOrder
    {
    public:
      IntegrableWithGlobalOrder();
      virtual void set_global_integration_order(unsigned int order);
      bool global_integration_order_set;
      unsigned int global_integration_order;
    };

    class HERMES_API SettableComputationTime
    {
    public:
      SettableComputationTime();
      virtual void set_time(double time);
      virtual void set_time_step(double time_step);
      double time;
      double time_step;
    };

    class HERMES_API OutputAttachable
    {
    public:
      OutputAttachable();
      virtual bool on_initialization();
      virtual bool on_step_begin();
      virtual bool on_initial_step_end();
      virtual bool on_step_end();
      virtual bool on_finish();

      template<typename T>
      class Parameter
      {
      private:
        T* value;
        friend class OutputAttachable;
      };

      template<typename T>
      const T& get_parameter_value(const Parameter<T>& parameter);

      template<typename T>
      T& get_parameter_value(Parameter<T>& parameter);

    protected:
      template<typename T>
      void set_parameter_value(Parameter<T>& parameter, T* value);
    };
  }

  typedef Hermes::Mixins::OutputAttachable::Parameter<unsigned int> OutputParameterUnsignedInt;
  typedef Hermes::Mixins::OutputAttachable::Parameter<double> OutputParameterDouble;
  typedef Hermes::Mixins::OutputAttachable::Parameter<bool> OutputParameterBool;

  typedef Hermes::Mixins::OutputAttachable::Parameter<std::vector<unsigned int> > OutputParameterUnsignedIntVector;
  typedef Hermes::Mixins::OutputAttachable::Parameter<std::vector<double> > OutputParameterDoubleVector;
  typedef Hermes::Mixins::OutputAttachable::Parameter<std::vector<bool> > OutputParameterBoolVector;
}
#endif