sok.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <deque>
#include <initializer_list>
#include <algorithm>
#include <memory>
 
// Inc HAA
#include "dbc.h"
#include "helper.h"
 
// Inc Medium
#include "watermark.h"
 
// Inc Rich
#include "so.h"
 
 
class SOK : public SOcomposite {
 
  struct SOKDeque {
    std::deque<SOp> stldeque_{};     
    Watermark watermark_{};          
    ~SOKDeque() {
      for( const auto & ptr : stldeque_ )
        delete ptr;
    }
  };
 
 
  std::shared_ptr<SOKDeque> deque_;
 
 
protected:
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( deque_ == nullptr )
      return false;
    if( getSize() > deque_->watermark_.getWatermark() )
      return false;
    return std::none_of( deque_->stldeque_.begin(), deque_->stldeque_.end(),
                         []( const SO * p ) {
                           return p == nullptr;
                         } );
  }                                              /* LCOV_EXCL_STOP */ 
#endif
 
 
public:
  SOK()
    : SOcomposite(),
      deque_(std::make_shared<SOKDeque>()) {
    DBC_INV_CTOR(SOK);
  }
 
 
  explicit SOK( const SOcomposite & p_other )
    : SOcomposite(p_other),
      deque_(std::make_shared<SOKDeque>()) {
    DBC_INV_CTOR(SOK);
  }
 
 
  SOK( const SOK & p_other )
    : SOcomposite(p_other),
      deque_(p_other.deque_) {
    DBC_INV_CTOR(SOK);
  }
 
 
  ~SOK() override {
    DBC_INV_CTOR(SOK);
  }
 
 
  SOK( SOK && ) = delete;
  SOK & operator=( const SOK & ) = delete;
  SOK & operator=( SOK && ) = delete;
 
 
public: /* virtual */
  [[nodiscard]] SOK * dup() const override { return new SOK( *this ); }
 
 
  [[nodiscard]] SOK * clone() const override;
 
 
  std::string opequalequal() const override;
 
 
  OTCode ot() const override { return OTCode::K; }
 
 
  std::string type() const override { return "stacktype"; }
 
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOK *>( p_other );
    return o ? deque_ == o->deque_ : false;
  }
 
 
  size_t getSize() const override { return deque_->stldeque_.size(); }
 
 
  size_t treeheight( size_t p_myheight ) const override;
 
 
public: /* accessor */
  size_t getWatermark() const { return deque_->watermark_.getWatermark(); }
 
 
  SOp ncat( size_t p_pos ) const {
    DBC_PRE( p_pos < getSize() );
 
    return deque_->stldeque_[ p_pos ];
  }
 
 
  SOp peek() const {
    DBC_PRE( getSize() > 0 );
 
    return deque_->stldeque_.back();
  }
 
 
public: /* other */
  void putSO( size_t p_index, SOp p_sop ) {
    DBC_PRE( p_index < getSize() and p_sop != nullptr );
 
    delete deque_->stldeque_[p_index];
    deque_->stldeque_[p_index] = p_sop;
 
    if( treeheight( 0 ) >= maxtreeheight )
      inErrExit( semantics, "composite object tree height exceeds maximum" );
 
    DBC_INV;
  }
 
 
  [[nodiscard]] SOp pop() {
    DBC_PRE( getSize() > 0 );
 
    SOp retval = deque_->stldeque_.back();
    deque_->stldeque_.pop_back();
 
    DBC_INV;
    return retval;
  }
 
 
  void pop_delete() {
    DBC_PRE( getSize() > 0 );
 
    delete deque_->stldeque_.back();
    deque_->stldeque_.pop_back();
 
    DBC_INV;
  }
 
 
  void push( SOp p_o1 );
 
 
  void push( std::initializer_list<SOp> p_list );
 
 
  void push_front( SOp p_obj );
 
 
  bool underflowcheck( size_t p_size ) const { return getSize() >= p_size; }
 
 
  bool otchecker( std::initializer_list<OTCode> p_list ) const;
 
 
  bool otchecker( OTCode p_code ) const {
    DBC_PRE( !deque_->stldeque_.empty() );
    DBC_PRE( p_code != OTCode::X );
 
    return peek()->ot() == p_code;
  }
 
 
  bool otcheckerOr( OTCode p_code1, OTCode p_code2 ) const {
    DBC_PRE( !deque_->stldeque_.empty() );
    DBC_PRE( p_code1 != OTCode::X );
    DBC_PRE( p_code2 != OTCode::X );
 
    return peek()->ot() == p_code1 || peek()->ot() == p_code2;
  }
 
 
  bool countto( size_t & p_retval, OTCode p_code ) const;
 
 
  SOp findValue( const SO * p_key ) const;
 
 
  SOp findDict( const SO * p_key ) const;
 
 
  [[nodiscard]] __int128 getI( OpError & p_ec );
 
 
  [[nodiscard]] __float128 getR( OpError & p_ec );
 
 
  [[nodiscard]] __float128 getIorRasR();
 
 
  [[nodiscard]] size_t getISize_t( OpError & p_ec );
};