sok.h

Go to the documentation of this file.

 
#pragma once
 
#include <deque>
#include <initializer_list>
#include <memory>
 
#include "dbc.h"
#include "counter.h"
#include "helper.h"
#include "so.h"
 
 
class SOK : public SOcomp {
 
  struct SOKDeque {
    std::deque<SOp> stldeque_;       
    ~SOKDeque() {
      for( const auto & ptr : stldeque_ )
        delete ptr;
    }
  };
 
  std::shared_ptr<SOKDeque> deque_;   
  size_t watermark_{};                
  void watermark() {
    if( getSize() > watermark_ )
      watermark_ = getSize();
  }
 
protected:
 
#ifndef DBC_IS_VOID
 
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( deque_ == nullptr )
      return false;
    for( const auto * obj : deque_->stldeque_ )
      if( obj == nullptr )
        return false;
    return true;
  }                                              /* LCOV_EXCL_STOP */ 
 
#endif
 
public:
  SOK() : deque_(std::make_shared<SOKDeque>()) {
    DBC_INV_CTOR(SOK);
  }
 
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 '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(); }
 
public: /* accessor */
  size_t getWatermark() const { return watermark_; }
 
  void setSO( 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;
 
    DBC_INV;
  }
 
  SOp at( 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 */
  [[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 ) {
    DBC_PRE( p_o1 != nullptr );
 
    deque_->stldeque_.push_back( p_o1 );
    watermark();
 
    DBC_INV;
  }
 
  void push( SOp p_o1, SOp p_o2 ) {
    DBC_PRE( p_o1 != nullptr and p_o2 != nullptr );
 
    deque_->stldeque_.push_back( p_o1 );
    deque_->stldeque_.push_back( p_o2 );
    watermark();
    
    DBC_INV;
  }
 
  void push( std::initializer_list<SOp> p_list ) {
    for( auto obj : p_list ) {
      DBC_PRE( obj != nullptr );
      deque_->stldeque_.push_back( obj );
    }
    watermark();
 
    DBC_INV;
  }
 
  void push_front( SOp p_obj ) {
    DBC_PRE( p_obj != nullptr );
 
    deque_->stldeque_.push_front( p_obj );
    watermark();
 
    DBC_INV;
  }
 
  bool underflowcheck( size_t p_size ) const { return getSize() >= p_size; }
 
  bool otchecker( const std::string & p_s ) const;
 
  bool otchecker( OTCode p_code ) const {
    DBC_PRE( !deque_->stldeque_.empty() );
 
    return peek()->ot() == p_code;
  }
 
  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();
 
  [[nodiscard]] __float128 getIorRasR();
 
  [[nodiscard]] size_t getISize_t();
};