sosimp.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
#include <memory>
 
// Inc Pure
#include "dbc.h"
#include "helper.h"
#include "adapter128.h"
#include "conversion.h"
#include "registry.h"
 
// Inc Rich
#include "so.h"
 
 
/* ******************************************************************* */
/* Simple Objects                                                      */
/* SO's that store their data without indirect referencing             */
/* ******************************************************************* */
 
 
class SOM : public SO {
 
public:
 
  SOM() = default;
 
  
  ~SOM() override = default;
 
 
  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_view type() const override { return "marktype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    return p_other->ot() == OTCode::M;    // All SOM are equal
  }
 
};
 
 
class SOL : public SO {
  
public:
 
  SOL() = default;
 
 
  ~SOL() override = default;
 
 
  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_view type() const override { return "nulltype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    return p_other->ot() == OTCode::L;    // All SOL are equal
  }
 
};
 
 
class SOI : public SO {
 
  __int128 i_;           
public:
 
  explicit SOI( const std::string & p_s ) : i_(conversion::string_to___int128(p_s)) {}
 
 
  explicit SOI( __int128 p_i ) : i_(p_i) {}
 
 
  ~SOI() override = default;
 
 
  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 conversion::__int128_to_string( i_ ); }
 
 
  OTCode ot() const override { return OTCode::I; }
 
 
  std::string_view type() const override { return "integertype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != ot() )
      return false;
    const auto o = static_cast<const SOI *>( p_other );
    return i_ == o->i_;
  }
 
 
  bool gt( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::I ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOI *>( p_other );
    p_ec = success;
    return i_ > o->i_;
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::I ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOI *>( p_other );
    p_ec = success;
    return i_ >= o->i_;
  }
 
public: /* other */
 
  void decrement__1() { i_--; }
 
 
  void increment__1() { i_++; }
 
  
  void sqr__1() { i_ *= i_; }
 
 
  void half__1() { i_ /= 2; }
 
};
 
 
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 = default;
 
 
  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_view type() const override { return "booleantype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != ot() )
      return false;
    const auto o = static_cast<const SOB *>( p_other);
    return b_ == o->b_;
  }
 
public: /* other */
 
  void negation__1() { b_ = !b_; }
 
};
 
 
class SOR : public SO {
 
  __float128 r_;      
protected:
 
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    return adapter128::isfinite( r_ );
  }                                              /* LCOV_EXCL_STOP */
#endif
 
public:
 
  explicit SOR( const std::string & p_s ) : r_( conversion::string_to___float128(p_s) ) {
    DBC_INV_CTOR(SOR);  // This also checks the precondition.
  }
 
 
  explicit SOR( __float128 p_r ) : r_(p_r) {
    DBC_INV_CTOR(SOR);
  }
 
 
  ~SOR() override = default;
 
 
  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_; }
 
 
  bool setReal( __float128 p_r ) {
    DBC_INV_RAII(SOR);
  
    if( ! adapter128::isfinite(p_r) )
      return false;
    r_ = p_r;
    return true;
  }
 
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_view type() const override { return "realtype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != ot() )
      return false;
    const auto o = static_cast<const SOR *>( p_other );
    return r_ == o->r_;
  }
 
 
  bool gt( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::R ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOR *>( p_other );
    p_ec = success;
    return r_ > o->r_;
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::R ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOR *>( p_other );
    p_ec = success;
    return r_ >= o->r_;
  }
 
public: /* other */
 
  void half__1() {
    r_ /= 2;
 
    DBC_INV;
  }
 
 
  OpError sqr__1() {
    DBC_INV_RAII(SOR);
 
    if( std::abs(r_) > SOR_MAX_SQR ) 
      return undefinedresult;
    r_ *= r_;
    return success;
  }
 
 
  void trunc__1() {
    r_ = adapter128::trunc( r_ );
 
    DBC_INV;
  }
 
 
  void ceil__1() {
     r_ = adapter128::ceil( r_ );
 
     DBC_INV;
  }
 
 
  void floor__1() {
    r_ = adapter128::floor( r_ );
 
    DBC_INV;
  }
 
 
  OpError reciprocal__1() {
    DBC_INV_RAII(SOR);
 
    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 = default;
 
 
  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 opequalequal() const override {
    if( getExec() )
      return name_;
    return "/"+name_;
  }
 
 
  std::string opequal() const override {
    return name_;
  }
 
 
  OTCode ot() const override {
    return getExec() ? OTCode::Nx : OTCode::N;
  }
 
 
  std::string_view type() const override { return "nametype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( !otcodeIsName( p_other->ot() ) )
      return false;
    const auto o = static_cast<const SON *>( p_other );
    return name_ == o->name_;
  }
 
 
  size_t getSize() const override { return name_.size(); }
 
public: /* other */
 
  static bool otcodeIsName( OTCode p_code ) {
    return p_code <= OTCode::Nx;
  }
 
};
 
 
class SOO : public SO {
 
  core_t * const core_;         
protected:
 
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( core_ == nullptr )
      return false;
    return Registry::lookUp( core_ );
  }                                              /* LCOV_EXCL_STOP */
#endif
 
public:
 
  explicit SOO( core_t * p_fun )
    : core_(p_fun) {
    DBC_PRE( Registry::lookUp( p_fun ) );
 
    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_ ); }
 
 
  std::string opequal() const override {
    return std::string( Registry::lookUpName( core_) );
  }
 
 
  std::string opequalequal() const override {
    return "--" + opequal() + "--";
  }
 
 
  OTCode ot() const override { return OTCode::O; }
 
 
  std::string_view type() const override { return "operatortype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( !otcodeIsCoreCode( p_other->ot() ) )
      return false;
    const auto o = static_cast<const SOO *>( p_other );
    return core_ == o->core_;
  }
 
public: /* other */
 
  void exec( Context & k ) const { core_(k); }
 
 
  static bool otcodeIsCoreCode( OTCode p_code ) {
    return p_code == OTCode::O || p_code == OTCode::o;
  }
 
};
 
 
class SOo : public SOO {
 
  size_t stackusage_;   
 
public:
 
  explicit SOo( core_t * p_fun )
    : SOO( p_fun ),                                          // This checks the precondition
      stackusage_( Registry::lookUpStackusage( p_fun ) ) {
    }
 
 
  ~SOo() override = default;
 
 
  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; }
 
};