selection.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_COMMON_PARALLEL_SELECTION_HH
#define DUNE_COMMON_PARALLEL_SELECTION_HH
 
#include <cstdint>
 
#include <dune/common/iteratorfacades.hh>
#include <dune/common/parallel/indexset.hh>
 
namespace Dune
{
  template<typename TS, typename TG, typename TL, int N>
  class SelectionIterator
  {
  public:
    typedef TS AttributeSet;
 
    typedef Dune::ParallelIndexSet<TG,TL,N> ParallelIndexSet;
 
    //typedef typename ParallelIndexSet::const_iterator ParallelIndexSetIterator;
 
    typedef ConstArrayListIterator<IndexPair<TG,TL>, N, std::allocator<Dune::IndexPair<TG,TL> > > ParallelIndexSetIterator;
    SelectionIterator(const ParallelIndexSetIterator& iter, const ParallelIndexSetIterator& end)
      : iter_(iter), end_(end)
    {
      // Step to the first valid entry
      while(iter_!=end_ && !AttributeSet::contains(iter_->local().attribute()))
        ++iter_;
    }
 
    void operator++()
    {
      assert(iter_!=end_);
      for(++iter_; iter_!=end_; ++iter_)
        if(AttributeSet::contains(iter_->local().attribute()))
          break;
    }
 
 
    uint32_t operator*() const
    {
      return iter_->local().local();
    }
 
    bool operator==(const SelectionIterator<TS,TG,TL,N>& other) const
    {
      return iter_ == other.iter_;
    }
 
    bool operator!=(const SelectionIterator<TS,TG,TL,N>& other) const
    {
      return iter_ != other.iter_;
    }
 
  private:
    ParallelIndexSetIterator iter_;
    const ParallelIndexSetIterator end_;
  };
 
 
  template<typename TS, typename TG, typename TL, int N>
  class UncachedSelection
  {
  public:
    typedef TS AttributeSet;
 
    typedef TG GlobalIndex;
 
    typedef TL LocalIndex;
 
    typedef Dune::ParallelIndexSet<GlobalIndex,LocalIndex,N> ParallelIndexSet;
 
    typedef SelectionIterator<TS,TG,TL,N> iterator;
 
    typedef iterator const_iterator;
 
    UncachedSelection()
      : indexSet_()
    {}
 
    UncachedSelection(const ParallelIndexSet& indexset)
      : indexSet_(&indexset)
    {}
    void setIndexSet(const ParallelIndexSet& indexset);
 
    //const ParallelIndexSet& indexSet() const;
 
    const_iterator begin() const;
 
    const_iterator end() const;
 
 
  private:
    const ParallelIndexSet* indexSet_;
 
  };
 
  template<typename TS, typename TG, typename TL, int N>
  class Selection
  {
  public:
    typedef TS AttributeSet;
 
    typedef TG GlobalIndex;
 
    typedef TL LocalIndex;
 
    typedef Dune::ParallelIndexSet<GlobalIndex,LocalIndex,N> ParallelIndexSet;
 
    typedef uint32_t* iterator;
 
    typedef uint32_t* const_iterator;
 
    Selection()
      : selected_()
    {}
 
    Selection(const ParallelIndexSet& indexset)
      : selected_(), size_(0), built_(false)
    {
      setIndexSet(indexset);
    }
 
    ~Selection();
 
    void setIndexSet(const ParallelIndexSet& indexset);
 
    void free();
 
    //IndexSet indexSet() const;
 
    const_iterator begin() const;
 
    const_iterator end() const;
 
 
  private:
    uint32_t* selected_;
    size_t size_;
    bool built_;
 
  };
 
  template<typename TS, typename TG, typename TL, int N>
  inline void Selection<TS,TG,TL,N>::setIndexSet(const ParallelIndexSet& indexset)
  {
    if(built_)
      free();
 
    // Count the number of entries the selection has to hold
    typedef typename ParallelIndexSet::const_iterator const_iterator;
    const const_iterator end = indexset.end();
    int entries = 0;
 
    for(const_iterator index = indexset.begin(); index != end; ++index)
      if(AttributeSet::contains(index->local().attribute()))
        ++entries;
 
    selected_ = new uint32_t[entries];
    built_ = true;
 
    entries = 0;
    for(const_iterator index = indexset.begin(); index != end; ++index)
      if(AttributeSet::contains(index->local().attribute()))
        selected_[entries++]= index->local().local();
 
    size_=entries;
    built_=true;
  }
 
  template<typename TS, typename TG, typename TL, int N>
  uint32_t* Selection<TS,TG,TL,N>::begin() const
  {
    return selected_;
  }
 
  template<typename TS, typename TG, typename TL, int N>
  uint32_t* Selection<TS,TG,TL,N>::end() const
  {
    return selected_+size_;
  }
 
  template<typename TS, typename TG, typename TL, int N>
  inline void Selection<TS,TG,TL,N>::free()
  {
    delete[] selected_;
    size_=0;
    built_=false;
  }
 
  template<typename TS, typename TG, typename TL, int N>
  inline Selection<TS,TG,TL,N>::~Selection()
  {
    if(built_)
      free();
  }
 
  template<typename TS, typename TG, typename TL, int N>
  SelectionIterator<TS,TG,TL,N> UncachedSelection<TS,TG,TL,N>::begin() const
  {
    return SelectionIterator<TS,TG,TL,N>(indexSet_->begin(),
                                         indexSet_->end());
  }
 
  template<typename TS, typename TG, typename TL, int N>
  SelectionIterator<TS,TG,TL,N> UncachedSelection<TS,TG,TL,N>::end() const
  {
    return SelectionIterator<TS,TG,TL,N>(indexSet_->end(),
                                         indexSet_->end());
  }
  template<typename TS, typename TG, typename TL, int N>
  void UncachedSelection<TS,TG,TL,N>::setIndexSet(const ParallelIndexSet& indexset)
  {
    indexSet_ = &indexset;
  }
 
}
#endif // DUNE_COMMON_PARALLEL_SELECTION_HH