soa.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <vector>
#include <algorithm>
 
// Inc HAA
#include "dbc.h"
#include "helper.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:
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( vec_ == nullptr )
      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( treeheight( 0 ) >= maxtreeheight )
      inErrExit( semantics, "composite object tree 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 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(); }
 
 
  size_t treeheight( size_t p_myheight ) const override;
 
 
public: /* other */
  auto begin() { return vec_->stlvec_.begin(); }
 
 
  auto end() { 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 );
};