dbpp_ListSectionsFlow.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <map>
#include <algorithm>
#include "dbpp_SectionFlow.h"
#include "include/Sfx_DefineTypes.h"
 
namespace dbpp 
{
  class ListSectionsFlow 
  {
  public:
    using vec_sizetype = std::vector<SectionFlow>::size_type;
    using vec_valtype = std::vector<SectionFlow>::value_type;
    using vec_iter = std::vector<SectionFlow>::iterator;
    using vec_citer = std::vector<SectionFlow>::const_iterator;
    using vec_riter = std::reverse_iterator<vec_iter>;
    using vec_rciter = std::reverse_iterator<vec_citer>;
 
    // **************** STL-like Container ***************
    vec_iter begin() { return m_listSectionsFlow.begin(); }
    vec_iter end()   { return m_listSectionsFlow.end();}
    vec_riter rbegin() { return m_listSectionsFlow.rbegin(); }
    vec_riter rend()   { return m_listSectionsFlow.rend(); }
    vec_citer cbegin() const { return m_listSectionsFlow.cbegin(); }
    vec_citer cend()   const { return m_listSectionsFlow.cend(); }
    vec_rciter crbegin() const { return m_listSectionsFlow.crbegin(); }
    vec_rciter crend() const { return m_listSectionsFlow.crend(); }
 
  public:
    // New ctor to take account that subject can be shared by many instances
// make sure that we still pointing to a valid instance (DEPRECATED!!)
    //explicit ListSectionsFlow( vec_sizetype aNbSections=100) {/*not implemented yet*/ }
    void push_back( const SectionFlow& aSectF) { m_listSectionsFlow.push_back(aSectF); }
    void push_back( SectionFlow&& aSectF) { m_listSectionsFlow.push_back(std::move(aSectF)); }
    bool contains(SectionFlow aSectF2Find)
    {
      // use the find algorithm, of the stl ()
      if (std::find(m_listSectionsFlow.begin(), m_listSectionsFlow.end(), aSectF2Find) != m_listSectionsFlow.end())
      {
        // found something
        return true;
      }
      return false;
    }

    void clear() { m_listSectionsFlow.clear(); }
 
    // Design Note: should i return a reference?
    SectionFlow& operator[] (vec_sizetype aIdx)
    {
      return m_listSectionsFlow[aIdx];
    }
    const SectionFlow& operator[] (vec_sizetype aIdx) const
    {
      return m_listSectionsFlow[aIdx];
    }

    [[nodiscard]] bool isEmpty() const noexcept { return m_listSectionsFlow.empty(); }
    vec_sizetype size() const noexcept { return m_listSectionsFlow.size(); }
    void shrink2Fit() { m_listSectionsFlow.shrink_to_fit(); }
    std::vector<SectionFlow> getList() const noexcept
    {
      return m_listSectionsFlow;
    }

    const SectionFlow& front() const { return m_listSectionsFlow.front(); }
    const SectionFlow& back() const  { return m_listSectionsFlow.back();  }
    void reserve( vec_sizetype aSize) { m_listSectionsFlow.reserve(aSize); }

    bool isFrictionLess() const
    {
      return (std::all_of(m_listSectionsFlow.cbegin(), m_listSectionsFlow.cend(),
        [](const SectionFlow& aSectFlow)
        {
          return aSectFlow.N() == 0.;
        }));
    }

    bool isFlatBed() const
    {
      return (std::all_of(m_listSectionsFlow.cbegin(), m_listSectionsFlow.cend(),
        [](const SectionFlow& aSectFlow)
        {
          return aSectFlow.Z() == 0.;
        }));
    }

    bool isUnitWidth() const
    {
      return (std::all_of(m_listSectionsFlow.cbegin(), m_listSectionsFlow.cend(),
        [](const SectionFlow& aSectFlow)
        {
          return aSectFlow.B() == 1.;
        }));
    }

    std::map<unsigned, float64> getSectionsManning() const
    {
      std::map<unsigned int, double> w_sectManningMap;
      // Manning coefficient
      for (const auto& w_sect : m_listSectionsFlow)
      {
        w_sectManningMap.insert({ w_sect.getId(), w_sect.N() });
      }
      return w_sectManningMap;
    }

    std::map<unsigned, float64> getSectionsBathymetry() const
    {
      std::map<unsigned int, double> w_sectBathymetryMap;
      // Manning coefficient
      for (const auto& w_sect : m_listSectionsFlow)
      {
        w_sectBathymetryMap.insert({ w_sect.getId(), w_sect.Z() });
      }
      return w_sectBathymetryMap;
    }

    std::map<unsigned, double> getSectionsWaterLevel() const
    {
      std::map<unsigned int, double> w_sectWaterLevelMap;
      // Manning coefficient
      for (const auto& w_sect : m_listSectionsFlow)
      {
        w_sectWaterLevelMap.insert({ w_sect.getId(), w_sect.H() });
      }
      return w_sectWaterLevelMap;
    }
  private:
    std::vector<SectionFlow> m_listSectionsFlow; 
  };
} // End of namespace