Field.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_Field_h
#define vtk_m_cont_Field_h
 
#include <vtkm/cont/vtkm_cont_export.h>
 
#include <vtkm/Range.h>
#include <vtkm/Types.h>
 
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/CastAndCall.h>
#include <vtkm/cont/UnknownArrayHandle.h>
 
namespace vtkm
{
namespace cont
{
 
 
class VTKM_CONT_EXPORT Field
{
public:
  enum struct Association
  {
    // Documentation is below (for better layout in generated documents).
    Any,
    WholeDataSet,
    Points,
    Cells,
    Partitions,
    Global,
  };
 
 
 
 
 
 
 
  VTKM_CONT
  Field() = default;
 
  VTKM_CONT
  Field(std::string name, Association association, const vtkm::cont::UnknownArrayHandle& data);
 
  template <typename T, typename Storage>
  VTKM_CONT Field(std::string name,
                  Association association,
                  const vtkm::cont::ArrayHandle<T, Storage>& data)
    : Field(name, association, vtkm::cont::UnknownArrayHandle{ data })
  {
  }
 
  Field(const vtkm::cont::Field& src);
  Field(vtkm::cont::Field&& src) noexcept;
 
  VTKM_CONT virtual ~Field();
 
  VTKM_CONT Field& operator=(const vtkm::cont::Field& src);
  VTKM_CONT Field& operator=(vtkm::cont::Field&& src) noexcept;
 
  VTKM_CONT bool IsCellField() const { return this->FieldAssociation == Association::Cells; }
  VTKM_CONT bool IsPointField() const { return this->FieldAssociation == Association::Points; }
  VTKM_CONT bool IsWholeDataSetField() const
  {
    return this->FieldAssociation == Association::WholeDataSet;
  }
  VTKM_CONT bool IsPartitionsField() const
  {
    return this->FieldAssociation == Association::Partitions;
  }
  VTKM_CONT bool IsGlobalField() const { return this->FieldAssociation == Association::Global; }
 
  VTKM_CONT bool IsSupportedType() const;
 
  VTKM_CONT vtkm::Id GetNumberOfValues() const { return this->Data.GetNumberOfValues(); }
 
  VTKM_CONT const std::string& GetName() const { return this->Name; }
  VTKM_CONT Association GetAssociation() const { return this->FieldAssociation; }
  const vtkm::cont::UnknownArrayHandle& GetData() const;
  vtkm::cont::UnknownArrayHandle& GetData();
 
  VTKM_CONT const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange() const;
 
  VTKM_CONT void GetRange(vtkm::Range* range) const;
 
  VTKM_CONT vtkm::cont::UnknownArrayHandle GetDataAsDefaultFloat() const;
 
  VTKM_CONT vtkm::cont::UnknownArrayHandle GetDataWithExpectedTypes() const;
 
  VTKM_CONT void ConvertToExpected();
 
  VTKM_CONT void SetData(const vtkm::cont::UnknownArrayHandle& newdata);
 
  template <typename T, typename StorageTag>
  VTKM_CONT void SetData(const vtkm::cont::ArrayHandle<T, StorageTag>& newdata)
  {
    this->SetData(vtkm::cont::UnknownArrayHandle(newdata));
  }
 
  VTKM_CONT
  virtual void PrintSummary(std::ostream& out, bool full = false) const;
 
  VTKM_CONT
  virtual void ReleaseResourcesExecution()
  {
    this->Data.ReleaseResourcesExecution();
    this->Range.ReleaseResourcesExecution();
  }
 
private:
  std::string Name; 
 
  Association FieldAssociation = Association::Any;
  vtkm::cont::UnknownArrayHandle Data;
  mutable vtkm::cont::ArrayHandle<vtkm::Range> Range;
  mutable bool ModifiedFlag = true;
};
 
template <typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::Field& field, Functor&& f, Args&&... args)
{
  vtkm::cont::CastAndCall(field.GetData(), std::forward<Functor>(f), std::forward<Args>(args)...);
}
 
 
template <typename T>
vtkm::cont::Field make_Field(std::string name,
                             Field::Association association,
                             const T* data,
                             vtkm::Id size,
                             vtkm::CopyFlag copy)
{
  return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandle(data, size, copy));
}
 
template <typename T>
vtkm::cont::Field make_Field(std::string name,
                             Field::Association association,
                             const std::vector<T>& data,
                             vtkm::CopyFlag copy)
{
  return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandle(data, copy));
}
 
template <typename T>
vtkm::cont::Field make_FieldMove(std::string name,
                                 Field::Association association,
                                 std::vector<T>&& data)
{
  return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandleMove(std::move(data)));
}
 
template <typename T>
vtkm::cont::Field make_Field(std::string name,
                             Field::Association association,
                             std::vector<T>&& data,
                             vtkm::CopyFlag vtkmNotUsed(copy))
{
  return make_FieldMove(name, association, std::move(data));
}
 
template <typename T>
vtkm::cont::Field make_Field(std::string name,
                             Field::Association association,
                             std::initializer_list<T>&& data)
{
  return make_FieldMove(name, association, vtkm::cont::make_ArrayHandle(std::move(data)));
}
 
 
template <typename T, typename S>
vtkm::cont::Field make_FieldPoint(std::string name, const vtkm::cont::ArrayHandle<T, S>& data)
{
  return vtkm::cont::Field(name, vtkm::cont::Field::Association::Points, data);
}
 
inline vtkm::cont::Field make_FieldPoint(std::string name,
                                         const vtkm::cont::UnknownArrayHandle& data)
{
  return vtkm::cont::Field(name, vtkm::cont::Field::Association::Points, data);
}
 
template <typename T, typename S>
vtkm::cont::Field make_FieldCell(std::string name, const vtkm::cont::ArrayHandle<T, S>& data)
{
  return vtkm::cont::Field(name, vtkm::cont::Field::Association::Cells, data);
}
 
 
inline vtkm::cont::Field make_FieldCell(std::string name,
                                        const vtkm::cont::UnknownArrayHandle& data)
{
  return vtkm::cont::Field(name, vtkm::cont::Field::Association::Cells, data);
}
 
} // namespace cont
} // namespace vtkm
 
 
namespace vtkm
{
namespace cont
{
namespace internal
{
template <>
struct DynamicTransformTraits<vtkm::cont::Field>
{
  using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
};
} // namespace internal
} // namespace cont
} // namespace vtkm
 
//=============================================================================
// Specializations of serialization related classes
 
namespace mangled_diy_namespace
{
 
template <>
struct VTKM_CONT_EXPORT Serialization<vtkm::cont::Field>
{
  static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::cont::Field& field);
  static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::Field& field);
};
 
} // diy
 
#endif //vtk_m_cont_Field_h