soa.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
#include <vector>
#include <algorithm>
#include "determinations.h"
 
// Inc Pure
#include "dbc.h"
 
// Inc Rich
#include "so.h"
 
 
class Context;
 
 
class SOA : public SOcomposite {
  
  struct SOAArray {
    std::vector<SOp> stlvec_{};                    
    ~SOAArray() {
      for( auto * ptr : stlvec_ )
        delete ptr;
    }
  };
 
 
  std::shared_ptr<SOAArray> vec_;                
 
protected:
 
  void * shptr() const override { return static_cast<void *>( vec_.get() ); } 
 
 
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( !SOcomposite::invariant() )
      return false;
    return std::none_of( vec_->stlvec_.begin(), vec_->stlvec_.end(),
                         []( const SO * p ) {
                           return p == nullptr;
                         } );
  }                                              /* LCOV_EXCL_STOP */
#endif
 
public:
 
  explicit SOA( bool p_exec, size_t p_len = 0 );
 
  
  SOA( const SOA & p_other ) : SOcomposite(p_other), vec_(p_other.vec_) {
    DBC_INV_CTOR(SOA);
  }
 
 
  ~SOA() override {
    DBC_INV_CTOR(SOA);
  }
 
 
  SOA() = delete;
  SOA( SOA&& ) = delete;
  SOA & operator=( const SOA & ) = delete;
  SOA & operator=( SOA && ) = delete;
 
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;
 
    if( SOcomposite::otcodeIsComposite( p_sop->ot() ) && 
        static_cast<SOcomposite *>(p_sop)->dagheight( 0 ) >= DET_MAXDAGHEIGHT )
      inErrExit( semantics, "composite object DAG height exceeds maximum" );
 
    DBC_INV;
  }
 
 
  SOp ncat( 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() ? OTCode::Ax : OTCode::A;
  }
 
 
  std::string_view type() const override { return "arraytype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::A && p_other->ot() != OTCode::Ax )
      return false;
    const auto o = static_cast<const SOA *>( p_other );
    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(); }
 
 
  size_t dagheight( size_t p_myheight ) const override;
 
public: /* other */
 
  auto begin() const { return vec_->stlvec_.begin(); }
 
 
  auto end() const { return vec_->stlvec_.end(); }
 
 
  void reduce();
 
 
  void unfold2exec( Context & k ) const;
 
 
  SOp front_pop() {
    DBC_PRE( getSize() > 0 );
    DBC_INV_RAII(SOA);
 
    SOp retval = ncat( 0 );
    vec_->stlvec_.erase( begin() );
    return retval;
  }
 
 
  void bind( Context & k );
 
 
  int findSubArray( const SOA * p_sub );
 
 
 void substSubArray( size_t p_idx, size_t p_oldSize, const SOA * p_sub );
 
};