concepts/entity.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © 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_GRID_CONCEPT_ENTITY_HH
#define DUNE_GRID_CONCEPT_ENTITY_HH

#include <concepts>
#include <utility>

#include <dune/common/rangeutilities.hh>
#include <dune/geometry/type.hh>
#include <dune/grid/common/gridenums.hh>
#include <dune/grid/concepts/geometry.hh>
#include <dune/grid/concepts/archetypes/entity.hh>

namespace Dune::Concept {

template<class S>
concept EntitySeed = std::semiregular<S> && requires(const S seed)
{
  { S::codimension  } -> std::convertible_to<int>;
  { seed.isValid()  } -> std::convertible_to<bool>;
};

static_assert(EntitySeed< Archetypes::EntitySeed<0> >);


template<class E>
concept EntityGeneral = std::regular<E> &&
  Geometry<typename E::Geometry> &&
  EntitySeed<typename E::EntitySeed> &&
requires(const E e, unsigned int codim)
{
  requires E::mydimension == (E::dimension - E::codimension);
  { e.level()            } -> std::convertible_to<int>;
  { e.partitionType()    } -> std::same_as<Dune::PartitionType>;
  { e.geometry()         } -> std::same_as<typename E::Geometry>;
  { e.type()             } -> std::same_as<Dune::GeometryType>;
  { e.subEntities(codim) } -> std::convertible_to<unsigned int>;
  { e.seed()             } -> std::same_as<typename E::EntitySeed>;
};

static_assert(EntityGeneral< Archetypes::Entity<2,0> >);


namespace Impl {

  // only check if Codim<cd>::Entity exists
  template<class E, int codim>
  concept EntityCodimExtended =
  (
    !requires
    {
      typename E::template Codim<codim>::Entity;
    }
  ) || (
    EntityGeneral<typename E::template Codim<codim>::Entity> &&
    requires(const E e, int subEntity)
    {
      { e.template subEntity<codim>(subEntity) } -> std::same_as<typename E::template Codim<codim>::Entity>;
    }
  );

  template<typename E, std::size_t... c>
  void entityAllCodimsExtended(std::integer_sequence<std::size_t,c...>)
   requires (EntityCodimExtended<E,int(c)> &&...);

} // end namespace Impl

template<class E>
concept EntityExtended = EntityGeneral<E> &&
  Geometry<typename E::LocalGeometry> &&
requires(const E e, int maxLevel)
{
  requires (E::codimension == 0);
  { e.father()                   } -> std::same_as<E>;
  { e.hasFather()                } -> std::convertible_to<bool>;
  { e.isLeaf()                   } -> std::convertible_to<bool>;
  { e.isRegular()                } -> std::convertible_to<bool>;
  { e.geometryInFather()         } -> std::same_as<typename E::LocalGeometry>;
  { e.hbegin(maxLevel)           } -> std::same_as<typename E::HierarchicIterator>;
  { e.hend(maxLevel)             } -> std::same_as<typename E::HierarchicIterator>;
  { e.isNew()                    } -> std::convertible_to<bool>;
  { e.mightVanish()              } -> std::convertible_to<bool>;
  { e.hasBoundaryIntersections() } -> std::convertible_to<bool>;

  requires std::same_as<E, typename E::template Codim<0>::Entity>;
} &&
Impl::EntityCodimExtended<E,0> &&
requires (index_constant<1> from, index_constant<E::dimension+1> to) {
  Impl::entityAllCodimsExtended<E>(range(from, to).to_integer_sequence());
};

template<class E>
concept Entity = EntityGeneral<E> && ((E::codimension != 0) || EntityExtended<E>);

} // end namespace Dune::Concept


#endif // DUNE_GRID_CONCEPT_ENTITY_HH