Interval_map.cpp

#include <map>
#include<iostream>
#include <algorithm>
template<typename K, typename V>
class interval_map {
    friend void IntervalMapTest();
    V m_valBegin;
    std::map<K,V> m_map;
public:
    interval_map(V const& val)
    : m_valBegin(val)
    {}

void assign( K const& keyBegin, K const& keyEnd, V const& val ) {

    if(keyBegin > keyEnd) return;

    if(m_map.empty()&& val==m_valBegin) return;

    if(m_map.empty()){
       m_map.insert(std::pair<K,V>{keyBegin,val});
       m_map.insert(std::pair<K,V>{keyEnd,m_valBegin});
       return;
    }

    auto it_beg = m_map.lower_bound(keyBegin),it_end = m_map.upper_bound(keyEnd);


    m_map.erase(it_beg,it_end);

    m_map.insert(std::pair<K,V>{keyBegin,val});
    m_map.insert(std::pair<K,V>{keyEnd,val});

    m_map.rbegin()->second = m_valBegin;
    //(-2,X)(0,X)(1,B)(3,C)(4,A)(6,Z)(10,A)(12,A)(14,A)(15,F)(20,A)

    for(auto it = m_map.begin();it!=std::prev(m_map.end());it++){

       if(it->second==std::next(it)->second){
       if(it->first>=std::next(it)->first)
         m_map.erase(it);
       else m_map.erase(std::next(it));

         --it;
       }

    }

}

void print(){

  std::for_each(m_map.begin(),m_map.end(),[](const auto& p){ std::cout<< "(" << p.first << "," << p.second << ")"; });

  std::cout<<"\n";

}

    V const& operator[]( K const& key ) const {
        auto it=m_map.upper_bound(key);
        if(it==m_map.begin()) {
            return m_valBegin;
        } else {
            return (--it)->second;
        }
    }
};

int main(){


    interval_map<int,char> map{'A'};

    map.assign(1,3,'B');
    map.print();

    map.assign(3,5,'C');
    map.print();

    map.assign(4,7,'A');
    map.print();

    map.assign(6,10,'Z');
    map.print();

    map.assign(-2,0,'X');
    map.print();

    map.assign(15,20,'F');
    map.print();

    map.assign(12,14,'A');
    map.print();



    return 0;}