sosimp.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <map>
#include <numeric>
#include <vector>
#include <memory>
 
#include "dbc.h"
#include "helper.h"
#include "adapter128.h"
#include "so.h"
 
 
/* ******************************************************************* */
/* Simple Objects                                                      */
/* SO's that store their data without indirect referencing             */
/* ******************************************************************* */
 
 
class SOM : public SO {
public: /* virtual */
  [[nodiscard]] SOM * dup() const override { return new SOM; }
 
  std::string opequal() const override { return "--nostringval--"; }
 
  std::string opequalequal() const override { return "mark"; }
 
  OTCode ot() const override { return OTCode::M; }
 
  std::string type() const override { return "marktype"; }
 
  bool equal( const SO * p_other ) const override {
    return dynamic_cast<const SOM *>( p_other) != nullptr;  // All SOM are equal
  }
};
 
 
class SOL : public SO {
public: /* virtual */
  SOL * dup() const override { return new SOL; }
 
  std::string opequal() const override { return "--nostringval--"; }
 
  std::string opequalequal() const override { return "null"; }
 
  OTCode ot() const override { return OTCode::L; }
 
  std::string type() const override { return "nulltype"; }
 
  bool equal( const SO * p_other ) const override {
    return dynamic_cast<const SOL *>( p_other) != nullptr;  // All SOL are equal
  }
};
 
 
class SOI : public SO {
  __int128 i_;           
public:
  explicit SOI( const std::string & p_s ) : i_(stoint128(p_s)) {}
 
  explicit SOI( __int128 p_i ) : i_(p_i) {}
 
public: /* accessor */
  __int128 getInteger() const { return i_; }
 
  void setInteger( __int128 p_i ) { i_=p_i; }
 
public: /* virtual */
  [[nodiscard]] SOI * dup() const override { return new SOI( i_ ); }
 
  std::string opequal() const override { return to_string( i_ ); }
 
  OTCode ot() const override { return OTCode::I; }
 
  std::string type() const override { return "integertype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOI*>( p_other );
    return o ? i_ == o->i_ : false;
  }
 
  bool gt( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOI*>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    return i_ > o->i_;
  }
 
  bool ge( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOI*>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    return i_ >= o->i_;
  }
 
public: /* other */
  void decrement() { i_--; }
 
  void increment() { i_++; }
};
 
 
class SOB : public SO {
  bool b_;         
public:
  explicit SOB( const std::string & p_s ) : b_(p_s == "true") {}
 
  explicit SOB( bool p_b ) : b_(p_b) {}
 
public: /* accessor */
  bool getB() const { return b_; }
 
  void setB( bool p_b ) { b_ = p_b; }
 
public: /* virtual */
  [[nodiscard]] SOB * dup() const override { return new SOB( b_ ); }
 
  std::string opequal() const override {
    return b_ ? "true" : "false";
  }
 
  OTCode ot() const override { return OTCode::B; }
 
  std::string type() const override { return "booleantype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOB *>( p_other);
    return o ? b_ == o->b_ : false;
  }
 
public: /* other */
  void negation() { b_ = !b_; }
};
 
 
class SOR : public SO {
  __float128 r_;      
public:
  explicit SOR( const std::string & p_s ) : r_( stofloat128(p_s) ) {}
 
  explicit SOR( __float128 p_r ) : r_(p_r) {}
 
public: /* accessor */
  __float128 getReal() const { return r_; }
 
  void setReal( __float128 p_r ) { r_ = p_r; }
 
public: /* virtual */
  [[nodiscard]] SOR * dup() const override { return new SOR( r_ ); }
 
  std::string opequal() const override;
 
  OTCode ot() const override { return OTCode::R; }
 
  std::string type() const override { return "realtype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOR* >( p_other );
    return o ? r_ == o->r_ : false;
  }
 
  bool gt( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOR *>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    return r_ > o->r_;
  }
 
  bool ge( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOR *>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    return r_ >= o->r_;
  }
 
public: /* other */
  void trunc() { r_ = ::trunc( r_ ); }
 
  void ceil() { r_ = ::ceil( r_ ); }
 
  void floor() { r_ = ::floor( r_ ); }
};
 
 
class SON : public SO {
  std::string name_;                 
protected:
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    return !name_.empty();
  }                                              /* LCOV_EXCL_STOP */
#endif
 
public:
  explicit SON( const std::string& p_name, bool p_exec = false ) : SO(p_exec), name_(p_name) {
    DBC_INV_CTOR(SON);
  }
 
public: /* virtual */
  [[nodiscard]] SON * dup() const override { return new SON( name_, getExec() ); }
 
  std::string opequal() const override {
    if( getExec() )
      return name_;
    return "/"+name_;
  }
 
  OTCode ot() const override {
    return getExec() ? OTCode::Nx : OTCode::N;
  }
 
  std::string type() const override { return "nametype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SON *>( p_other);
    return o ? name_ == o->name_ : false;
  }
 
  size_t getSize() const override { return name_.size(); }
 
public: /* other */
  void load_exec( Context & k ) const;
};
 
 
class SOO : public SO {
  core_t * const core_;         
  const char * const srep_;     
protected:
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( core_ == nullptr or srep_ == nullptr )
      return false;
    return *srep_ != 0;
  }                                              /* LCOV_EXCL_STOP */
#endif
 
public:
  SOO( core_t * p_fun, const char * p_str ) : core_(p_fun), srep_(p_str) {
    DBC_INV_CTOR(SOO);
  }
 
public: /* virtual */
  [[nodiscard]] SOO * dup() const override { return new SOO( core_, srep_ ); }
 
  std::string opequal() const override { return "--"+std::string(srep_)+"--"; }
 
  OTCode ot() const override { return OTCode::O; }
 
  std::string type() const override { return "operatortype"; }
 
  bool equal( const SO * p_other ) const override {
    const SOO* o = dynamic_cast<const SOO*>( p_other);
    return o ? core_ == o->core_ : false;
  }
 
public: /* other */
  void exec( Context & k ) const { core_(k); }
};
 
 
class SOo : public SOO {
  size_t stackusage_;   
public:
  SOo( core_t * p_fun, const char * p_str, size_t p_stackusage )
      : SOO( p_fun, p_str ), stackusage_(p_stackusage) {}
 
public: /* accessor */
  auto getStackusage() const { return stackusage_; }
 
public: /* virtual */
  OTCode ot() const override { return OTCode::o; }
};