iter-source.hpp

Go to the documentation of this file.

/*
  ITER-SOURCE.hpp  -  an interface to build an opaque iterator-based data source 

  Copyright (C)         Lumiera.org
    2010,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef LIB_ITER_SOURCE_H
#define LIB_ITER_SOURCE_H


#include "lib/meta/util.hpp"
#include "lib/iter-adapter.hpp"
#include "lib/itertools.hpp"
#include "lib/nocopy.hpp"

#include <type_traits>
#include <utility>
#include <string>
#include <memory>




namespace lib {
  
  using std::string;
  using std::shared_ptr;
  using std::forward;
  
  
  
  template<typename TY>
  class IterSource
    {
      
    protected: /* == data source API to implement == */
      
      typedef TY* Pos;
      typedef shared_ptr<IterSource> DataHandle;
      

      virtual Pos firstResult ()         =0;
      
      virtual void nextResult(Pos& pos)  =0;
      
      virtual void disconnect () { }
      
      
      
    public:
      virtual ~IterSource() { };  
      
      virtual
      operator string()  const    
        {
          return "IterSource<" + lib::meta::typeStr<TY>()+ ">";
        }
      
      
      /* == Iteration control API for IterAdapter frontend == */
      
      friend bool                                                    
      checkPoint (DataHandle const&, Pos const& pos)
        {
          return bool(pos);
        }
      
      friend void
      iterNext (DataHandle& source, Pos& pos)
        {
          ASSERT (source);
          source->nextResult(pos);
        }
      
      
      /* == public builder API to create instances == */
      
      struct iterator
        : IterAdapter<Pos, DataHandle>
        {                                                
          using _I = IterAdapter<Pos, DataHandle>;
          using _I::IterAdapter;
          
          operator string()  const {return _I::source()? string(*_I::source()) : "⟂"; }
        };
      
      static iterator
      build (IterSource& sourceImpl)
        {
          return std::move(
              startIteration (DataHandle{&sourceImpl, &detach_without_destroy}));
        }
      
      static iterator
      build (IterSource* sourceImplObject)
        {
          return std::move(
              startIteration (DataHandle{sourceImplObject, &destroy_managed_source}));
        }
      
      static iterator EMPTY_SOURCE;
      
      using value_type = TY;
      using reference  = TY&;
      using pointer    = TY*;
      
      
      
    private:
      static iterator
      startIteration (DataHandle sourceHandle)
        {
          REQUIRE (sourceHandle);
          Pos first = sourceHandle->firstResult();
          return {move(sourceHandle), first};
        }
      
      
      static void
      detach_without_destroy (IterSource * source)
        {
          WARN_IF (!source, library, "IterSource deleter called with NULL source pointer");
          if (source)
            source->disconnect();
        }
      
      static void
      destroy_managed_source (IterSource * source)
        {
          WARN_IF (!source, library, "IterSource deleter called with NULL source pointer");
          if (source)
            {
              source->disconnect();
              delete source;
            }
        }
    };
  
  
  template<typename TY>
  typename IterSource<TY>::iterator IterSource<TY>::EMPTY_SOURCE = iterator();
  
  
  
  
  
  template<class IT,  class ISO = IterSource<typename meta::ValueTypeBinding<IT>::value_type>>
  class WrappedLumieraIter
    : public ISO
    , util::NonCopyable
    {
      IT src_;
      
    protected:
      using Pos = typename ISO::Pos;
      
      Pos                                                
      firstResult ()
        {
          if (!src_)
            return 0;
          else
            return & *src_;
        }
      
      void
      nextResult (Pos& pos)
        {
          if (!pos) return;
          if (src_) ++src_;
          if (src_)
            pos = & *src_;
          else
            pos = 0;
        }
      
      
      
    public:
      WrappedLumieraIter (IT const& orig)
        : src_(orig)
        { }
      
      WrappedLumieraIter (IT&& orig)
        : src_(forward<IT>(orig))
        { }
      
      
    protected:
      IT&       wrappedIter()       { return src_; }
      IT const& wrappedIter() const { return src_; }
    };
  
  
  
  
  /* === pre-defined Adapters for frequently used Containers === */
  
  namespace iter_source {
    namespace {  // traits and helpers...
    
      template<class CON>
      struct _SeqT
        {
          using Val  = typename CON::iterator::value_type;
          using Iter = typename IterSource<Val>::iterator;
        };
      
      template<class IT>
      struct _RangeT
        {
          using Val  = typename IT::value_type;
          using Iter = typename IterSource<Val>::iterator;
        };

      template<class MAP>
      struct _MapT
        {
          using Key     = typename MAP::key_type;
          using Val     = typename MAP::value_type::second_type;
          using KeyIter = typename IterSource<Key>::iterator;
          using ValIter = typename IterSource<Val>::iterator;
        };
      
      
      template<class IT>
      struct _IterT
        {
          using Src  = typename std::remove_reference<IT>::type;
          using Val  = typename Src::value_type;
          using Iter = typename IterSource<Val>::iterator;
        };
      
      template<class IT, class FUN>
      struct _TransformIterT
        {
          using       Src = typename std::remove_reference<IT>::type;
          using    ResVal = typename lib::meta::_Fun<FUN>::Ret;
          using TransIter = TransformIter<Src, ResVal>;
          using      Iter = typename IterSource<ResVal>::iterator;
        };
      
      template<class IT>
      struct _PairIterT
        {
          using          Src = typename std::remove_reference<IT>::type;
          using     PairType = typename Src::value_type;
          using      ValType = typename PairType::second_type;
          using ConstKeyType = typename PairType::first_type;
          
          // since we're returning the keys always by value,
          // we can strip the const added by the STL map types
          using KeyType = typename std::remove_const<ConstKeyType>::type;
          
          typedef TransformIter<Src, KeyType> KeyIter;
          typedef TransformIter<Src, ValType> ValIter;
          
          static KeyType  takeFirst (PairType const& pair) { return pair.first; }
          static ValType  takeSecond(PairType const& pair) { return pair.second;}
        };
      
      
      template<class IT>
      typename _PairIterT<IT>::KeyIter
      takePairFirst (IT&& source)
      {
        return transformIterator(forward<IT>(source), _PairIterT<IT>::takeFirst );
      }
      
      template<class IT>
      typename _PairIterT<IT>::ValIter
      takePairSecond (IT&& source)
      {
        return transformIterator(forward<IT>(source), _PairIterT<IT>::takeSecond );
      }
      
    } //(END) type helpers...
    
    
    
    template<class IT>
    typename _IterT<IT>::Iter
    wrapIter (IT&& source)
    {
      using Src = typename _IterT<IT>::Src;
      using Val = typename _IterT<IT>::Val;
      
      return IterSource<Val>::build (new WrappedLumieraIter<Src> (forward<IT>(source)));
    }
    
    
    template<typename VAL>
    auto
    singleVal (VAL&& something)
    {
      using Src = decltype(singleValIterator (forward<VAL>(something)));
      using Val = typename _IterT<Src>::Val;

      return IterSource<Val>::build (new WrappedLumieraIter<Src>{singleValIterator (forward<VAL>(something))});
    }
    
    
    template<class IT, class FUN>
    typename _TransformIterT<IT,FUN>::Iter
    transform (IT&& source, FUN processingFunc)
    {
      typedef typename _TransformIterT<IT,FUN>::ResVal    ValType;
      typedef typename _TransformIterT<IT,FUN>::TransIter TransIT;
      
      return IterSource<ValType>::build (
          new WrappedLumieraIter<TransIT> (
              transformIterator (forward<IT>(source), processingFunc)));
    }
    
    
    template<class MAP>
    typename _MapT<MAP>::KeyIter
    eachMapKey (MAP& map)
    {
      using Range = RangeIter<typename MAP::iterator>;
      
      Range contents (map.begin(), map.end());
      return wrapIter (takePairFirst (contents));
    }
    
    
    template<class MAP>
    typename _MapT<MAP>::ValIter
    eachMapVal (MAP& map)
    {
      using Range = RangeIter<typename MAP::iterator>;
      
      Range contents (map.begin(), map.end());
      return wrapIter (takePairSecond(contents));
    }
    
    
    template<class MAP>
    typename _MapT<MAP>::KeyIter
    eachDistinctKey (MAP& map)
    {
      using Range = RangeIter<typename MAP::iterator>;
      
      Range contents (map.begin(), map.end());
      return wrapIter (filterRepetitions (takePairFirst(contents)));
    }
    
    
    template<class MAP>
    typename _MapT<MAP>::ValIter
    eachValForKey (MAP& map, typename _MapT<MAP>::Key key)
    {
      using Pos = typename MAP::iterator;
      using Range = RangeIter<Pos>;
      
      std::pair<Pos,Pos> valuesForKey = map.equal_range(key);
      Range contents (valuesForKey.first, valuesForKey.second);
      return wrapIter (takePairSecond(contents));
    }
    
    
    template<class CON>
    typename _SeqT<CON>::Iter
    eachEntry (CON& container)
    {
      using ValType = typename _SeqT<CON>::Val;
      using Range   = RangeIter<typename CON::iterator>;
      
      Range contents (container.begin(), container.end());
      return IterSource<ValType>::build (new WrappedLumieraIter<Range>(contents));
    }
    
    
    template<class IT>
    typename _RangeT<IT>::Iter
    eachEntry (IT const& begin, IT const& end)
    {
      using ValType = typename _RangeT<IT>::Val;
      using Range   = RangeIter<IT>;

      Range contents (begin, end);
      return IterSource<ValType>::build (new WrappedLumieraIter<Range>(contents));
    }
  
    
}} // namespace lib::iter_source
#endif