A high-level class to manipulate particle shapes. More...

#include <shape.hpp>

Inheritance diagram for icedb::Shapes::Shape:

[legend]

Collaboration diagram for icedb::Shapes::Shape:

[legend]

Public Types
typedef std::unique_ptr< Shape >	Shape_Type
	The preferred C++ type for referencing a shape. More...

Public Types inherited from icedb::Groups::Group
typedef std::unique_ptr< Groups::Group >	Group_ptr

typedef std::shared_ptr< H5::Group >	Group_HDF_shared_ptr

Public Member Functions
virtual	~Shape ()

bool	isShape () const
	Is this object actually a shape? More...

bool	isValid (std::ostream *out=nullptr) const
	Is this object a valid shape, according to the spec? More...

Public Member Functions inherited from icedb::Groups::Group
virtual	~Group ()

virtual Group_ptr	createGroup (const std::string &groupName)=0
	Create a group. More...

virtual Group_ptr	openGroup (const std::string &groupName) const =0
	Opens a group. More...

virtual bool	doesGroupExist (const std::string &groupName) const =0
	Does a group with this name exist? More...

virtual std::set< std::string >	getGroupNames () const =0
	Get the names of all sub-groups within the current group. More...

virtual void	deleteGroup (const std::string &groupName)=0
	Unlink the specified child group. More...

virtual Group_HDF_shared_ptr	getHDF5Group () const =0
	Get the fundamental HDF5 object that the group is built on. More...

Public Member Functions inherited from icedb::Attributes::CanHaveAttributes
	~CanHaveAttributes ()

bool	doesAttributeExist (const std::string &attributeName) const
	Does the object have an attribute with the given name? More...

std::type_index	getAttributeTypeId (const std::string &attributeName) const
	Returns the type of an attribute. More...

template<class Type >
bool	isAttributeOfType (const std::string &attributeName) const
	Is the type of the attribute "Type"? More...

std::set< std::string >	getAttributeNames () const
	List all attributes attached to this object. More...

void	deleteAttribute (const std::string &attributeName)
	Delete an attribute, by name, that is attached to this object. More...

template<class DataType >
void	readAttributeData (const std::string &attributeName, std::vector< size_t > &dimensions, std::vector< DataType > &data) const
	Function to read the data from an attribute using the provided input vectors. More...

template<class DataType >
void	writeAttributeData (const std::string &attributeName, const std::vector< size_t > &dimensionas, const std::vector< DataType > &data)
	Function to write an attribute to an object, with the provided raw data. More...

template<class DataType >
Attribute< DataType >	readAttribute (const std::string &attributeName) const
	Convenience function to read an attribute's data and return an Attribute object. More...

template<class DataType >
void	writeAttribute (const Attribute< DataType > &attribute)
	Convenience function to write an Attribute to an object. More...

template<class DataType >
void	writeAttribute (const std::string &name, std::initializer_list< size_t > dims, std::initializer_list< DataType > data)
	Convenience function to write a small Attribute to an object, using initializer lists. More...

Public Member Functions inherited from icedb::Tables::CanHaveTables
	~CanHaveTables ()

std::set< std::string >	getTableNames () const
	Lists all table names that are children of this object. More...

bool	doesTableExist (const std::string &tableName) const
	Does a table exist with the given name. More...

void	unlinkTable (const std::string &tableName)
	Unlink a table. In HDF5, this is not the same as erasing a table, which never actually happens. More...

Table::Table_Type	openTable (const std::string &tableName)

std::vector< size_t >	getChunkStrategy (const std::vector< size_t > &dims)
	The default chunking strategy for this table. Used for storage i/o speed, and for compression. More...

template<class DataType >
Table::Table_Type	createTable (const std::string &tableName, const std::vector< size_t > &dims, const std::vector< size_t > *chunks=nullptr)
	Create a table. More...

template<class DataType >
Table::Table_Type	createTable (const std::string &tableName, std::initializer_list< size_t > dims, const std::vector< size_t > *chunks=nullptr)
	Create a table. More...

template<class DataType >
Table::Table_Type	createTable (const std::string &tableName, std::initializer_list< size_t > dims, std::initializer_list< DataType > data, const std::vector< size_t > *chunks=nullptr)
	Create a table and writes initial data. Used with small tables. More...

template<class DataType >
Table::Table_Type	createTable (const std::string &tableName, std::initializer_list< size_t > dims, const std::vector< DataType > &data, const std::vector< size_t > *chunks=nullptr)
	Create a table and sets the table's initial data. More...

template<class DataType >
Table::Table_Type	createTable (const std::string &tableName, std::initializer_list< size_t > dims, const gsl::span< DataType > &data, const std::vector< size_t > *chunks=nullptr)
	Create a table and sets the table's initial data. More...

template<class DataType >
Table::Table_Type	createTable (const std::string &tableName, std::initializer_list< size_t > dims, const gsl::span< const DataType > &data, const std::vector< size_t > *chunks=nullptr)
	Create a table and sets the table's initial data. More...

Static Public Member Functions
static bool	isShape (Groups::Group &owner, const std::string &name)
	Is this object a shape? More...

static bool	isShape (gsl::not_null< H5::Group *> group)
	Is this object a group? More...

static bool	isValid (gsl::not_null< H5::Group > group, std::ostream out=nullptr)
	Is "group" a valid shape, according to the spec.? More...

static Shape_Type	openShape (Groups::Group &grpshp)

static Shape_Type	openShape (Groups::Group &owner, const std::string &name)
	Open a group's subgroup as a shape. More...

static Shape_Type	openShape (Groups::Group::Group_HDF_shared_ptr shape)
	Re-open an open HDF5 group as a shape. More...

static Shape_Type	createShape (Groups::Group &grpshp, const std::string &uid, gsl::not_null< const NewShapeRequiredProperties > required, const NewShapeCommonOptionalProperties optional=nullptr)
	Create a new shape. More...

static Shape_Type	createShape (Groups::Group &owner, const std::string &name, const std::string &uid, gsl::not_null< const NewShapeRequiredProperties > required, const NewShapeCommonOptionalProperties optional=nullptr)
	Create a new shape. More...

static Shape_Type	createShape (Groups::Group::Group_HDF_shared_ptr newShapeLocation, const std::string &uid, gsl::not_null< const NewShapeRequiredProperties > required, const NewShapeCommonOptionalProperties optional=nullptr)
	Create a new shape. More...

Static Public Member Functions inherited from icedb::Groups::Group
static Group_ptr	createGroup (const std::string &name, gsl::not_null< H5::Group *> parent)
	Create a group with a specified parent (static function) More...

static Group_ptr	createGroup (const std::string &name, gsl::not_null< H5::H5File *> parent)
	Create a group with a specified parent (static function) More...

static Group_ptr	createGroup (const std::string &name, gsl::not_null< const Group *> parent)
	Create a group with a specified parent (static function) More...

static Group_ptr	openGroup (const std::string &name, gsl::not_null< H5::Group *> parent)
	Open a group under the specified parent (static function) More...

static Group_ptr	openGroup (const std::string &name, gsl::not_null< H5::H5File *> parent)
	Open a group under the specified parent (static function) More...

static Group_ptr	openGroup (const std::string &name, gsl::not_null< const Group *> parent)
	Open a group under the specified parent (static function) More...

static Group_ptr	openGroup (Group_HDF_shared_ptr group)
	Open an icedb group from an HDF5 group object. More...

static Group_ptr	mount (const std::string &subdirname, gsl::not_null< const Group > containingParent, gsl::not_null< H5::H5File > pointsTo)
	Mount an HDF5 file as a child 'group'. More...

Static Public Member Functions inherited from icedb::Attributes::CanHaveAttributes
static bool	doesAttributeExist (gsl::not_null< const H5::H5Object *> parent, const std::string &attributeName)
	Does an object (parent) have an attribute with the given name? More...

static std::type_index	getAttributeTypeId (gsl::not_null< const H5::H5Object *> parent, const std::string &attributeName)
	Returns the type of an attribute. More...

template<class DataType >
static void	readAttributeData (gsl::not_null< const H5::H5Object *> parent, const std::string &attributeName, std::vector< size_t > &dimensions, std::vector< DataType > &data)
	Function to read the data from an attribute. More...

template<class DataType >
static Attribute< DataType >	readAttribute (gsl::not_null< const H5::H5Object *> obj, const std::string &attributeName)
	Convenience function to read an attribute's data and return an Attribute object. More...

Public Attributes
const std::string	particle_unique_id
	This is the unique identifier for this shape. More...

Public Attributes inherited from icedb::Groups::Group
const std::string	name
	The name of the group. More...

Static Public Attributes
static const std::string	_icedb_obj_type_shape_identifier = "shape"
	Each shape 'group' has an attribute with this identifier. Used for shape collection and searching. More...

Static Public Attributes inherited from icedb::Groups::Group
static const std::string	_icedb_obj_type_identifier = { "_icedb_obj_type" }
	The tag used in icedb to identify a group. More...

Protected Member Functions
	Shape (const std::string &uid)

Protected Member Functions inherited from icedb::Groups::Group
	Group ()

	Group (const std::string &name)

Protected Member Functions inherited from icedb::Attributes::CanHaveAttributes
	CanHaveAttributes ()

virtual void	_setAttributeParent (std::shared_ptr< H5::H5Object > obj)=0

virtual std::shared_ptr< H5::H5Object >	_getAttributeParent () const =0

Protected Member Functions inherited from icedb::Tables::CanHaveTables
	CanHaveTables ()
	Trivial constructor used when CanHaveTables is a virtual base class. More...

virtual void	_setTablesParent (std::shared_ptr< H5::Group > obj)=0
	CanHaveTables needs post-constructor setup. This sets the base HDF5 object that gets manipulated. More...

virtual std::shared_ptr< H5::Group >	_getTablesParent () const =0
	Gets the base HDF5 object that is manipulated. More...

Detailed Description

A high-level class to manipulate particle shapes.

Shapes are implemented as a set of tables and attributes, contained within a discrete Group. This class provides a higl-level interface to accessing and manipulating shapes. It acts as an "overlay" to an alreagy-existing group. It adds additional functions and "value".

Definition at line 112 of file shape.hpp.

Member Typedef Documentation

◆ Shape_Type

typedef std::unique_ptr<Shape> icedb::Shapes::Shape::Shape_Type

The preferred C++ type for referencing a shape.

Definition at line 145 of file shape.hpp.

Constructor & Destructor Documentation

◆ Shape()

icedb::Shapes::Shape::Shape ( const std::string & uid )

protected

Definition at line 160 of file Shapes.cpp.

References _icedb_obj_type_shape_identifier.

160 : particle_unique_id{ uid } {}

icedb::Shapes::Shape::particle_unique_id

const std::string particle_unique_id

This is the unique identifier for this shape.

Definition: shape.hpp:194

◆ ~Shape()

icedb::Shapes::Shape::~Shape ( )

virtual

Definition at line 159 of file Shapes.cpp.

159 {}

Member Function Documentation

◆ createShape() [1/3]

Shape::Shape_Type icedb::Shapes::Shape::createShape	(	Groups::Group &	grpshp,
		const std::string &	uid,
		gsl::not_null< const NewShapeRequiredProperties *>	required,
		const NewShapeCommonOptionalProperties *	optional = `nullptr`
	)

static

Create a new shape.

Parameters

uid	is a unique name for the shape
grpshp	is the opened group that is converted into a shape

Exceptions

if	the group has any already-existing tables or attributes that conflict with the new shape object

Parameters

required	is a pointer to the NewShapeRequiredProperties structure, that provides the "required" shape data.
optional	is a pointer to the Common Optional Properties structure, that provides optional, supplementary data.

Returns: the new shape on success

Exceptions

on failure

Definition at line 231 of file Shapes.cpp.

References icedb::Groups::Group::getHDF5Group().

Referenced by createShape(), main(), and icedb::Examples::Shapes::ShapeDataBasic::toShape().

         {
             return createShape(grpshp.getHDF5Group(), uid, required, optional);
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ createShape() [2/3]

Shape::Shape_Type icedb::Shapes::Shape::createShape	(	Groups::Group &	owner,
		const std::string &	name,
		const std::string &	uid,
		gsl::not_null< const NewShapeRequiredProperties *>	required,
		const NewShapeCommonOptionalProperties *	optional = `nullptr`
	)

static

Create a new shape.

Parameters

owner	is the "parent" of the shape - a shape is constructed as a child of the owner
name	is the name of the new group that gets created
uid	is a unique name for the shape

Exceptions

if	the group has any already-existing tables or attributes that conflict with the new shape object

Parameters

required	is a pointer to the NewShapeRequiredProperties structure, that provides the "required" shape data.
optional	is a pointer to the Common Optional Properties structure, that provides optional, supplementary data.

Returns: the new shape on success

Exceptions

on failure

Definition at line 239 of file Shapes.cpp.

References icedb::Groups::Group::createGroup(), createShape(), icedb::Groups::Group::doesGroupExist(), and icedb::Groups::Group::openGroup().

         {
             if (owner.doesGroupExist(name)) {
                 const auto grp = owner.openGroup(name);
                 return createShape(grp->getHDF5Group(), uid, required, optional);
             }
             else {
                 const auto grp = owner.createGroup(name);
                 return createShape(grp->getHDF5Group(), uid, required, optional);
             }
         }

Here is the call graph for this function:

◆ createShape() [3/3]

Shape::Shape_Type icedb::Shapes::Shape::createShape	(	Groups::Group::Group_HDF_shared_ptr	newShapeLocation,
		const std::string &	uid,
		gsl::not_null< const NewShapeRequiredProperties *>	required,
		const NewShapeCommonOptionalProperties *	optional = `nullptr`
	)

static

Create a new shape.

Parameters

newShapeLocation	is the "parent" of the shape - a shape is constructed as a child of the owner
uid	is a unique name for the shape

Exceptions

if	the group has any already-existing tables or attributes that conflict with the new shape object

Parameters

required	is a pointer to the NewShapeRequiredProperties structure, that provides the "required" shape data.
optional	is a pointer to the Common Optional Properties structure, that provides optional, supplementary data.

Returns: the new shape on success

Exceptions

on failure

Definition at line 254 of file Shapes.cpp.

         {
             Expects(required->isValid(&(std::cerr)));
             if (required->requiresOptionalPropertiesStruct()) Expects(optional);
             if (optional) Expects(optional->isValid(required));
             
             Shape::Shape_Type res = std::make_unique<Shape_impl>(uid, newShapeLocation);
             
             // Write required attributes
             res->writeAttribute<std::string>(Group::_icedb_obj_type_identifier, { 1 }, { Shape::_icedb_obj_type_shape_identifier });
             res->writeAttribute<std::string>("particle_id", { 1 }, { required->particle_id });
 
             // Write required dimensions
 
             // This table is created, but if it is trivial, then it is unset (i.e. internally set only to the fill value)
             bool createTblPSEN = false;
             if (optional) {
                 if (optional->particle_scattering_element_number.size()) createTblPSEN = true;
             }
             if (required->NC4_compat) createTblPSEN = true;
 
             std::unique_ptr<icedb::Tables::Table> tblPSEN;
             if (createTblPSEN) {
                 tblPSEN = res->createTable<uint64_t>("particle_scattering_element_number",
                 { static_cast<size_t>(required->number_of_particle_scattering_elements) });
                 if (optional) {
                     if (!optional->particle_scattering_element_number.empty()) {
                         tblPSEN->writeAll<uint64_t>(optional->particle_scattering_element_number);
                     }
                 }
                 // NOTE: The HDF5 dimension scale specification explicitly allows for dimensions to not have assigned values.
                 tblPSEN->setDimensionScale("particle_scattering_element_number");
             }
 
             bool createTblPCN = false;
             if (optional) {
                 if (optional->particle_constituent_number.size()) createTblPCN = true;
             }
             if (required->NC4_compat) createTblPCN = true;
 
             std::unique_ptr<icedb::Tables::Table> tblPCN;
             if (createTblPCN) {
                 tblPCN = res->createTable<uint8_t>("particle_constituent_number",
                 { static_cast<size_t>(required->number_of_particle_constituents) });
                 if (optional) {
                     if (!optional->particle_constituent_number.empty()) {
                         tblPCN->writeAll<uint8_t>(optional->particle_constituent_number);
                     }
                 }
                 tblPCN->setDimensionScale("particle_constituent_number");
             }
 
             std::unique_ptr<icedb::Tables::Table> tblXYZ;
             if (required->NC4_compat) {
                 tblXYZ = res->createTable<uint8_t>("particle_axis", { 3 }, { 0, 1, 2 });
                 tblXYZ->setDimensionScale("particle_axis");
             }
 
             constexpr size_t max_x = 20000;
             const std::vector<size_t> chunks{ 
                 (max_x < required->number_of_particle_scattering_elements) ? 
                 max_x : required->number_of_particle_scattering_elements, 3 };
             
             // Determine if we can store the data as integers.
             // If non-integral coordinates, no.
             bool considerInts = (required->particle_scattering_element_coordinates_are_integral) ? true : false;
             bool useUint16s = false, useUint8s = false;
             if (considerInts) {
                 // This minmax check is very slow.....
                 //const auto bounds = std::minmax_element(required->particle_scattering_element_coordinates.cbegin(), required->particle_scattering_element_coordinates.cend());
                 //if (*(bounds.first) > 0) {
                 //  if (*(bounds.second) < UINT8_MAX - 2) useUint8s = true;
                 //  else if (*(bounds.second) < UINT16_MAX - 2) useUint16s = true;
                 //}
                 float mx = -1;
                 if (optional) {
                     if (optional->hint_max_scattering_element_dimension > 0) {
                         mx = optional->hint_max_scattering_element_dimension > 0;
                     }
                 }
                 if (mx < 0) {
                     auto me = std::max_element(required->particle_scattering_element_coordinates.cbegin(), required->particle_scattering_element_coordinates.cend());
                     mx = *me;
                 }
                 if (mx < UINT8_MAX - 2) useUint8s = true;
                     else if (mx < UINT16_MAX - 2) useUint16s = true;
             }
             
             if (useUint8s) {
                 std::vector<uint8_t> crds_ints(required->number_of_particle_scattering_elements * 3);
                 for (size_t i = 0; i < crds_ints.size(); ++i) {
                     crds_ints[i] = static_cast<uint8_t>(required->particle_scattering_element_coordinates[i]);
                 }
                 auto tblPSEC = res->createTable<uint8_t>(
                     "particle_scattering_element_coordinates",
                     { static_cast<size_t>(required->number_of_particle_scattering_elements), 3 },
                     crds_ints, &chunks);
                 if (tblPSEN) tblPSEC->attachDimensionScale(0, tblPSEN.get());
                 if (tblXYZ) tblPSEC->attachDimensionScale(1, tblXYZ.get());
             }
             else if (useUint16s) {
                 std::vector<uint16_t> crds_ints(required->number_of_particle_scattering_elements*3);
                 for (size_t i = 0; i < crds_ints.size(); ++i) {
                     crds_ints[i] = static_cast<uint16_t>(required->particle_scattering_element_coordinates[i]);
                 }
                 auto tblPSEC = res->createTable<uint16_t>(
                     "particle_scattering_element_coordinates",
                     { static_cast<size_t>(required->number_of_particle_scattering_elements), 3 },
                     crds_ints, &chunks);
                 if (tblPSEN) tblPSEC->attachDimensionScale(0, tblPSEN.get());
                 if (tblXYZ) tblPSEC->attachDimensionScale(1, tblXYZ.get());
             } else {
                 auto tblPSEC = res->createTable<float>("particle_scattering_element_coordinates",
                 { static_cast<size_t>(required->number_of_particle_scattering_elements), 3 },
                     required->particle_scattering_element_coordinates, &chunks);
                 if (tblPSEN) tblPSEC->attachDimensionScale(0, tblPSEN.get());
                 if (tblXYZ) tblPSEC->attachDimensionScale(1, tblXYZ.get());
             }
 
 
             if (optional) {
 
                 // TODO: if (optional->particle_constituent_name.size()) {}
 
 
                 if (optional->particle_constituent_single_name.size()) {
                     res->writeAttribute<std::string>("particle_single_constituent_name",
                         { 1 }, { optional->particle_constituent_single_name });
                 }
 
                 if (optional->particle_scattering_element_composition_fractional.size()) {
                     const std::vector<size_t> cs{
                         (max_x < required->number_of_particle_scattering_elements) ?
                         max_x : required->number_of_particle_scattering_elements,
                         static_cast<size_t>(required->number_of_particle_constituents)
                     };
                     auto tblPSEC2a = res->createTable<float>("particle_scattering_element_composition_fractional",
                     { static_cast<size_t>(required->number_of_particle_scattering_elements),
                         static_cast<size_t>(required->number_of_particle_constituents) },
                         optional->particle_scattering_element_composition_fractional, &cs);
                     if (tblPSEN) tblPSEC2a->attachDimensionScale(0, tblPSEN.get());
                     if (tblPCN) tblPSEC2a->attachDimensionScale(1, tblPCN.get());
                 }
 
                 if (optional->particle_scattering_element_composition_whole.size()) {
                     const std::vector<size_t> cs{
                         (max_x < required->number_of_particle_scattering_elements) ?
                         max_x : required->number_of_particle_scattering_elements
                     };
                     auto tblPSEC2b = res->createTable<uint8_t>(
                         "particle_scattering_element_composition_whole",
                         { static_cast<size_t>(required->number_of_particle_scattering_elements) },
                         optional->particle_scattering_element_composition_whole, &cs);
                     if (tblPSEN) tblPSEC2b->attachDimensionScale(0, tblPSEN.get());
                 }
 
                 
 
                 // Write common optional attributes
                 if (optional->particle_scattering_element_spacing > 0)
                     res->writeAttribute<float>("particle_scattering_element_spacing", { 1 }, { optional->particle_scattering_element_spacing });
 
                 // Write common optional variables
                 if (optional->particle_scattering_element_radius.size()) {
                     auto tblPSER = res->createTable<float>("particle_scattering_element_radius",
                     { static_cast<size_t>(required->number_of_particle_scattering_elements) },
                         optional->particle_scattering_element_radius);
                     if (tblPSEN) tblPSER->attachDimensionScale(0, tblPSEN.get());
                 }
 
             }
 
             return res;
         }

Here is the call graph for this function:

◆ isShape() [1/3]

bool icedb::Shapes::Shape::isShape	(	Groups::Group &	owner,
		const std::string &	name
	)

static

Is this object a shape?

Parameters

owner	is the parent group
name	is the sub-group that is being tested

Exceptions

if	the group "name" does not exist

Returns: true if it is a shape, false otherwise.

Definition at line 163 of file Shapes.cpp.

References icedb::Groups::Group::doesGroupExist(), isShape(), and icedb::Groups::Group::openGroup().

                                                                      {
             if (!owner.doesGroupExist(name)) return false;
             auto grp = owner.openGroup(name);
             return isShape(grp->getHDF5Group().get());
         }

Here is the call graph for this function:

◆ isShape() [2/3]

bool icedb::Shapes::Shape::isShape ( gsl::not_null< H5::Group *> group )

static

Is this object a group?

Parameters

group is the HDF5 group

Exceptions

if	the object pointed to by group is not a valid HDF5 group.

Returns: true if it is a shape, false otherwise

Definition at line 168 of file Shapes.cpp.

References icedb::Attributes::Attribute< DataType >::data, icedb::Attributes::CanHaveAttributes::doesAttributeExist(), and icedb::Attributes::CanHaveAttributes::getAttributeTypeId().

                                                        {
             if (!Attributes::CanHaveAttributes::doesAttributeExist(group, Group::_icedb_obj_type_identifier)) return false;
             if (Attributes::CanHaveAttributes::getAttributeTypeId(group, Group::_icedb_obj_type_identifier) != typeid(std::string)) return false;
             
             Attributes::Attribute<std::string> obj_type
                 = Attributes::CanHaveAttributes::readAttribute<std::string>(group, Group::_icedb_obj_type_identifier);
             if (obj_type.data.size() != 1) return false;
             if (obj_type.data[0] != Shape::_icedb_obj_type_shape_identifier) return false;
             return true;
         }

Here is the call graph for this function:

◆ isShape() [3/3]

bool icedb::Shapes::Shape::isShape ( ) const

Is this object actually a shape?

Definition at line 178 of file Shapes.cpp.

References icedb::Groups::Group::getHDF5Group().

Referenced by isShape(), isValid(), and openShape().

                                   {
             return isShape(getHDF5Group().get());
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isValid() [1/2]

bool icedb::Shapes::Shape::isValid	(	gsl::not_null< H5::Group *>	group,
		std::ostream *	out = `nullptr`
	)

static

Is "group" a valid shape, according to the spec.?

Parameters

group is the HDF5 group

Exceptions

if	the object pointed to by group is not a valid HDF5 group.

Parameters

out	is an output stream to which diagnostic messages can be written. Diagnostics include why an object is not a shape (e.g. missing an essential parameter).

Exceptions

if	the output stream is somehow invalid

Check for the existence of the standard tables, dimensions and attributes, and that they have the appropriate sizes.

Todo:: Finish this, and tucn checks on attributes and variables into template functions!!!

Definition at line 183 of file Shapes.cpp.

References icedb::Groups::Group::_icedb_obj_type_identifier, icedb::Attributes::CanHaveAttributes::doesAttributeExist(), icedb::Attributes::CanHaveAttributes::getAttributeTypeId(), and isShape().

Referenced by isValid().

                                                                         {
 
 
             bool good = true;
             if (!isShape(group)) {
                 good = false;
                 if (out) (*out) << "This is not a valid shape. Missing the appropriate " 
                     << Groups::Group::_icedb_obj_type_identifier << " attribute." << std::endl;
                 return good;
             }
 
             if (!Attributes::CanHaveAttributes::doesAttributeExist(group, "particle_id")) {
                 good = false;
                 if (out) (*out) << "Missing the particle_id attribute." << std::endl;
             }
             else if (Attributes::CanHaveAttributes::getAttributeTypeId(group, "particle_id") != typeid(std::string)) {
                 good = false;
                 if (out) (*out) << "The particle_id attribute has the wrong type." << std::endl;
             }
             else {
                 auto attr = Attributes::CanHaveAttributes::readAttribute<std::string>(group, "particle_id");
                 if (attr.data.size() != 1) {
                     good = false;
                     if (out) (*out) << "The particle_id attribute has the wrong size. It should be a scalar." << std::endl;
                 }
                 else {
                     if (!attr.data[0].size()) {
                         good = false;
                         if (out) (*out) << "The particle_id attribute is empty." << std::endl;
                     }
                 }
             }
             if (out) (*out) << "TODO: Finish these checks!" << std::endl;
             return good;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isValid() [2/2]

bool icedb::Shapes::Shape::isValid ( std::ostream * out = nullptr ) const

Is this object a valid shape, according to the spec?

Parameters

out	is an output stream to which diagnostic messages can be written. Diagnostics include why an object is not a shape (e.g. missing an essential parameter).

Exceptions

if	the output stream is somehow invalid

Definition at line 182 of file Shapes.cpp.

References icedb::Groups::Group::getHDF5Group(), and isValid().

182 { return isValid(this->getHDF5Group().get(), out); }

icedb::Shapes::Shape::isValid

static bool isValid(gsl::not_null< H5::Group *> group, std::ostream *out=nullptr)

Is "group" a valid shape, according to the spec.?

Definition: Shapes.cpp:183

icedb::Groups::Group::getHDF5Group

virtual Group_HDF_shared_ptr getHDF5Group() const =0

Get the fundamental HDF5 object that the group is built on.

Here is the call graph for this function:

◆ openShape() [1/3]

Shape::Shape_Type icedb::Shapes::Shape::openShape ( Groups::Group & grpshp )

static

Re-open a group as a shape

Returns: the shape object on success

Exceptions

if	the group is not a valid shape

Definition at line 227 of file Shapes.cpp.

References icedb::Groups::Group::getHDF5Group().

Referenced by openShape().

                                                             {
             return openShape(grpshp.getHDF5Group());
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ openShape() [2/3]

Shape::Shape_Type icedb::Shapes::Shape::openShape	(	Groups::Group &	owner,
		const std::string &	name
	)

static

Open a group's subgroup as a shape.

Definition at line 222 of file Shapes.cpp.

References icedb::Groups::Group::doesGroupExist(), icedb::Groups::Group::openGroup(), and openShape().

                                                                                   {
             assert(owner.doesGroupExist(name));
             return openShape(owner.openGroup(name)->getHDF5Group());
         }

Here is the call graph for this function:

◆ openShape() [3/3]

Shape::Shape_Type icedb::Shapes::Shape::openShape ( Groups::Group::Group_HDF_shared_ptr shape )

static

Re-open an open HDF5 group as a shape.

Definition at line 432 of file Shapes.cpp.

References isShape().

                                                                               {
             // Get UUID
             //res->writeAttribute<std::string>("particle_id", { 1 }, { required->particle_id });
             Expects(isShape(shape.get()));
             //Expects(shape->attrExists("particle_id")); // Expects(isShape(shape.get())) subsumes this.
             auto id = Attributes::CanHaveAttributes::readAttribute<std::string>(shape.get(),"particle_id");
 
             Shape::Shape_Type res = std::make_unique<Shape_impl>(id.data[0], shape);
             return res;
         }

Here is the call graph for this function:

Member Data Documentation

◆ _icedb_obj_type_shape_identifier

const std::string icedb::Shapes::Shape::_icedb_obj_type_shape_identifier = "shape"

static

Each shape 'group' has an attribute with this identifier. Used for shape collection and searching.

Definition at line 118 of file shape.hpp.

Referenced by Shape().

◆ particle_unique_id

const std::string icedb::Shapes::Shape::particle_unique_id

This is the unique identifier for this shape.

Definition at line 194 of file shape.hpp.

The documentation for this class was generated from the following files:

lib/icedb/shape.hpp
lib/src/Shapes.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ Shape_Type

Constructor & Destructor Documentation

◆ Shape()

◆ ~Shape()

Member Function Documentation

◆ createShape() [1/3]

◆ createShape() [2/3]

◆ createShape() [3/3]

◆ isShape() [1/3]

◆ isShape() [2/3]

◆ isShape() [3/3]

◆ isValid() [1/2]

◆ isValid() [2/2]

◆ openShape() [1/3]

◆ openShape() [2/3]

◆ openShape() [3/3]

Member Data Documentation

◆ _icedb_obj_type_shape_identifier

◆ particle_unique_id