UnknownCellSet.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_cont_UnknownCellSet_h
#define vtk_m_cont_UnknownCellSet_h
 
#include <vtkm/cont/CastAndCall.h>
#include <vtkm/cont/CellSet.h>
#include <vtkm/cont/DefaultTypes.h>
 
#include <vtkm/cont/vtkm_cont_export.h>
 
#include <memory>
 
namespace vtkm
{
namespace cont
{
 
// Forward declaration.
template <typename CellSetList>
class UncertainCellSet;
 
class VTKM_CONT_EXPORT UnknownCellSet
{
  std::shared_ptr<vtkm::cont::CellSet> Container;
 
  void InitializeKnownOrUnknownCellSet(const UnknownCellSet& cellSet,
                                       std::true_type vtkmNotUsed(isUnknownCellSet))
  {
    *this = cellSet;
  }
 
  template <typename CellSetType>
  void InitializeKnownOrUnknownCellSet(const CellSetType& cellSet,
                                       std::false_type vtkmNotUsed(isUnknownCellSet))
  {
    VTKM_IS_CELL_SET(CellSetType);
    this->Container = std::shared_ptr<vtkm::cont::CellSet>(new CellSetType(cellSet));
  }
 
public:
  VTKM_CONT UnknownCellSet() = default;
 
  template <typename CellSetType>
  VTKM_CONT UnknownCellSet(const CellSetType& cellSet)
  {
    this->InitializeKnownOrUnknownCellSet(
      cellSet, typename std::is_base_of<UnknownCellSet, CellSetType>::type{});
  }
 
  VTKM_CONT bool IsValid() const { return static_cast<bool>(this->Container); }
 
  VTKM_CONT vtkm::cont::CellSet* GetCellSetBase() { return this->Container.get(); }
  VTKM_CONT const vtkm::cont::CellSet* GetCellSetBase() const { return this->Container.get(); }
 
  VTKM_CONT UnknownCellSet NewInstance() const;
 
  VTKM_CONT std::string GetCellSetName() const;
 
  template <typename CellSetType>
  VTKM_CONT bool IsType() const
  {
    return (dynamic_cast<const CellSetType*>(this->Container.get()) != nullptr);
  }
 
  VTKM_CONT vtkm::Id GetNumberOfCells() const
  {
    return this->Container ? this->Container->GetNumberOfCells() : 0;
  }
  VTKM_CONT vtkm::Id GetNumberOfFaces() const
  {
    return this->Container ? this->Container->GetNumberOfFaces() : 0;
  }
  VTKM_CONT vtkm::Id GetNumberOfEdges() const
  {
    return this->Container ? this->Container->GetNumberOfEdges() : 0;
  }
  VTKM_CONT vtkm::Id GetNumberOfPoints() const
  {
    return this->Container ? this->Container->GetNumberOfPoints() : 0;
  }
 
  VTKM_CONT vtkm::UInt8 GetCellShape(vtkm::Id id) const
  {
    return this->GetCellSetBase()->GetCellShape(id);
  }
  VTKM_CONT vtkm::IdComponent GetNumberOfPointsInCell(vtkm::Id id) const
  {
    return this->GetCellSetBase()->GetNumberOfPointsInCell(id);
  }
  VTKM_CONT void GetCellPointIds(vtkm::Id id, vtkm::Id* ptids) const
  {
    return this->GetCellSetBase()->GetCellPointIds(id, ptids);
  }
 
  VTKM_CONT void DeepCopyFrom(const CellSet* src) { this->GetCellSetBase()->DeepCopy(src); }
 
  VTKM_CONT void PrintSummary(std::ostream& os) const;
 
  VTKM_CONT void ReleaseResourcesExecution()
  {
    if (this->Container)
    {
      this->Container->ReleaseResourcesExecution();
    }
  }
 
  template <typename CellSetType>
  VTKM_CONT bool CanConvert() const
  {
    // TODO: Currently, these are the same. But in the future we expect to support
    // special CellSet types that can convert back and forth such as multiplexed
    // cell sets or a cell set that can hold structured grids of any dimension.
    return this->IsType<CellSetType>();
  }
 
  template <typename CellSetType>
  VTKM_CONT void AsCellSet(CellSetType& cellSet) const
  {
    VTKM_IS_CELL_SET(CellSetType);
    CellSetType* cellSetPointer = dynamic_cast<CellSetType*>(this->Container.get());
    if (cellSetPointer == nullptr)
    {
      VTKM_LOG_CAST_FAIL(*this, CellSetType);
      throwFailedDynamicCast(this->GetCellSetName(), vtkm::cont::TypeToString(cellSet));
    }
    VTKM_LOG_CAST_SUCC(*this, *cellSetPointer);
    cellSet = *cellSetPointer;
  }
 
  template <typename CellSetType>
  VTKM_CONT CellSetType AsCellSet() const
  {
    CellSetType cellSet;
    this->AsCellSet(cellSet);
    return cellSet;
  }
 
  // Defined in UncertainCellSet.h
  template <typename CellSetList>
  VTKM_CONT vtkm::cont::UncertainCellSet<CellSetList> ResetCellSetList(CellSetList) const;
  template <typename CellSetList>
  VTKM_CONT vtkm::cont::UncertainCellSet<CellSetList> ResetCellSetList() const;
 
  template <typename CellSetList, typename Functor, typename... Args>
  VTKM_CONT void CastAndCallForTypes(Functor&& functor, Args&&... args) const;
};
 
//=============================================================================
// Free function casting helpers
// (Not sure if these should be deprecated.)
 
template <typename CellSetType>
VTKM_CONT inline bool IsType(const vtkm::cont::UnknownCellSet& unknownCellSet)
{
  return unknownCellSet.IsType<CellSetType>();
}
 
template <typename CellSetType>
VTKM_CONT inline CellSetType Cast(const vtkm::cont::UnknownCellSet& unknownCellSet)
{
  return unknownCellSet.AsCellSet<CellSetType>();
}
 
namespace internal
{
 
VTKM_CONT_EXPORT void ThrowCastAndCallException(const vtkm::cont::UnknownCellSet&,
                                                const std::type_info&);
 
template <>
struct DynamicTransformTraits<vtkm::cont::UnknownCellSet>
{
  using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
};
 
} // namespace internal
 
template <typename CellSetList, typename Functor, typename... Args>
VTKM_CONT void UnknownCellSet::CastAndCallForTypes(Functor&& functor, Args&&... args) const
{
  VTKM_IS_LIST(CellSetList);
  bool called = false;
  vtkm::ListForEach(
    [&](auto cellSet) {
      if (!called && this->CanConvert<decltype(cellSet)>())
      {
        called = true;
        this->AsCellSet(cellSet);
        VTKM_LOG_CAST_SUCC(*this, cellSet);
 
        // If you get a compile error here, it means that you have called CastAndCall for a
        // vtkm::cont::UnknownCellSet and the arguments of the functor do not match those
        // being passed. This is often because it is calling the functor with a CellSet
        // type that was not expected. Either add overloads to the functor to accept all
        // possible cell set types or constrain the types tried for the CastAndCall.
        functor(cellSet, args...);
      }
    },
    CellSetList{});
 
  if (!called)
  {
    VTKM_LOG_CAST_FAIL(*this, CellSetList);
    internal::ThrowCastAndCallException(*this, typeid(CellSetList));
  }
}
 
template <typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::UnknownCellSet& cellSet, Functor&& f, Args&&... args)
{
  cellSet.CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST>(std::forward<Functor>(f),
                                                          std::forward<Args>(args)...);
}
 
namespace internal
{
 
template <typename T>
using UnknownCellSetCheck = typename std::is_base_of<vtkm::cont::UnknownCellSet, T>::type;
 
#define VTKM_IS_UNKNOWN_CELL_SET(T) \
  VTKM_STATIC_ASSERT(::vtkm::cont::internal::UnknownCellSetCheck<T>::value)
 
#define VTKM_IS_KNOWN_OR_UNKNOWN_CELL_SET(T)                                 \
  VTKM_STATIC_ASSERT(::vtkm::cont::internal::CellSetCheck<T>::type::value || \
                     ::vtkm::cont::internal::UnknownCellSetCheck<T>::value)
 
} // namespace internal
 
} // namespace vtkm::cont
} // namespace vtkm
 
//=============================================================================
// Specializations of serialization related classes
 
namespace vtkm
{
namespace cont
{
 
template <>
struct VTKM_CONT_EXPORT SerializableTypeString<vtkm::cont::UnknownCellSet>
{
  static VTKM_CONT std::string Get();
};
}
} // namespace vtkm::cont
 
namespace mangled_diy_namespace
{
 
template <>
struct VTKM_CONT_EXPORT Serialization<vtkm::cont::UnknownCellSet>
{
public:
  static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::cont::UnknownCellSet& obj);
  static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::UnknownCellSet& obj);
};
 
} // namespace mangled_diy_namespace
 
 
// Include the implementation of UncertainCellSet. This should be included because there
// are methods in UnknownCellSet that produce objects of this type. It has to be included
// at the end to resolve the circular dependency.
#include <vtkm/cont/UncertainCellSet.h>
 
#endif //vtk_m_cont_UnknownCellSet_h