context.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <iostream>
#include <map>
#include <cstdint>
 
#include "dbc.h"
#include "interpreter.h"
#include "counter.h"
#include "helper.h"
 
#include "sok.h"
 
 
class Context : public Counter<Context>, protected DbC {
  std::string snapLeonline_;       
  SOK os_,                         
      es_,                         
      ds_;                         
  bool run_ = true;                
  int proclevel_ = 0;              
  int loadlevel_ = 0;              
  int arraynesting_ = 0;           
  AngularUnit angularunit_ = AngularUnit::DEG;  
  size_t realprecision_ = 10;                   
  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;
    return arraynesting_ >= 0;
  }                                              /* LCOV_EXCL_STOP */  
#endif
 
private:
  static const std::map<const char *, core_t *> systemdictmap_,
                                                leodictmap_;
 
public:
  Context();
 
  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_; }
 
  std::ostream & getCout() {
    return Interpreter::get()->getCout();
  }
 
  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; }
 
  size_t getRealprecision() const { return realprecision_; }
 
  void setRealprecision( size_t p_prec ) { realprecision_ = p_prec; }
 
  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 status_statistics();
 
  void property_statistics();
 
  void stack_statistics();
};