SetTracker.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_SETTRACKER_H
#define ZYPP_BASE_SETTRACKER_H

#include <iosfwd>
#include <utility>
#include <algorithm>
#include <ostream>

namespace zypp
{
  namespace base
  {
    template <class TSet>
    struct SetTracker
    {
      typedef  TSet                     set_type;
      typedef typename TSet::key_type   key_type;
      typedef typename TSet::value_type value_type;

      SetTracker()
      {}

      SetTracker( set_type initial_r )
      : _current( std::move(initial_r) )
      {}



      bool setInitial()
      { _added.clear(); _removed.clear(); return false; }

      bool setInitial( set_type new_r )
      {
        setInitial();
        bool changed = ( new_r != _current );
        if ( changed )
        {
          _current = std::move(new_r);
        }
        return changed;
      }


      bool set( set_type new_r )
      {
        bool changed = ( new_r != _current );
        if ( changed )
        {
          // build the initial (cur-add+rem) set in _current
          setDifference( _current, _added, _removed );
          _current.swap( _removed );
          _added.clear();
          _removed.clear();

          const set_type & initial( _current );
          setDifference( initial, new_r, _removed );
          setDifference( new_r, initial, _added );
          _current.swap( new_r );
        }
        return changed;
      }

      bool add( const value_type & val_r )
      {
        bool done = _current.insert( val_r ).second;
        if ( done )
        {
          if ( ! _removed.erase( val_r ) )
            _added.insert( val_r );
        }
        return done;
      }

      bool remove( const value_type & val_r )
      {
        bool done = _current.erase( val_r );
        if ( done )
        {
          if ( ! _added.erase( val_r ) )
            _removed.insert( val_r );
        }
        return done;
      }



      bool contains( const key_type & key_r ) const     { return find( _current, key_r ); }

      bool wasAdded( const key_type & key_r ) const     { return find( _added, key_r ); }

      bool wasRemoved( const key_type & key_r ) const   { return find( _removed, key_r ); }


      const set_type & current() const                  { return _current; }

      const set_type & added() const                    { return _added; }

      const set_type & removed() const                  { return _removed; }



      set_type & current()                              { return _current; }

      set_type & added()                                { return _added; }

      set_type & removed()                              { return _removed; }

    private:

      static bool find( const set_type & set_r, const key_type & key_r )
      { return set_r.find( key_r ) != set_r.end(); }

      template <class TORDERED_SET, typename enable_if = typename TORDERED_SET::key_compare>
      static void setDifference( const TORDERED_SET & lhs, const TORDERED_SET & rhs, TORDERED_SET & result_r )
      {
        // std::set_difference requires ordered sets!
        std::set_difference( lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
                             std::inserter( result_r, result_r.end() ),
                             typename TORDERED_SET::key_compare() );
      }

      template <class TUNORDERED_SET, typename enable_if = typename TUNORDERED_SET::hasher, typename = void>
      static void setDifference( const TUNORDERED_SET & lhs, const TUNORDERED_SET & rhs, TUNORDERED_SET & result_r )
      {
        // std::set_difference requires ordered sets!
        for ( const auto & l : lhs )
        { if ( rhs.find( l ) == rhs.end() ) result_r.insert( l ); }
      }

    private:
      set_type _current;
      set_type _added;
      set_type _removed;
    };

    template <class TSet>
    std::ostream & operator<<( std::ostream & str, const SetTracker<TSet> & obj )
    { return str << "set(" << obj.current().size() << "|+" << obj.added().size() << "|-" << obj.removed().size() << ')'; }

  } // namespace base
} // namespace zypp
#endif // ZYPP_BASE_SETTRACKER_H