context.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <map>
#include <cstdint>
 
// Inc HAA
#include "dbc.h"
#include "helper.h"
 
// Inc Medium
#include "counter.h"
 
// Inc Rich
#include "sok.h"
#include "sof.h"
 
 
class Context : public Counter<Context>, protected DbC {
 
  bool run_ = true;                
  SOK os_{},                       
      es_{},                       
      ds_{};                       
  std::string snapLeonline_{};     
  int proclevel_ = 0;              
  int loadlevel_ = 0;              
  int arraynesting_ = 0;           
  SOF * inf_;                                   
  SOF * outf_;                                  
  AngularUnit angularunit_ = AngularUnit::DEG;  
  size_t maxloadlevel_ = 1000;                  
  uint32_t seed_ = 0;                           
public:
  constexpr static size_t mindictstack_ = 3;   
protected:
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( proclevel_ < 0 )
      return false;
    if( loadlevel_ < 0 )
      return false;
    if( inf_ == nullptr )
      return false;
    if( outf_ == nullptr )
      return false;
    if( ! inf_->isOpen() )
      return false;
    if( ! outf_->isOpen() )
      return false;
    return arraynesting_ >= 0;
  }                                              /* LCOV_EXCL_STOP */  
#endif
 
private:
  static const std::map<const char *, core_t *> systemdictmap_,
                                                leodictmap_;
 
 
public:
  explicit Context( const std::string & p_inf_name );
 
  
  Context() = delete;
  Context( const Context & ) = delete;
  Context( Context && ) = delete;
  Context & operator=( const Context & ) = delete;
  Context & operator=( Context && ) = delete;
 
 
  virtual ~Context();
 
 
public: /* accessor */
  SOK & opst() { return os_; }
 
 
  SOK & exst() { return es_; }
 
 
  SOK & dist() { return ds_; }
 
 
  size_t getProclevel() const { return static_cast<size_t>(proclevel_); }
 
 
  size_t getLoadlevel() const { return static_cast<size_t>(loadlevel_); }
 
 
  size_t getArraynesting() const { return static_cast<size_t>(arraynesting_); }
 
 
  size_t getMaxloadlevel() const { return maxloadlevel_; }
 
 
  bool getInterpreterLoop() const { return run_; }
 
 
  void stopInterpreterLoop() { run_ = false; }
 
 
  void setSnapLeonline( const std::string & p_line ) { snapLeonline_ = p_line; }
 
 
  auto getAngularUnit() const { return angularunit_; }
 
 
  void setAngularUnit( AngularUnit p_unit ) { angularunit_ = p_unit; }
 
 
  uint32_t getSeed() const { return seed_; }
 
 
  void setSeed( uint32_t p_seed ) { seed_ = p_seed; }
 
 
public: /* other */
  void incProclevel() {
    DBC_INV_RAII(Context);
    proclevel_++;
  }
 
 
  void decProclevel() {
    DBC_INV_RAII(Context);
    proclevel_--;
  }
 
 
  void incLoadlevel() {
    DBC_INV_RAII(Context);
    loadlevel_++;
  }
 
 
  void decLoadlevel() {
    DBC_INV_RAII(Context);
    loadlevel_--;
  }
 
 
  void incArraynesting() {
    DBC_INV_RAII(Context);
    arraynesting_++;
  }
 
 
  void decArraynesting() {
    DBC_INV_RAII(Context);
    arraynesting_--;
  }
 
 
  void print( const std::string & p_line ) const {
    outf_->writestring( p_line );
  }
 
 
  void print( std::string_view p_line ) const {
    outf_->writestring( p_line );
  }
 
 
  void print( const char * p_line ) const {
    outf_->writestring( std::string_view( p_line ) );
  }
 
 
  void flushoutfile() const {
    outf_->flush();
  }
 
 
  bool readLeonLine( std::string & p_line ) const {
    return inf_->readLeonLine( p_line );
  }
 
 
  void status_statistics() const;
 
 
  void property_statistics() const;
 
 
  void stack_statistics() const;
 
 
  void pstackdump( const SOK & p_stack ) const;
 
};