sos.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <memory>
 
// Inc HAA
#include "dbc.h"
#include "helper.h"
 
// Inc Rich
#include "so.h"
 
 
class SOS : public SOcomposite {
 
  std::shared_ptr<std::string> str_;
 
 
protected:
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    return str_ != nullptr;
  }                                              /* LCOV_EXCL_STOP */
#endif
 
 
public:
  explicit SOS( const std::string & p_str )
    : SOcomposite(),
      str_(std::make_shared<std::string>(p_str)) {
    DBC_INV_CTOR(SOS);
  }
 
 
  SOS( const SOS & p_other ) : SOcomposite(p_other), str_(p_other.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( *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_ + ")"; }
 
 
  OTCode ot() const override { return OTCode::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( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOS *>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    p_ec = success;
    return *str_ > *(o->str_);
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOS *>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    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;
  }
 
};