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://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 "vector.h"
#include "exceptions.h"

namespace Hermes
{




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

    public:
      void set_verbose_output(bool to_set);

      bool get_verbose_output() const;

      void set_verbose_callback(callbackFn callback);
    public:
      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, ...);
      };
    protected:
      Loggable(bool verbose_output = false, callbackFn verbose_callback = NULL);

      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;
      
      /* 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* log_file, const char* src_function, const char* src_file, const int src_line);
        const char code;          
        const char* log_file;     
        const char* src_function; 
        const char* src_file;     
        const int src_line;       
      };

      HermesLogEventInfo* hermes_build_log_info(char event) const;


      class LoggerMonitor
      {
        pthread_mutexattr_t mutex_attr; 
        pthread_mutex_t mutex; 

      public:
        LoggerMonitor()
        {
          pthread_mutexattr_init(&mutex_attr);
          pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
          pthread_mutex_init(&mutex, &mutex_attr);
        };
        ~LoggerMonitor()
        {
          pthread_mutex_destroy(&mutex);
          pthread_mutexattr_destroy(&mutex_attr);
        };

        void enter() { pthread_mutex_lock(&mutex); };

        void leave() { pthread_mutex_unlock(&mutex); };
      };

      static LoggerMonitor logger_monitor;

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


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

      bool verbose_output;

      callbackFn verbose_callback;
    };

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

      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 WIN32 //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();
      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 void on_initialization();
      virtual void on_step_begin();
      virtual void on_step_end();
      virtual void on_finish();
    };
  }
}
#endif