UnknownCellSet.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  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 viskores_cont_UnknownCellSet_h
#define viskores_cont_UnknownCellSet_h
 
#include <viskores/cont/CastAndCall.h>
#include <viskores/cont/CellSet.h>
#include <viskores/cont/DefaultTypes.h>
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <memory>
 
namespace viskores
{
namespace cont
{
 
// Forward declaration.
template <typename CellSetList>
class UncertainCellSet;
 
class VISKORES_CONT_EXPORT UnknownCellSet
{
  std::shared_ptr<viskores::cont::CellSet> Container;
 
  void InitializeKnownOrUnknownCellSet(const UnknownCellSet& cellSet,
                                       std::true_type viskoresNotUsed(isUnknownCellSet))
  {
    *this = cellSet;
  }
 
  template <typename CellSetType>
  void InitializeKnownOrUnknownCellSet(const CellSetType& cellSet,
                                       std::false_type viskoresNotUsed(isUnknownCellSet))
  {
    VISKORES_IS_CELL_SET(CellSetType);
    this->Container = std::shared_ptr<viskores::cont::CellSet>(new CellSetType(cellSet));
  }
 
public:
  VISKORES_CONT UnknownCellSet() = default;
 
  template <typename CellSetType>
  VISKORES_CONT UnknownCellSet(const CellSetType& cellSet)
  {
    this->InitializeKnownOrUnknownCellSet(
      cellSet, typename std::is_base_of<UnknownCellSet, CellSetType>::type{});
  }
 
  VISKORES_CONT bool IsValid() const { return static_cast<bool>(this->Container); }
 
  VISKORES_CONT viskores::cont::CellSet* GetCellSetBase() { return this->Container.get(); }
  VISKORES_CONT const viskores::cont::CellSet* GetCellSetBase() const
  {
    return this->Container.get();
  }
 
  VISKORES_CONT UnknownCellSet NewInstance() const;
 
  VISKORES_CONT std::string GetCellSetName() const;
 
  template <typename CellSetType>
  VISKORES_CONT bool IsType() const
  {
    return (dynamic_cast<const CellSetType*>(this->Container.get()) != nullptr);
  }
 
  VISKORES_CONT viskores::Id GetNumberOfCells() const
  {
    return this->Container ? this->Container->GetNumberOfCells() : 0;
  }
  VISKORES_CONT viskores::Id GetNumberOfFaces() const
  {
    return this->Container ? this->Container->GetNumberOfFaces() : 0;
  }
  VISKORES_CONT viskores::Id GetNumberOfEdges() const
  {
    return this->Container ? this->Container->GetNumberOfEdges() : 0;
  }
  VISKORES_CONT viskores::Id GetNumberOfPoints() const
  {
    return this->Container ? this->Container->GetNumberOfPoints() : 0;
  }
 
  VISKORES_CONT viskores::UInt8 GetCellShape(viskores::Id id) const
  {
    return this->GetCellSetBase()->GetCellShape(id);
  }
  VISKORES_CONT viskores::IdComponent GetNumberOfPointsInCell(viskores::Id id) const
  {
    return this->GetCellSetBase()->GetNumberOfPointsInCell(id);
  }
  VISKORES_CONT void GetCellPointIds(viskores::Id id, viskores::Id* ptids) const
  {
    return this->GetCellSetBase()->GetCellPointIds(id, ptids);
  }
 
  VISKORES_CONT void DeepCopyFrom(const CellSet* src) { this->GetCellSetBase()->DeepCopy(src); }
 
  VISKORES_CONT void PrintSummary(std::ostream& os) const;
 
  VISKORES_CONT void ReleaseResourcesExecution()
  {
    if (this->Container)
    {
      this->Container->ReleaseResourcesExecution();
    }
  }
 
  template <typename CellSetType>
  VISKORES_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>
  VISKORES_CONT void AsCellSet(CellSetType& cellSet) const
  {
    VISKORES_IS_CELL_SET(CellSetType);
    CellSetType* cellSetPointer = dynamic_cast<CellSetType*>(this->Container.get());
    if (cellSetPointer == nullptr)
    {
      VISKORES_LOG_CAST_FAIL(*this, CellSetType);
      throwFailedDynamicCast(this->GetCellSetName(), viskores::cont::TypeToString(cellSet));
    }
    VISKORES_LOG_CAST_SUCC(*this, *cellSetPointer);
    cellSet = *cellSetPointer;
  }
 
  template <typename CellSetType>
  VISKORES_CONT CellSetType AsCellSet() const
  {
    CellSetType cellSet;
    this->AsCellSet(cellSet);
    return cellSet;
  }
 
  // Defined in UncertainCellSet.h
  template <typename CellSetList>
  VISKORES_CONT viskores::cont::UncertainCellSet<CellSetList> ResetCellSetList(CellSetList) const;
  template <typename CellSetList>
  VISKORES_CONT viskores::cont::UncertainCellSet<CellSetList> ResetCellSetList() const;
 
  template <typename CellSetList, typename Functor, typename... Args>
  VISKORES_CONT void CastAndCallForTypes(Functor&& functor, Args&&... args) const;
};
 
//=============================================================================
// Free function casting helpers
// (Not sure if these should be deprecated.)
 
template <typename CellSetType>
VISKORES_CONT inline bool IsType(const viskores::cont::UnknownCellSet& unknownCellSet)
{
  return unknownCellSet.IsType<CellSetType>();
}
 
template <typename CellSetType>
VISKORES_CONT inline CellSetType Cast(const viskores::cont::UnknownCellSet& unknownCellSet)
{
  return unknownCellSet.AsCellSet<CellSetType>();
}
 
namespace internal
{
 
VISKORES_CONT_EXPORT void ThrowCastAndCallException(const viskores::cont::UnknownCellSet&,
                                                    const std::type_info&);
 
template <>
struct DynamicTransformTraits<viskores::cont::UnknownCellSet>
{
  using DynamicTag = viskores::cont::internal::DynamicTransformTagCastAndCall;
};
 
} // namespace internal
 
template <typename CellSetList, typename Functor, typename... Args>
VISKORES_CONT void UnknownCellSet::CastAndCallForTypes(Functor&& functor, Args&&... args) const
{
  VISKORES_IS_LIST(CellSetList);
  bool called = false;
  viskores::ListForEach(
    [&](auto cellSet)
    {
      if (!called && this->CanConvert<decltype(cellSet)>())
      {
        called = true;
        this->AsCellSet(cellSet);
        VISKORES_LOG_CAST_SUCC(*this, cellSet);
 
        // If you get a compile error here, it means that you have called CastAndCall for a
        // viskores::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)
  {
    VISKORES_LOG_CAST_FAIL(*this, CellSetList);
    internal::ThrowCastAndCallException(*this, typeid(CellSetList));
  }
}
 
template <typename Functor, typename... Args>
void CastAndCall(const viskores::cont::UnknownCellSet& cellSet, Functor&& f, Args&&... args)
{
  cellSet.CastAndCallForTypes<VISKORES_DEFAULT_CELL_SET_LIST>(std::forward<Functor>(f),
                                                              std::forward<Args>(args)...);
}
 
namespace internal
{
 
template <typename T>
using UnknownCellSetCheck = typename std::is_base_of<viskores::cont::UnknownCellSet, T>::type;
 
#define VISKORES_IS_UNKNOWN_CELL_SET(T) \
  VISKORES_STATIC_ASSERT(::viskores::cont::internal::UnknownCellSetCheck<T>::value)
 
#define VISKORES_IS_KNOWN_OR_UNKNOWN_CELL_SET(T)                                     \
  VISKORES_STATIC_ASSERT(::viskores::cont::internal::CellSetCheck<T>::type::value || \
                         ::viskores::cont::internal::UnknownCellSetCheck<T>::value)
 
} // namespace internal
 
} // namespace viskores::cont
} // namespace viskores
 
//=============================================================================
// Specializations of serialization related classes
 
namespace viskores
{
namespace cont
{
 
template <>
struct VISKORES_CONT_EXPORT SerializableTypeString<viskores::cont::UnknownCellSet>
{
  static VISKORES_CONT std::string Get();
};
}
} // namespace viskores::cont
 
namespace mangled_diy_namespace
{
 
template <>
struct VISKORES_CONT_EXPORT Serialization<viskores::cont::UnknownCellSet>
{
public:
  static VISKORES_CONT void save(BinaryBuffer& bb, const viskores::cont::UnknownCellSet& obj);
  static VISKORES_CONT void load(BinaryBuffer& bb, viskores::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 <viskores/cont/UncertainCellSet.h>
 
#endif //viskores_cont_UnknownCellSet_h