sosimp.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <memory>
 
// Inc HAA
#include "dbc.h"
#include "helper.h"
#include "adapter128.h"
 
// Inc Rich
#include "so.h"
 
 
/* ******************************************************************* */
/* Simple Objects                                                      */
/* SO's that store their data without indirect referencing             */
/* ******************************************************************* */
 
 
class SOM : public SO {
 
public:
  SOM() {}
 
  
  ~SOM() override {}
 
 
  SOM( const SOM & ) = delete;
  SOM( SOM && ) = delete;
  SOM & operator=( const SOM & ) = delete;
  SOM & operator=( SOM && ) = delete;
 
 
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:
  SOL() {}
 
 
  ~SOL() override {}
 
 
  SOL( const SOL & ) = delete;
  SOL( SOL && ) = delete;
  SOL & operator=( const SOL & ) = delete;
  SOL & operator=( SOL && ) = delete;
 
 
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_(string_to___int128(p_s)) {}
 
 
  explicit SOI( __int128 p_i ) : i_(p_i) {}
 
 
  ~SOI() override {}
 
 
  SOI() = delete;
  SOI( const SOI & ) = delete;
  SOI( SOI && ) = delete;
  SOI & operator=( const SOI & ) = delete;
  SOI & operator=( SOI && ) = delete;
 
 
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 __int128_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( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOI*>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    p_ec = success;
    return i_ > o->i_;
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOI*>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    p_ec = success;
    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) {}
 
 
  ~SOB() override {}
 
 
  SOB() = delete;
  SOB( const SOB & ) = delete;
  SOB( SOB && ) = delete;
  SOB & operator=( const SOB & ) = delete;
  SOB & operator=( SOB && ) = delete;
 
 
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_( string_to___float128(p_s) ) {}
 
 
  explicit SOR( __float128 p_r ) : r_(p_r) {}
 
 
  ~SOR() override {}
 
 
  SOR() = delete;
  SOR( const SOR & ) = delete;
  SOR( SOR && ) = delete;
  SOR & operator=( const SOR & ) = delete;
  SOR & operator=( SOR && ) = delete;
 
 
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( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOR *>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    p_ec = success;
    return r_ > o->r_;
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOR *>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    p_ec = success;
    return r_ >= o->r_;
  }
 
 
public: /* other */
  void trunc() { r_ = adapter128::trunc( r_ ); }
 
 
  void ceil() { r_ = adapter128::ceil( r_ ); }
 
 
  void floor() { r_ = adapter128::floor( r_ ); }
 
 
  OpError reciprocal() {
    if( std::abs(r_) > std::numeric_limits<__float128>::min() ) {
      r_ = 1/r_;
      return success;
    }
    return undefinedresult;
  }
};
 
 
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( std::string p_name, bool p_exec = false )
    : SO( p_exec ),
      name_( std::move(p_name) ) {
    DBC_INV_CTOR(SON);
  }
 
 
  SON( const SON & p_other )
    : SO(p_other),
      name_(p_other.name_) {
    DBC_INV_CTOR(SON);
  }
 
 
  ~SON() override {}
 
 
  SON() = delete;
  SON( SON && ) = delete;
  SON & operator=( const SON & ) = delete;
  SON & operator=( SON && ) = delete;
 
 
public: /* accessor */
  std::string getName() const { return name_; }
 
 
public: /* virtual */
  [[nodiscard]] SON * dup() const override { return new SON( *this ); }
 
 
  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(); }
 
};
 
 
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);
  }
 
 
  ~SOO() override {
    DBC_INV_CTOR(SOO);
  }
 
 
  SOO() = delete;
  SOO( const SOO & ) = delete;
  SOO( SOO && ) = delete;
  SOO & operator=( const SOO & ) = delete;
  SOO & operator=( SOO && ) = delete;
 
 
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) {
    }
 
 
  ~SOo() override {}
 
 
  SOo() = delete;
  SOo( const SOo & ) = delete;
  SOo( SOo && ) = delete;
  SOo & operator=( const SOo & ) = delete;
  SOo & operator=( SOo && ) = delete;
 
 
public: /* accessor */
  auto getStackusage() const { return stackusage_; }
 
 
public: /* virtual */
  OTCode ot() const override { return OTCode::o; }
 
};