so.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
 
// Inc Pure
#include "dbc.h"
#include "helper.h"
 
// Inc Medium
#include "counter.h"
#include "error.h"
 
 
enum class OTCode : char {
 
  N = 0,   
  Nx = 1,  
  B,       
  I,       
  L,       
  M,       
  O,       
  o,       
  Q,       
  R,       
 
  F,       
  S,       
 
  // The order of these next 4 entries is used to identify composed semantic objects:
  A,       
  Ax,      
  D,       
  K,       
 
  X        
 
};
 
 
class SO : public Counter<SO>, protected DbC {
 
  bool exec_;            
 
public:
 
  SO() : exec_(false) {}
 
 
  explicit SO( bool p_exec ) : exec_(p_exec) {}
 
 
  SO( const SO & p_other ) : Counter<SO>(), DbC(), exec_(p_other.exec_) {}
 
 
  virtual ~SO() = default;
 
 
  SO( SO && ) = delete;
  SO & operator=( const SO & ) = delete;
  SO & operator=( SO && ) = delete;
 
public: /* accessor */
 
  bool getExec() const {
    return exec_;
  }
 
 
  void setExec( bool p_exec ) {
    exec_ = p_exec;
  }
 
 
  virtual size_t getSize() const {
    return 1;
  }
 
public: /* virtual */
 
  [[nodiscard]] virtual SO * dup() const = 0;
 
 
  [[nodiscard]] virtual SO * clone() const {
    return dup();
  }
 
 
  virtual std::string opequal() const = 0;
 
 
  virtual std::string opequalequal() const {
    return opequal();
  }
 
 
  virtual OTCode ot() const = 0;
 
 
  virtual std::string_view type() const = 0;
 
 
  virtual bool equal( const SO * /* unused */ ) const = 0;
 
 
  virtual bool gt( OpError & p_ec, const SO * /* unused */ ) const {
    p_ec = typecheck;
    return false;
  }
 
 
  virtual bool ge( OpError & p_ec, const SO * /* unused */ ) const {
    p_ec = typecheck;
    return false;
  }
 
};
 
 
using SOp = SO *;
 
 
class SOshptr : public SO {
 
protected:
 
  virtual void * shptr() const = 0;
 
 
#ifndef DBC_IS_VOID
 
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    return shptr() != nullptr;
  }                                              /* LCOV_EXCL_STOP */ 
#endif
  
public:
 
  /* Ctors */
  using SO::SO;
 
public: /* virtual */
 
  std::string opequal() const override {
    return "--nostringval--";
  }
 
  
  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 SOshptr *>( p_other );
    return shptr() == o->shptr();
  }
 
};
 
 
class SOcomposite : public SOshptr {
 
public:
 
  /* Ctors */
  using SOshptr::SOshptr;
 
public: /* virtual */
 
  virtual size_t dagheight( size_t p_myheigth ) const = 0;
 
  
  static bool otcodeIsComposite( OTCode p_code ) {
    return p_code >= OTCode::A && p_code <= OTCode::K;
  }
 
};