plocalindex.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_PLOCALINDEX_HH
#define DUNE_COMMON_PARALLEL_PLOCALINDEX_HH
 
#include <iostream>
 
#if HAVE_MPI
#include <mpi.h>
#endif
 
#include <dune/common/parallel/indexset.hh>
#include <dune/common/parallel/localindex.hh>
#include <dune/common/parallel/mpitraits.hh>
 
namespace Dune
{
 
 
  template<class T> class ParallelLocalIndex;
 
  template<class T>
  std::ostream& operator<<(std::ostream& os, const ParallelLocalIndex<T>& index)
  {
    os<<"{local="<<index.localIndex_<<", attr="<<T(index.attribute_)<<", public="
    <<(index.public_ ? true : false)<<"}";
    return os;
  }
 
  template<typename T>
  class ParallelLocalIndex
  {
#if HAVE_MPI
    // friend declaration needed for MPITraits
    friend struct MPITraits<ParallelLocalIndex<T> >;
#endif
    friend std::ostream& operator<<<>(std::ostream& os, const ParallelLocalIndex<T>& index);
 
  public:
    typedef T Attribute;
    ParallelLocalIndex(const Attribute& attribute, bool isPublic);
 
    ParallelLocalIndex(size_t localIndex, const Attribute& attribute, bool isPublic=true);
    ParallelLocalIndex();
 
#if 0
    ParallelLocalIndex(const Attribute& attribute, size_t local, bool isPublic);
#endif
 
    inline const Attribute attribute() const;
 
    inline void setAttribute(const Attribute& attribute);
 
    inline size_t local() const;
 
    inline operator size_t() const;
 
    inline ParallelLocalIndex<Attribute>& operator=(size_t index);
 
    inline bool isPublic() const;
 
    inline LocalIndexState state() const;
 
    inline void setState(const LocalIndexState& state);
 
  private:
    size_t localIndex_;
 
    char attribute_;
 
    char public_;
 
    char state_;
 
  };
 
  template<typename T>
  bool operator==(const ParallelLocalIndex<T>& p1,
                  const ParallelLocalIndex<T>& p2)
  {
    if(p1.local()!=p2.local())
      return false;
    if(p1.attribute()!=p2.attribute())
      return false;
    if(p1.isPublic()!=p2.isPublic())
      return false;
    return true;
  }
  template<typename T>
  bool operator!=(const ParallelLocalIndex<T>& p1,
                  const ParallelLocalIndex<T>& p2)
  {
    return !(p1==p2);
  }
 
 
  template<typename T>
  struct LocalIndexComparator<ParallelLocalIndex<T> >
  {
    static bool compare(const ParallelLocalIndex<T>& t1,
                        const ParallelLocalIndex<T>& t2){
      return t1.attribute()<t2.attribute();
    }
  };
 
 
#if HAVE_MPI
 
  template<typename T>
  class MPITraits<ParallelLocalIndex<T> >
  {
  public:
    static MPI_Datatype getType();
  private:
    static MPI_Datatype type;
 
  };
 
#endif
 
  template<class T>
  ParallelLocalIndex<T>::ParallelLocalIndex(const T& attribute, bool isPublic)
    : localIndex_(0), attribute_(static_cast<char>(attribute)),
      public_(static_cast<char>(isPublic)), state_(static_cast<char>(VALID))
  {}
 
 
  template<class T>
  ParallelLocalIndex<T>::ParallelLocalIndex(size_t local, const T& attribute, bool isPublic)
    : localIndex_(local), attribute_(static_cast<char>(attribute)),
      public_(static_cast<char>(isPublic)), state_(static_cast<char>(VALID))
  {}
 
  template<class T>
  ParallelLocalIndex<T>::ParallelLocalIndex()
    : localIndex_(0), attribute_(), public_(static_cast<char>(false)),
      state_(static_cast<char>(VALID))
  {}
 
  template<class T>
  inline const T ParallelLocalIndex<T>::attribute() const
  {
    return T(attribute_);
  }
 
  template<class T>
  inline void
  ParallelLocalIndex<T>::setAttribute(const Attribute& attribute)
  {
    attribute_ = attribute;
  }
 
  template<class T>
  inline size_t ParallelLocalIndex<T>::local() const
  {
    return localIndex_;
  }
 
  template<class T>
  inline ParallelLocalIndex<T>::operator size_t() const
  {
    return localIndex_;
  }
 
  template<class T>
  inline ParallelLocalIndex<T>&
  ParallelLocalIndex<T>::operator=(size_t index)
  {
    localIndex_=index;
    return *this;
  }
 
  template<class T>
  inline bool ParallelLocalIndex<T>::isPublic() const
  {
    return static_cast<bool>(public_);
  }
 
  template<class T>
  inline LocalIndexState ParallelLocalIndex<T>::state() const
  {
    return LocalIndexState(state_);
  }
 
  template<class T>
  inline void ParallelLocalIndex<T>::setState(const LocalIndexState& state)
  {
    state_=static_cast<char>(state);
  }
 
#if HAVE_MPI
 
  template<typename T>
  MPI_Datatype MPITraits<ParallelLocalIndex<T> >::getType()
  {
 
    if(type==MPI_DATATYPE_NULL) {
      int length = 1;
      MPI_Aint base, disp;
      MPI_Datatype types[1] = {MPITraits<char>::getType()};
      ParallelLocalIndex<T> rep;
      MPI_Get_address(&rep, &base);
      MPI_Get_address(&(rep.attribute_), &disp);
      disp -= base;
 
      MPI_Datatype tmp;
      MPI_Type_create_struct(1, &length, &disp, types, &tmp);
 
      MPI_Type_create_resized(tmp, 0, sizeof(ParallelLocalIndex<T>), &type);
      MPI_Type_commit(&type);
 
      MPI_Type_free(&tmp);
    }
    return type;
  }
 
  template<typename T>
  MPI_Datatype MPITraits<ParallelLocalIndex<T> >::type = MPI_DATATYPE_NULL;
 
#endif // HAVE_MPI
 
 
} // namespace Dune
 
#endif // DUNE_COMMON_PARALLEL_PLOCALINDEX_HH