sos.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
#include <memory>
 
// Inc Pure
#include "dbc.h"
#include "helper.h"
 
// Inc Rich
#include "so.h"
 
 
class SOS : public SOshptr {
 
  std::shared_ptr<std::string> str_;
 
protected:
 
  void * shptr() const override { return static_cast<void *>( str_.get() ); } 
 
public:
 
  explicit SOS( const std::string & p_str )
    : SOshptr(),
      str_(std::make_shared<std::string>(p_str)) {
    DBC_INV_CTOR(SOS);
  }
 
 
  SOS( const SOS & p_other ) : SOshptr(p_other), str_(p_other.str_) {
    DBC_INV_CTOR(SOS);
  }
 
 
  SOS( const SOshptr & p_other, const std::string & p_str )
    : SOshptr( p_other ),
      str_( std::make_shared<std::string>(p_str) ) {
    DBC_INV_CTOR(SOS);
  }
 
 
  ~SOS() override {
    DBC_INV_CTOR(SOS);
  }
 
 
  SOS() = delete;
  SOS( SOS && ) = delete;
  SOS & operator=( const SOS & ) = delete;
  SOS & operator=( SOS && ) = delete;
 
public: /* accessor */
 
  std::string getString() const { return *str_; }
 
 
  std::string & getStringRef() { return *str_; }
 
public: /* virtual */
 
  [[nodiscard]] SOS * dup() const override { return new SOS( *this ); }
 
 
  [[nodiscard]] SOS * clone() const override {
    auto rv = new SOS( static_cast<const SOshptr &>(*this), *str_ );
 
    DBC_POST( rv != nullptr );
    DBC_POST( rv->invariant() );
    return rv;
  }
 
 
  std::string opequal() const override { return *str_; }
 
 
  std::string opequalequal() const override { return "(" + *str_ + ")"; }
 
 
  OTCode ot() const override { return OTCode::S; }
 
 
  std::string_view type() const override { return "stringtype"; }
 
 
  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 SOS *>( p_other );
    return str_ == o->str_ or
          *str_ == *(o->str_);       // SOS are equal if their value is equal, even with non-shared pointers
  }
 
 
  bool gt( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::S ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOS *>( p_other );
    p_ec = success;
    return *str_ > *(o->str_);
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::S ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOS *>( p_other );
    p_ec = success;
    return *str_ >= *(o->str_);
  }
 
 
  size_t getSize() const override { return str_->size(); }
 
public: /* other */
 
  void putCh( size_t p_index, int p_char );
 
 
  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;
  }
 
};