context.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
#include <cstdint>
#include "determinations.h"
 
// Inc Pure
#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_{ OTCode::D };            
  std::string snapLeonline_{};     
  int proclevel_ = 0;              
  int loadlevel_ = 0;              
  int arraynesting_ = 0;           
  SOF * inf_;                                   
  SOF * outf_;                                  
  AngularUnit angularunit_ = AngularUnit::DEG;  
  size_t maxloadlevel_ = DET_MAXLOADLEVEL;      
  uint32_t seed_ = 0;                           
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
 
public:
 
  constexpr static size_t mindictstack_ = 3;   
  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() {
    proclevel_++;
    DBC_INV;
  }
 
 
  void decProclevel() {
    proclevel_--;
    DBC_INV;
  }
 
 
  void incLoadlevel() {
    loadlevel_++;
    DBC_INV;
  }
 
 
  void decLoadlevel() {
    loadlevel_--;
    DBC_INV;
  }
 
 
  void incArraynesting() {
    arraynesting_++;
    DBC_INV;
  }
 
 
  void decArraynesting() {
    arraynesting_--;
    DBC_INV;
  }
 
 
  void print( const std::string & p_line ) {
    outf_->writestring( p_line );
 
    DBC_INV;
  }
 
 
  void print( std::string_view p_line ) {
    outf_->writestring( p_line );
 
    DBC_INV;
  }
 
 
  void print( const char * p_line ) {
    DBC_PRE( p_line != nullptr );
 
    outf_->writestring( p_line );
 
    DBC_INV;
  }
 
 
  void flushoutfile() {
    outf_->flush();
 
    DBC_INV;
  }
 
 
  bool readLeonLine( std::string & p_line ) {
    DBC_INV_RAII(Context);
 
    return inf_->readLeonLine( p_line );
  }
 
 
  void status_statistics();
 
 
  void property_statistics();
 
 
  void stack_statistics();
 
 
  void pstackdump( const SOK & p_stack );
 
};