socomp.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <map>
#include <numeric>
#include <vector>
#include <memory>
 
#include "dbc.h"
#include "helper.h"
#include "so.h"
 
class Context;
 
/* ************************************************************ */
/* Composite Objects                                            */
/* SO's that reference their data with shared_ptr<>             */
/* ************************************************************ */
 
class SOS : public SOcomp {
  std::shared_ptr<std::string> str_;      
protected:
 
#ifndef DBC_IS_VOID
 
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( str_ == nullptr )
      return false;
    return true;
  }                                              /* LCOV_EXCL_STOP */
 
#endif
 
public:
  explicit SOS( const std::string & p_str ) : str_(std::make_shared<std::string>(p_str)) {
    DBC_INV_CTOR(SOS);
  }
 
public: /* accessor */
  std::string getString() const { return *str_; }
 
  void setch( size_t p_index, int p_char );
 
public: /* virtual */
  [[nodiscard]] SOS * dup() const override { return new SOS( *this ); }
 
  [[nodiscard]] SOS * clone() const override {
    auto rv = new SOS( *str_ );
    rv->setExec( getExec() );
 
    DBC_POST( rv != nullptr );
    DBC_POST( rv->invariant() );
    return rv;
  }
 
  std::string opequal() const override { return *str_; }
 
  std::string opequalequal() const override { return "(" + *str_ + ")"; }  // TODO: Should print "\000" for character 0 within string length.
 
  OTCode ot() const override { return 'S'; }
 
  std::string type() const override { return "stringtype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOS *>( p_other );
    return o ? *str_ == *(o->str_) : false;       // SOS are equal if their value is equal, even with non-shared pointers
  }
 
  bool gt( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOS *>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    return *str_ > *(o->str_);
  }
 
  bool ge( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOS *>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    return *str_ >= *(o->str_);
  }
 
  size_t getSize() const override { return str_->size(); }
 
public: /* other */
  void erase0() {
    str_->erase(0,1); 
 
    DBC_INV;
  }
 
  void replace( size_t p_pos, const std::string & p_src ) {
    DBC_PRE( p_pos + p_src.size() <= getSize() );
 
    str_->replace( p_pos, p_src.size(), p_src );
 
    DBC_INV;
  }
};
 
 
class SOA : public SOcomp {
  struct SOAArray {
    std::vector<SOp> stlvec_;                         
    ~SOAArray() {
      for( auto * ptr : stlvec_ )
        delete ptr;
    }
  };
 
  std::shared_ptr<SOAArray> vec_;                  
protected:
 
#ifndef DBC_IS_VOID
 
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( vec_ == nullptr )
      return false;
    for( const auto * obj : vec_->stlvec_ )  // IDEA: use std::all_of()
      if( obj == nullptr )
        return false;
    return true;
  }                                              /* LCOV_EXCL_STOP */
 
#endif
 
 
public:
  explicit SOA( size_t p_len = 0, bool p_exec = false );
 
public: /* accessor */
  void setSO( size_t p_index, SOp p_sop ) {
    DBC_PRE( p_index < getSize() );
    DBC_PRE( p_sop != nullptr );
 
    delete vec_->stlvec_[p_index];
    vec_->stlvec_[p_index] = p_sop;
 
    DBC_INV;
  }
 
  SOp at( size_t p_pos ) const {
    DBC_PRE( p_pos < getSize() );
 
    return vec_->stlvec_[ p_pos ];
  }
 
public: /* virtual */
  [[nodiscard]] SOA * dup() const override { return new SOA( *this ); }
 
  [[nodiscard]] SOA * clone() const override;
 
  std::string opequalequal() const override;
 
  OTCode ot() const override {
    return getExec() ? 'a' : 'A';
  }
 
  std::string type() const override { return "arraytype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOA*>( p_other );
    if( !o ) return false;
    if( getSize() == 0 && o->getSize() == 0 )
      return true;         // Exception: arrays of size zero are always equal.
    return vec_ == o->vec_;
    }
 
  size_t getSize() const override { return vec_->stlvec_.size(); }
 
public: /* other */
  void reduce();
 
  void unfold2exec( Context & k ) const;
 
  SOp front_pop() {
    DBC_PRE( getSize() > 0 );
    DBC_INV_RAII(SOA);
 
    SOp retval = at( 0 );
    vec_->stlvec_.erase( vec_->stlvec_.begin() );
    return retval;
  }
 
  void bind( Context & k );
};
 
 
class SOD : public SOcomp {
  struct SODMap {
    std::map<SOp,SOp> stlmap_;       
    ~SODMap() {
      for( const auto & ptr : stlmap_ ) {
        delete ptr.first;
        delete ptr.second;
      }
    }
  };
 
  std::shared_ptr<SODMap> map_;   
protected:
 
#ifndef DBC_IS_VOID
 
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( map_ == nullptr )
      return false;
    for( const auto & obj : map_->stlmap_ )
      if( obj.first == nullptr or obj.second == nullptr )
        return false;
    return true;
  }                                              /* LCOV_EXCL_STOP */
 
#endif
 
public:
  SOD() : map_(std::make_shared<SODMap>()) {
    DBC_INV_CTOR(SOD);
  }
 
public: /* virtual */
  [[nodiscard]] SOD * dup() const override { return new SOD( *this ); }
 
  [[nodiscard]] SOD * clone() const override;
 
  std::string opequalequal() const override;
 
  OTCode ot() const override { return 'D'; }
 
  std::string type() const override { return "dicttype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOD*>( p_other);
    return o ? map_ == o->map_ : false;
  }
 
  size_t getSize() const override { return map_->stlmap_.size(); }
 
public: /* other */
  void insert( SOp p_key, SOp p_value, bool p_forcebegin = false );
 
  SOp find( const SO * p_key ) const;
 
  auto any_pop() {
    DBC_PRE( getSize() > 0 );
    DBC_INV_RAII( SOD );
 
    auto it = map_->stlmap_.begin();
    std::pair<SOp,SOp> retval( *it );
    map_->stlmap_.erase( it );
    return retval;
  }
 
  void undef( const SO * p_key ) const;
};