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