sox.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <map>
#include <numeric>
#include <vector>
#include <memory>
#include "helper.h"
#include "so.h"
#include "context.h"
 
using namespace std;
 
 
/* ******************************************************************* */
/* Simple Objects                                                      */
/* SO's that store their data without indirect referencing             */
/* ******************************************************************* */
 
 
class SOM : public SO {
public_virtual
  SOM * dup() const override { return new SOM; }
  string opequal() const override { return "--nostringval--"; }
  string opequalequal( Context & ) const override { return "-mark-"; }
  OTCode ot() const override { return 'M'; }
  bool equal( const SO* p_other ) const override {         // We can't use SOp here. Doxygen fails to identify the override with this typedef.
    return dynamic_cast<const SOM*>( p_other) != nullptr;  // All SOM are equal
  }
};
 
 
class SO0 : public SO {
public_virtual
  SO0 * dup() const override { return new SO0; }
  string opequal() const override { return "--nostringval--"; }
  string opequalequal( Context & ) const override { return "null"; }
  OTCode ot() const override { return '0'; }
  bool equal( const SO* p_other ) const override {
    return dynamic_cast<const SO0*>( p_other) != nullptr;  // All SO0 are equal
  }
};
 
 
class SOI : public SO {
  __int128 i_;           
public:
  explicit SOI( const string& p_s ) : i_(stoint128(p_s)) {}
  explicit SOI( __int128 p_i ) : i_(p_i) {}
 
public_accessor
  __int128 getInteger() const { return i_; }
  void setInteger( __int128 p_i ) { i_=p_i; }
 
public_virtual
  SOI * dup() const override { return new SOI( i_ ); }
  string opequal() const override { return to_string( i_ ); }
  OTCode ot() const override { return 'I'; }
  bool equal( const SO* p_other ) const override {
    const SOI* o = dynamic_cast<const SOI*>( p_other);
    if( o ) return i_ == o->i_;
    return false;
  }
};
 
 
class SOB : public SO {
  bool b_;         
public:
  explicit SOB( const string& p_s ) { b_ = p_s == "true"; }
  explicit SOB( bool p_b ) : b_(p_b) {}
 
public_accessor
  bool getB() const { return b_; }
  void setB( bool p_b ) { b_ = p_b; }
 
public_virtual
  SOB * dup() const override { return new SOB( b_ ); }
  string opequal() const override { return b_ ? "true" : "false"; }
  OTCode ot() const override { return 'B'; }
  bool equal( const SO* p_other ) const override {
    const SOB* o = dynamic_cast<const SOB*>( p_other);
    if( o ) return b_ == o->b_;
    return false;
  }
 
public_other
  void negation() { b_ = !b_; }
};
 
 
class SOR : public SO {
  __float128 r_;      
public:
  explicit SOR( const string& p_s ) : r_(stofloat128(p_s)) {}
  explicit SOR( __float128 p_r ) : r_(p_r) {}
 
public_accessor
  __float128 getReal() const { return r_; }
  void setReal( __float128 p_r ) { r_ = p_r; }
 
public_virtual
  SOR * dup() const override { return new SOR( r_ ); }
  string opequal() const override { return to_string( r_ ); }
  OTCode ot() const override { return 'R'; }
  bool equal( const SO* p_other ) const override {
    const SOR* o = dynamic_cast<const SOR*>( p_other);
    if( o ) return r_ == o->r_;
    return false;
  }
};
 
 
class SON : public SO {
  string n_;                 
public:
  explicit SON( const string& p_n, bool p_exec = false ) : SO(p_exec), n_(p_n) { }
 
public_virtual
  SON * dup() const override { return new SON( n_, getExec() ); }
  string opequal() const override {
    if( exec_ ) return n_;
    return "/"+n_;
  }
  OTCode ot() const override { return exec_ ? 'n' : 'N'; }
  bool equal( const SO* p_other ) const override {
    const SON* o = dynamic_cast<const SON*>( p_other);
    if( o ) return n_ == o->n_;
    return false;
  }
  size_t getSize() const override { return n_.size(); }
 
public_other
  void load( Context & k ) const;
};
 
 
class SOO : public SO {
  void (*f_)( Context & );    
  string s_;                  
public:
  explicit SOO( void (*p_f)( Context & ), const string& p_s ) : f_(p_f), s_(p_s) { }
 
public_virtual
  SOO * dup() const override { return new SOO( f_, s_ ); }
  string opequal() const override { return "--"+s_+"--"; }
  OTCode ot() const override { return 'O'; }
  bool equal( const SO* p_other ) const override {
    const SOO* o = dynamic_cast<const SOO*>( p_other);
    if( o ) return f_ == o->f_;
    return false;
  }
 
public_other
  void exec( Context & k ) { f_(k); }
};
 
 
class SOo : public SOO {
  size_t stackusage_;   
public:
  SOo( void (*p_f)( Context & ), const string & p_s, size_t p_stackusage )
      : SOO( p_f, p_s ), stackusage_(p_stackusage) { }
 
public_accessor
  size_t getStackusage() const { return stackusage_; }
 
public_virtual
  OTCode ot() const override { return 'o'; }
};
 
 
/* ************************************************************ */
/* Composite Objects                                            */
/* SO's that reference their data with shared_ptr<>             */
/* ************************************************************ */
 
 
class SOS : public SO {
  shared_ptr<string> s_;      
  explicit SOS( shared_ptr<string> p_s ) : s_(p_s) {}
 
public:
  explicit SOS( string p_s ) : s_(make_shared<string>(p_s)) { }
 
  ~SOS() = default;
 
public_accessor
  string getString() const { return *s_; }
 
public_virtual
  SOS* dup() const override { return new SOS( s_ ); }
  SOS* clone() const override { return new SOS( *s_ ); }
  string opequal() const override { return *s_; }
  string opequalequal( Context & ) const override { return "("+*s_+")"; }
  OTCode ot() const override { return 'S'; }
  bool equal( const SO* p_other ) const override {
    const SOS* o = dynamic_cast<const SOS*>( p_other);
    if( o ) return *s_ == *(o->s_);       // SOS are equal if their value is equal, even with non-shared pointers
    return false;
  }
  size_t getSize() const override { return s_->size(); }
 
public_other
  void setch( size_t index, int ch ) { (*s_)[index] = ch; }
 
  void erase0() { s_->erase(0,1); }
};
 
 
class SOA : public SO {
  struct SOAArray {
    vector<SOp> a_;                         
    ~SOAArray() { for( auto ptr : a_ ) delete ptr; }
  };
  shared_ptr<SOAArray> v_;                  
  SOA( shared_ptr<SOAArray> p_v, bool p_exec ) : SO(p_exec), v_(p_v) {}
 
public:
  explicit SOA( size_t p_l = 0, bool p_exec = false ) : SO(p_exec) {
    v_ = make_shared<SOAArray>();
    for( size_t i = 1; i <= p_l; i++ )
      v_->a_.push_back( new SO0 );
  }
 
public_accessor
  void setSO( size_t p_index, SOp p_o ) {
    delete v_->a_[p_index];
    v_->a_[p_index] = p_o;
  }
 
  SOp at( size_t p_pos ) const { return v_->a_.at( p_pos ); }
 
public_virtual
  SOA* dup() const override { return new SOA( v_, getExec() ); }
  SOA* clone() const override {  // IDEA: work around the temporary construction of all the SO0 objects.
    SOA* rv = new SOA( getSize(), exec_ );
    for( size_t i = 0; i < getSize(); i++ )
      rv->setSO( i, at(i)->clone() );
    return rv;
  }
  string opequal() const override { return "--nostringval--"; }
  string opequalequal( Context & ) const override;
  OTCode ot() const override { return exec_ ? 'a' : 'A'; }
  bool equal( const SO* p_other ) const override {
    const SOA* o = dynamic_cast<const SOA*>( p_other);
    if( o ) {
      if( getSize() == 0 && o->getSize() == 0 ) return true;   // Exception: arrays of size zero are always equal.
      return v_ == o->v_;
    }
    return false;
  }
  size_t getSize() const override { return v_->a_.size(); }
 
public_other
  void reduce() {
    const size_t s = getSize();
    if( !s ) return;
    SOp last = v_->a_.at( s-1 );
    v_->a_.pop_back();
    delete last;
  }
 
  void unfold2exec( Context & k ) const {
    for( size_t s = getSize(); s>0; s-- )
      k.exst().push( at(s-1)->dup() );
  }
 
  SOp front_pop() {
    SOp retval = v_->a_.at(0);
    v_->a_.erase( v_->a_.begin() );
    return retval;
  }
};
 
 
class SOD : public SO {
  struct SODMap {
    map<SOp,SOp> a_;       
    ~SODMap() { for( const auto& ptr : a_ ) { delete ptr.first; delete ptr.second; } }
  };
  shared_ptr<SODMap> d_;   
  explicit SOD( shared_ptr<SODMap> p_d ) : d_(p_d) {}
 
public:
  SOD() { d_ = make_shared<SODMap>(); }
 
public_virtual
  SOD* dup() const override { return new SOD( d_ ); }
  SOD* clone() const override {
    SOD* rv = new SOD();
    for( auto& ptr : d_->a_ ) rv->insert( ptr.first->clone(), ptr.second->clone() );
    return rv;
  }
  string opequal() const override { return "--nostringval--"; }
  string opequalequal( Context & k ) const override;
  OTCode ot() const override { return 'D'; }
  bool equal( const SO* p_other ) const override {
    const SOD* o = dynamic_cast<const SOD*>( p_other);
    if( o ) return d_ == o->d_;
    return false;
  }
  size_t getSize() const override { return d_->a_.size(); }
 
public_other
  void insert( SOp p_key,                   
               SOp p_value,                 
               bool p_forcebegin = false    
             );
 
  SOp find( const SO * p_key ) const;
 
  pair<SOp,SOp> any_pop() {
    auto it = d_->a_.begin();
    pair<SOp,SOp> retval( *it );
    d_->a_.erase( it );
    return retval;
  }
};