sok.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
#include <deque>
#include <initializer_list>
#include <algorithm>
#include <memory>
#include "determinations.h"
 
// Inc Pure
#include "dbc.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_;
 
 
  OTCode restricted_{ OTCode::X };
 
protected:
  
  void * shptr() const override { return static_cast<void *>( deque_.get() ); } 
 
 
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( !SOcomposite::invariant() )
      return false;
    if( getSize() > deque_->watermark_.getWatermark() )
      return false;
    if( std::any_of( deque_->stldeque_.begin(), deque_->stldeque_.end(),
                     []( const SO * p ) {
                         return p == nullptr;
                     } ) )
      return false;
    if( restricted_ != OTCode::X )
      if( std::any_of( deque_->stldeque_.begin(), deque_->stldeque_.end(),
                       [this]( const SO * p ) {
                           return p->ot() != restricted_;
                       } ) )
        return false;
    return true;
  }                                              /* LCOV_EXCL_STOP */ 
#endif
 
public:
 
  SOK()
    : SOcomposite(),
      deque_(std::make_shared<SOKDeque>()),
      restricted_(OTCode::X) {
    DBC_INV_CTOR(SOK);
  }
 
 
  explicit SOK( OTCode p_restr )
    : SOcomposite(),
      deque_(std::make_shared<SOKDeque>()),
      restricted_(p_restr) {
    DBC_INV_CTOR(SOK);
  }
 
 
  explicit SOK( const SOcomposite & p_other )
    : SOcomposite(p_other),
      deque_(std::make_shared<SOKDeque>()),
      restricted_(OTCode::X) {
    DBC_INV_CTOR(SOK);
  }
 
 
  SOK( const SOK & p_other )
    : SOcomposite(p_other),
      deque_(p_other.deque_),
      restricted_(p_other.restricted_) {
    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_view type() const override { return "stacktype"; }
 
 
  size_t getSize() const override { return deque_->stldeque_.size(); }
 
 
  size_t dagheight( size_t p_myheight ) const override;
 
public: /* accessor */
 
  OTCode getRestricted() const { return restricted_; }
 
 
  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 );
    DBC_PRE( restricted_ == OTCode::X || restricted_ == p_sop->ot() );
 
    delete deque_->stldeque_[p_index];
    deque_->stldeque_[p_index] = p_sop;
 
    if( SOcomposite::otcodeIsComposite( p_sop->ot() ) && 
      static_cast<SOcomposite *>(p_sop)->dagheight( 0 ) >= DET_MAXDAGHEIGHT )
      inErrExit( semantics, "composite object DAG 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( SO * p_key ) const;
 
 
  SOp findDict( SO * p_key ) const;
 
 
  [[nodiscard]] __int128 getI();
 
 
  [[nodiscard]] __float128 getR();
 
 
  [[nodiscard]] __float128 getIorRasR();
 
 
  [[nodiscard]] size_t getISize_t( OpError & p_ec );
 
};