sod.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <map>
#include <numeric>
#include <algorithm>
#include <memory>
 
// Inc HAA
#include "dbc.h"
#include "helper.h"
 
// Inc Rich
#include "so.h"
 
 
class Context;
 
 
class SOD : public SOcomposite {
 
  struct SODMap {
    std::map<SOp,SOp> 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:
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( map_ == nullptr )
      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 type() const override { return "dicttype"; }
 
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOD*>( p_other);
    return o ? map_ == o->map_ : false;
  }
 
 
  size_t getSize() const override { return map_->stlmap_.size(); }
 
 
  size_t treeheight( size_t p_myheight ) const override;
 
 
public: /* other */
  auto begin() { return map_->stlmap_.begin(); }
 
 
  auto end() { return map_->stlmap_.end(); }
 
 
  void insert( SOp p_key, SOp p_value, bool p_forcebegin = false );
 
 
  SOp find( const 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( const SO * p_key );
};