sod.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
#include <numeric>
#include <algorithm>
#include <unordered_map>
#include <functional>        // for std::hash
 
// Inc Pure
#include "dbc.h"
#include "helper.h"
 
// Inc Rich
#include "so.h"
#include "sosimp.h"          // we reference SON
 
 
class Context;
 
 
class SOD : public SOcomposite {
 
  struct FunctorHash {
 
    size_t operator()( const SOp & p_key ) const {
      DBC_PRE( p_key != nullptr ); 
 
      const OTCode isN = p_key->ot();
      if( SON::otcodeIsName( isN ) ) {
        const SON * son = static_cast<const SON *>( p_key );
        return std::hash<std::string>{}( son->getName() );
      }
      return std::hash<char>{}( static_cast<char>( isN ) );
    }
 
  };
 
 
  struct FunctorEqual {
 
    bool operator()( const SOp & p_lhs, const SOp & p_rhs ) const {
      DBC_PRE( p_lhs != nullptr ); 
      DBC_PRE( p_rhs != nullptr ); 
 
      return p_lhs->equal( p_rhs );
    }
 
  };
 
 
  struct SODMap {
 
    std::unordered_map<SOp,SOp,FunctorHash,FunctorEqual> stlmap_{};       
    ~SODMap() {
      std::for_each( stlmap_.begin(), stlmap_.end(),
                     []( const auto & p_pair ) {
                       delete p_pair.first;
                       delete p_pair.second;
                     } );
    }
  
  };
 
 
  std::shared_ptr<SODMap> map_;
 
protected:
  
  void * shptr() const override { return static_cast<void *>( map_.get() ); } 
 
 
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( !SOcomposite::invariant() )
      return false;
    return std::none_of( map_->stlmap_.begin(), map_->stlmap_.end(),
                         []( const auto & p ) {
                           return p.first == nullptr or p.second == nullptr;
                         } );
  }                                              /* LCOV_EXCL_STOP */
#endif
 
public:
 
  SOD()
    : SOcomposite(),
      map_(std::make_shared<SODMap>()) {
    DBC_INV_CTOR(SOD);
  }
 
 
  explicit SOD( const SOcomposite & p_other )
    : SOcomposite( p_other ),
      map_(std::make_shared<SODMap>()) {
    DBC_INV_CTOR(SOD);
  }
 
 
  SOD( const SOD & p_other ) : SOcomposite(p_other), map_(p_other.map_) {
    DBC_INV_CTOR(SOD);
  }
 
 
  ~SOD() override {
    DBC_INV_CTOR(SOD);
  }
 
 
  SOD( SOD&& ) = delete;
  SOD & operator=( const SOD & ) = delete;
  SOD & operator=( SOD && ) = delete;
 
public: /* virtual */
 
  [[nodiscard]] SOD * dup() const override { return new SOD( *this ); }
 
  [[nodiscard]] SOD * clone() const override;
 
 
  std::string opequalequal() const override;
 
 
  OTCode ot() const override { return OTCode::D; }
 
 
  std::string_view type() const override { return "dicttype"; }
 
 
  size_t getSize() const override { return map_->stlmap_.size(); }
 
 
  size_t dagheight( size_t p_myheight ) const override;
 
public: /* other */
 
  auto begin() const { return map_->stlmap_.begin(); }
 
 
  auto end() const { return map_->stlmap_.end(); }
 
 
  void insert( SOp p_key, SOp p_value );
 
 
  SOp find( SO * p_key ) const;
 
 
  auto any_pop() {
    DBC_PRE( getSize() > 0 );
    DBC_INV_RAII( SOD );
 
    auto it = begin();
    auto retval( *it );
    map_->stlmap_.erase( it );
    return retval;
  }
 
 
  void undef( SO * p_key );
 
};