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