dependency.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_AMG_DEPENDENCY_HH
#define DUNE_AMG_DEPENDENCY_HH
 
 
#include <bitset>
#include <ostream>
 
#include "graph.hh"
#include "properties.hh"
#include <dune/common/propertymap.hh>
 
 
namespace Dune
{
  namespace Amg
  {
    class EdgeProperties
    {
      friend std::ostream& operator<<(std::ostream& os, const EdgeProperties& props);
    public:
      enum {INFLUENCE, DEPEND, SIZE};
 
    private:
 
      std::bitset<SIZE> flags_;
    public:
      EdgeProperties();
 
      std::bitset<SIZE>::reference operator[](std::size_t v);
 
      bool operator[](std::size_t v) const;
 
      bool depends() const;
 
      void setDepends();
 
      void resetDepends();
 
      bool influences() const;
 
      void setInfluences();
 
      void resetInfluences();
 
      bool isOneWay() const;
 
      bool isTwoWay() const;
 
      bool isStrong()  const;
 
      void reset();
 
      void printFlags() const;
    };
 
    class VertexProperties {
      friend std::ostream& operator<<(std::ostream& os, const VertexProperties& props);
    public:
      enum { ISOLATED, VISITED, FRONT, BORDER, SIZE };
    private:
 
      std::bitset<SIZE> flags_;
 
    public:
      VertexProperties();
 
      std::bitset<SIZE>::reference operator[](std::size_t v);
 
      bool operator[](std::size_t v) const;
 
      void setIsolated();
 
      bool isolated() const;
 
      void resetIsolated();
 
      void setVisited();
 
      bool visited() const;
 
      void resetVisited();
 
      void setFront();
 
      bool front() const;
 
      void resetFront();
 
      void setExcludedBorder();
 
      bool excludedBorder() const;
 
      void resetExcludedBorder();
 
      void reset();
 
    };
 
    template<typename G, std::size_t i>
    class PropertyGraphVertexPropertyMap
      : public RAPropertyMapHelper<typename std::bitset<VertexProperties::SIZE>::reference,
            PropertyGraphVertexPropertyMap<G,i> >
    {
    public:
 
      typedef ReadWritePropertyMapTag Category;
 
      enum {
        index = i
      };
 
      typedef G Graph;
 
      typedef std::bitset<VertexProperties::SIZE> BitSet;
 
      typedef typename BitSet::reference Reference;
 
      typedef bool ValueType;
 
      typedef typename G::VertexDescriptor Vertex;
 
      PropertyGraphVertexPropertyMap(G& g)
        : graph_(&g)
      {}
 
      PropertyGraphVertexPropertyMap()
        : graph_(0)
      {}
 
 
      Reference operator[](const Vertex& vertex) const
      {
        return graph_->getVertexProperties(vertex)[index];
      }
    private:
      Graph* graph_;
    };
 
  } // end namespace Amg
 
  template<typename G, typename EP, typename VM, typename EM>
  struct PropertyMapTypeSelector<Amg::VertexVisitedTag,Amg::PropertiesGraph<G,Amg::VertexProperties,EP,VM,EM> >
  {
    typedef Amg::PropertyGraphVertexPropertyMap<Amg::PropertiesGraph<G,Amg::VertexProperties,EP,VM,EM>, Amg::VertexProperties::VISITED> Type;
  };
 
  template<typename G, typename EP, typename VM, typename EM>
  typename PropertyMapTypeSelector<Amg::VertexVisitedTag,Amg::PropertiesGraph<G,Amg::VertexProperties,EP,VM,EM> >::Type
  get([[maybe_unused]] const Amg::VertexVisitedTag& tag, Amg::PropertiesGraph<G,Amg::VertexProperties,EP,VM,EM>& graph)
  {
    return Amg::PropertyGraphVertexPropertyMap<Amg::PropertiesGraph<G,Amg::VertexProperties,EP,VM,EM>, Amg::VertexProperties::VISITED>(graph);
  }
 
  namespace Amg
  {
    inline std::ostream& operator<<(std::ostream& os, const EdgeProperties& props)
    {
      return os << props.flags_;
    }
 
    inline EdgeProperties::EdgeProperties()
      : flags_()
    {}
 
    inline std::bitset<EdgeProperties::SIZE>::reference
    EdgeProperties::operator[](std::size_t v)
    {
      return flags_[v];
    }
 
    inline bool EdgeProperties::operator[](std::size_t i) const
    {
      return flags_[i];
    }
 
    inline void EdgeProperties::reset()
    {
      flags_.reset();
    }
 
    inline void EdgeProperties::setInfluences()
    {
      // Set the INFLUENCE bit
      //flags_ |= (1<<INFLUENCE);
      flags_.set(INFLUENCE);
    }
 
    inline bool EdgeProperties::influences() const
    {
      // Test the INFLUENCE bit
      return flags_.test(INFLUENCE);
    }
 
    inline void EdgeProperties::setDepends()
    {
      // Set the first bit.
      //flags_ |= (1<<DEPEND);
      flags_.set(DEPEND);
    }
 
    inline void EdgeProperties::resetDepends()
    {
      // reset the first bit.
      //flags_ &= ~(1<<DEPEND);
      flags_.reset(DEPEND);
    }
 
    inline bool EdgeProperties::depends() const
    {
      // Return the first bit.
      return flags_.test(DEPEND);
    }
 
    inline void EdgeProperties::resetInfluences()
    {
      // reset the second bit.
      flags_ &= ~(1<<INFLUENCE);
    }
 
    inline bool EdgeProperties::isOneWay() const
    {
      // Test whether only the first bit is set
      //return isStrong() && !isTwoWay();
      return ((flags_) & std::bitset<SIZE>((1<<INFLUENCE)|(1<<DEPEND)))==(1<<DEPEND);
    }
 
    inline bool EdgeProperties::isTwoWay() const
    {
      // Test whether the first and second bit is set
      return ((flags_) & std::bitset<SIZE>((1<<INFLUENCE)|(1<<DEPEND)))==((1<<INFLUENCE)|(1<<DEPEND));
    }
 
    inline bool EdgeProperties::isStrong() const
    {
      // Test whether the first or second bit is set
      return ((flags_) & std::bitset<SIZE>((1<<INFLUENCE)|(1<<DEPEND))).to_ulong();
    }
 
 
    inline std::ostream& operator<<(std::ostream& os, const VertexProperties& props)
    {
      return os << props.flags_;
    }
 
    inline VertexProperties::VertexProperties()
      : flags_()
    {}
 
 
    inline std::bitset<VertexProperties::SIZE>::reference
    VertexProperties::operator[](std::size_t v)
    {
      return flags_[v];
    }
 
    inline bool VertexProperties::operator[](std::size_t v) const
    {
      return flags_[v];
    }
 
    inline void VertexProperties::setIsolated()
    {
      flags_.set(ISOLATED);
    }
 
    inline bool VertexProperties::isolated() const
    {
      return flags_.test(ISOLATED);
    }
 
    inline void VertexProperties::resetIsolated()
    {
      flags_.reset(ISOLATED);
    }
 
    inline void VertexProperties::setVisited()
    {
      flags_.set(VISITED);
    }
 
    inline bool VertexProperties::visited() const
    {
      return flags_.test(VISITED);
    }
 
    inline void VertexProperties::resetVisited()
    {
      flags_.reset(VISITED);
    }
 
    inline void VertexProperties::setFront()
    {
      flags_.set(FRONT);
    }
 
    inline bool VertexProperties::front() const
    {
      return flags_.test(FRONT);
    }
 
    inline void VertexProperties::resetFront()
    {
      flags_.reset(FRONT);
    }
 
    inline void VertexProperties::setExcludedBorder()
    {
      flags_.set(BORDER);
    }
 
    inline bool VertexProperties::excludedBorder() const
    {
      return flags_.test(BORDER);
    }
 
    inline void VertexProperties::resetExcludedBorder()
    {
      flags_.reset(BORDER);
    }
 
    inline void VertexProperties::reset()
    {
      flags_.reset();
    }
 
  }
}
#endif