adjactor.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/util/assertion.hpp>
 
namespace FEAT
{
  namespace Adjacency
  {
    class Adjactor
    {
    public:
    // Note: The following class is just an abstract description of an adjactor for the documentation -- it is not
    // an actual class that should be compiled, therefore the class is inside a block reserved only for doxygen.
#ifdef DOXYGEN
      class ImageIterator
      {
      public:
        ImageIterator();
 
        ImageIterator(const ImageIterator& other);
 
        ImageIterator& operator=(const ImageIterator& other);
 
        Index operator*() const;
 
        ImageIterator& operator++();
 
        bool operator!=(const ImageIterator& other) const;
      }; // class ImageIterator
 
      Index get_num_nodes_domain() const;
 
      Index get_num_nodes_image() const;
 
      ImageIterator image_begin(Index domain_node) const;
 
      ImageIterator image_end(Index domain_node) const;
#endif // DOXYGEN
 
      class NullImageIterator
      {
      public:
        NullImageIterator& operator++()
        {
          XABORTM("cannot increment NullImageIterator");
          return *this;
        }
 
        Index operator*() const
        {
          XABORTM("cannot dereference NullImageIterator");
          return Index(0);
        }
 
        bool operator!=(const NullImageIterator& DOXY(other)) const
        {
          // NullImageIterators are always equal
          return false;
        }
      }; // class Adjactor::NullImageIterator
 
      class IndexImageIterator
      {
      protected:
        Index _index;
 
      public:
        IndexImageIterator() :
          _index(0)
        {
        }
 
        explicit IndexImageIterator(Index index) :
          _index(index)
        {
        }
 
        IndexImageIterator(const IndexImageIterator& other) :
          _index(other._index)
        {
        }
 
        IndexImageIterator& operator=(const IndexImageIterator& other)
        {
          _index = other._index;
          return *this;
        }
 
        IndexImageIterator& operator++()
        {
          ++_index;
          return *this;
        }
 
        Index operator*() const
        {
          return _index;
        }
 
        bool operator!=(const IndexImageIterator& other) const
        {
          return _index != other._index;
        }
      }; // class Adjactor::IndexImageIterator
    }; // class Adjactor
 
    template<
      typename Adj1_,
      typename Adj2_>
    class CompositeAdjactor
    {
    private:
      const Adj1_& _adj1;
      const Adj2_& _adj2;
 
    public:
      typedef Adj1_ Adjactor1;
      typedef Adj2_ Adjactor2;
 
      class ImageIterator
      {
        // The CompositeAdjactor class needs to be a friend as it calls the protected constructors.
        friend class CompositeAdjactor<Adj1_, Adj2_>;
 
      private:
 
        typedef typename Adj1_::ImageIterator Iterator1;
        typedef typename Adj2_::ImageIterator Iterator2;
 
        const Adj2_* _adj2;
 
        mutable Iterator1 _cur1;
        mutable Iterator1 _end1;
        mutable Iterator2 _cur2;
        mutable Iterator2 _end2;
 
      protected:
        // constructor for image_begin()
        ImageIterator(
          const Adj1_* adj1,
          const Adj2_* adj2,
          Index domain_node)
           :
          _adj2(adj2),
          _cur1(adj1->image_begin(domain_node)),
          _end1(adj1->image_end(domain_node)),
          _cur2(),
          _end2()
        {
          if(_cur1 != _end1)
          {
            _cur2 = adj2->image_begin(*_cur1);
            _end2 = adj2->image_end(*_cur1);
          }
        }
 
        // constructor for image_end()
        ImageIterator(
          const Adj1_* adj1,
          Index domain_node)
           :
          _adj2(nullptr),
          _cur1(adj1->image_end(domain_node)),
          _end1(_cur1),
          _cur2(),
          _end2()
        {
        }
 
      public:
        inline ImageIterator() :
          _adj2(nullptr),
          _cur1(),
          _end1(),
          _cur2(),
          _end2()
        {
        }
 
        inline ImageIterator(const ImageIterator& other) :
          _adj2(other._adj2),
          _cur1(other._cur1),
          _cur2(other._cur2),
          _end1(other._end1),
          _end2(other._end2)
        {
        }
 
        inline Index operator*() const
        {
          return *_cur2;
        }
 
        inline bool operator!=(const ImageIterator& other) const
        {
          return (_cur1 != other._cur1) || (_cur2 != other._cur2);
        }
 
        ImageIterator& operator++()
        {
          // increment the second iterator; if it did not reach the end then we have a valid position
          if(++_cur2 != _end2)
          {
            return *this;
          }
 
          // second iterator reached its end, so keep incrementing the first iterator until we find the next
          // non-empty second adjacency list or until we reach its end
          while(++_cur1 != _end1)
          {
            // reset second iterator
            _cur2 = _adj2->image_begin(*_cur1);
            _end2 = _adj2->image_end(*_cur1);
 
            // check whether the second adjacency list is empty, if not then we have a valid position
            if(_cur2 != _end2)
            {
              return *this;
            }
          }
 
          // If we come out here, then there are no more adjacencies left, so we need to set
          // this iterator to the 'end' position - this setting must be compatible to the iterator
          // returned by the image_end() function of the CompositeAdjactor class!
          // Note: see the second protected constructor of this class for the following definition.
          _cur2 = Iterator2();
          _end2 = _cur2;
 
          return *this;
        }
      }; // class CompositeAdjactor::ImageIterator
 
      inline CompositeAdjactor(
        const Adj1_& adjactor1,
        const Adj2_& adjactor2)
         :
        _adj1(adjactor1),
        _adj2(adjactor2)
      {
        // Ensure that the number of image nodes in the first adjactor is not greater than the number of domain
        // nodes in the second adjactor; otherwise the composite adjactor is ill-formed.
        XASSERTM(_adj1.get_num_nodes_image() <= _adj2.get_num_nodes_domain(), "Composite Adjactor is ill-formed");
      }
 
      inline Index get_num_nodes_domain() const
      {
        // The number of domain nodes of the composite adjactor is given by the number of domain nodes of the
        // first adjactor in the composition.
        return _adj1.get_num_nodes_domain();
      }
 
      inline Index get_num_nodes_image() const
      {
        // The number of image nodes of the composite adjactor is given by the number of image nodes of the
        // second adjactor in the composition.
        return _adj2.get_num_nodes_image();
      }
 
      inline ImageIterator image_begin(Index domain_node) const
      {
        ASSERTM(domain_node < get_num_nodes_domain(), "domain_node out of valid range");
        return ImageIterator(&_adj1, &_adj2, domain_node);
      }
 
      inline ImageIterator image_end(Index domain_node) const
      {
        ASSERTM(domain_node < get_num_nodes_domain(), "domain_node out of valid range");
        return ImageIterator(&_adj1, domain_node);
      }
 
      inline const Adjactor1& get_adjactor1() const
      {
        return _adj1;
      }
 
      inline const Adjactor2& get_adjactor2() const
      {
        return _adj2;
      }
    }; // class CompositeAdjactor
  } // namespace Adjacency
} // namespace FEAT