Stream

class HPS::Stream

The Stream class contains objects and enumerations used for importing and exporting HSF files.

Public Static Functions

static Toolkit CreateToolkit()

Create a new Toolkit. !

Returns: A new Toolkit.

class AttributeLockImportEvent : public HPS::Stream::ImportEvent 

Public Functions

AttributeLockImportEvent()

AttributeLockImportEvent(HPS::SegmentKey &in_segment_key, HPS::AttributeLockKit &in_attribute_lock_kit)

virtual ~AttributeLockImportEvent()

Public Members

HPS::AttributeLockKit &attribute_lock_kit

HPS::SegmentKey &segment_key

class BoundingImportEvent : public HPS::Stream::ImportEvent 

Public Functions

BoundingImportEvent()

BoundingImportEvent(HPS::SegmentKey &in_segment_key, HPS::BoundingKit &in_bounding_kit)

virtual ~BoundingImportEvent()

Public Members

HPS::BoundingKit &bounding_kit

HPS::SegmentKey &segment_key

class CameraImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CameraImportEvent()

CameraImportEvent(HPS::SegmentKey &in_segment_key, HPS::CameraKit &in_camera_kit)

virtual ~CameraImportEvent()

Public Members

HPS::CameraKit &camera_kit

HPS::SegmentKey &segment_key

class CircleImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CircleImportEvent()

CircleImportEvent(HPS::SegmentKey &in_segment_key, HPS::CircleKit &in_circle_kit)

virtual ~CircleImportEvent()

Public Members

HPS::CircleKit &circle_kit

HPS::SegmentKey &segment_key

class CircularArcImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CircularArcImportEvent()

CircularArcImportEvent(HPS::SegmentKey &in_segment_key, HPS::CircularArcKit &in_circular_arc_kit)

virtual ~CircularArcImportEvent()

Public Members

HPS::CircularArcKit &circular_arc_kit

HPS::SegmentKey &segment_key

class CircularWedgeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CircularWedgeImportEvent()

CircularWedgeImportEvent(HPS::SegmentKey &in_segment_key, HPS::CircularWedgeKit &in_circular_wedge_kit)

virtual ~CircularWedgeImportEvent()

Public Members

HPS::CircularWedgeKit &circular_wedge_kit

HPS::SegmentKey &segment_key

class ColorInterpolationImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ColorInterpolationImportEvent()

ColorInterpolationImportEvent(HPS::SegmentKey &in_segment_key, HPS::ColorInterpolationKit &in_color_interpolation_kit)

virtual ~ColorInterpolationImportEvent()

Public Members

HPS::ColorInterpolationKit &color_interpolation_kit

HPS::SegmentKey &segment_key

class CommentImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CommentImportEvent()

CommentImportEvent(HPS::SegmentKey &in_segment_key, char const *in_comment)

virtual ~CommentImportEvent()

Public Members

HPS::UTF8 const comment

HPS::SegmentKey &segment_key

class ConditionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ConditionImportEvent()

ConditionImportEvent(HPS::SegmentKey &in_segment_key)

virtual ~ConditionImportEvent()

Public Members

HPS::UTF8Array conditions

HPS::SegmentKey &segment_key

class ContourLineImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ContourLineImportEvent()

ContourLineImportEvent(HPS::SegmentKey &in_segment_key, HPS::ContourLineKit &in_contour_line_kit)

virtual ~ContourLineImportEvent()

Public Members

HPS::ContourLineKit &contour_line_kit

HPS::SegmentKey &segment_key

class CubeMapDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CubeMapDefinitionImportEvent()

CubeMapDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::ImageDefinition &in_negative_z, HPS::ImageDefinition &in_positive_z, HPS::ImageDefinition &in_negative_x, HPS::ImageDefinition &in_positive_x, HPS::ImageDefinition &in_negative_y, HPS::ImageDefinition &in_positive_y, HPS::TextureOptionsKit &in_texture_kit)

virtual ~CubeMapDefinitionImportEvent()

Public Members

UTF8 name

HPS::ImageDefinition &negative_x

HPS::ImageDefinition &negative_y

HPS::ImageDefinition &negative_z

HPS::PortfolioKey &portfolio_key

HPS::ImageDefinition &positive_x

HPS::ImageDefinition &positive_y

HPS::ImageDefinition &positive_z

HPS::TextureOptionsKit &texture_kit

class CullingImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CullingImportEvent()

CullingImportEvent(HPS::SegmentKey &in_segment_key, HPS::CullingKit &in_culling_kit)

virtual ~CullingImportEvent()

Public Members

HPS::CullingKit &culling_kit

HPS::SegmentKey &segment_key

class CurveAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CurveAttributeImportEvent()

CurveAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::CurveAttributeKit &in_curve_attribute_kit)

virtual ~CurveAttributeImportEvent()

Public Members

HPS::CurveAttributeKit &curve_attribute_kit

HPS::SegmentKey &segment_key

class CuttingSectionAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CuttingSectionAttributeImportEvent()

CuttingSectionAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::CuttingSectionAttributeKit &in_cutting_section_attribute_kit)

virtual ~CuttingSectionAttributeImportEvent()

Public Members

HPS::CuttingSectionAttributeKit &cutting_section_attribute_kit

HPS::SegmentKey &segment_key

class CuttingSectionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CuttingSectionImportEvent()

CuttingSectionImportEvent(HPS::SegmentKey &in_segment_key, HPS::CuttingSectionKit &in_cutting_section_kit)

virtual ~CuttingSectionImportEvent()

Public Members

HPS::CuttingSectionKit &cutting_section_kit

HPS::SegmentKey &segment_key

class CylinderAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CylinderAttributeImportEvent()

CylinderAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::CylinderAttributeKit &in_cylinder_attribute_kit)

virtual ~CylinderAttributeImportEvent()

Public Members

HPS::CylinderAttributeKit &cylinder_attribute_kit

HPS::SegmentKey &segment_key

class CylinderImportEvent : public HPS::Stream::ImportEvent 

Public Functions

CylinderImportEvent()

CylinderImportEvent(HPS::SegmentKey &in_segment_key, HPS::CylinderKit &in_cylinder_kit)

virtual ~CylinderImportEvent()

Public Members

HPS::CylinderKit &cylinder_kit

HPS::SegmentKey &segment_key

class DistantLightImportEvent : public HPS::Stream::ImportEvent 

Public Functions

DistantLightImportEvent()

DistantLightImportEvent(HPS::SegmentKey &in_segment_key, HPS::DistantLightKit &in_distantlight_kit)

virtual ~DistantLightImportEvent()

Public Members

HPS::DistantLightKit &distant_light_kit

HPS::SegmentKey &segment_key

class DistantLightPropertyImportEvent : public HPS::Stream::ImportEvent 

Public Functions

DistantLightPropertyImportEvent()

DistantLightPropertyImportEvent(HPS::DistantLightKey &in_distant_light_key, HPS::DistantLightKit &in_distant_light_kit)

virtual ~DistantLightPropertyImportEvent()

Public Members

HPS::DistantLightKey &distant_light_key

HPS::DistantLightKit &distant_light_kit

class DrawingAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

DrawingAttributeImportEvent()

DrawingAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::DrawingAttributeKit &in_drawing_attribute_kit)

virtual ~DrawingAttributeImportEvent()

Public Members

HPS::DrawingAttributeKit &drawing_attribute_kit

HPS::SegmentKey &segment_key

class EdgeAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

EdgeAttributeImportEvent()

EdgeAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::EdgeAttributeKit &in_edge_attribute_kit)

virtual ~EdgeAttributeImportEvent()

Public Members

HPS::EdgeAttributeKit &edge_attribute_kit

HPS::SegmentKey &segment_key

class EllipseImportEvent : public HPS::Stream::ImportEvent 

Public Functions

EllipseImportEvent()

EllipseImportEvent(HPS::SegmentKey &in_segment_key, HPS::EllipseKit &in_ellipse_kit)

virtual ~EllipseImportEvent()

Public Members

HPS::EllipseKit &ellipse_kit

HPS::SegmentKey &segment_key

class EllipticalArcImportEvent : public HPS::Stream::ImportEvent 

Public Functions

EllipticalArcImportEvent()

EllipticalArcImportEvent(HPS::SegmentKey &in_segment_key, HPS::EllipticalArcKit &in_elliptical_arc_kit)

virtual ~EllipticalArcImportEvent()

Public Members

HPS::EllipticalArcKit &elliptical_arc_kit

HPS::SegmentKey &segment_key

class ExportEvent

The ExportEvent class is the base class for events signaled during Stream export.

Subclassed by HPS::Stream::GeometryExportEvent, HPS::Stream::SegmentExportEvent

Public Functions

intptr_t GetClassID() const: Returns a unique identifier that is shared by all objects of the same class.

virtual ~ExportEvent()

Public Members

HPS::ByteArray non_db_user_data: A HPS::ByteArray where the user may store data that is not associated with the database to be export by Stream. On import, this data will be reported to the user through a HPS::Stream::NonDBuserDataEvent

class ExportEventHandler

The ExportEventHandler class is the base class for user-defined ExportEvent handlers.

Public Functions

inline ExportEventHandler()

virtual void Handle(ExportEvent *in_event)

The handler function for Stream ExportEvents. Override this function to process the ExportEvent to suit your needs. This function is called synchronously as data is exported by Stream; Stream export will be paused until this function returns.

Parameters: in_event – A pointer to the ExportEvent data.

virtual ~ExportEventHandler()

class ExportNotifier : public HPS::IONotifier 

The ExportNotifier class is a smart-pointer that is associated with an asynchronous file export. It is used to interact with an ongoing export or get the results from a completed export.

Public Functions

void Assign(ExportNotifier const &in_that)

Associate this ExportNotifier with the same file export as the source ExportNotifier.

Parameters: in_that – The source ExportNotifier for the assignment.

ExportNotifier(): The default constructor creates an ExportNotifier object which is not associated with any file export.

ExportNotifier(ExportNotifier &&in_that)

The move constructor creates an ExportNotifier by transferring the underlying impl of the rvalue reference to this ExportNotifier thereby avoiding a copy and allocation.

Parameters: in_that – An rvalue reference to an ExportNotifier to take the impl from.

ExportNotifier(ExportNotifier const &in_that)

The copy constructor creates a new ExportNotifier object that is associated with the same file export as the source ExportNotifier.

Parameters: in_that – The source ExportNotifier to copy.

ExportNotifier(IONotifier const &in_that)

The conversion constructor creates a new derived ExportNotifier object from a base IONotifier object. The copy will only be successful if the source notifier is really an upcast of this notifier type. Otherwise the copy will fail and the resulting ExportNotifier will be invalid.

Parameters: in_that – The source IONotifier to copy.

inline virtual HPS::Type ObjectType() const

This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

Returns: The declared type of the object in question, which may differ from the true, underlying type.

ExportNotifier &operator=(ExportNotifier &&in_that)

The move assignment operator transfers the underlying impl of the rvalue reference to this ExportNotifier thereby avoiding a copy.

Parameters: in_that – An rvalue reference to an ExportNotifier to take the impl from.
Returns: A reference to this ExportNotifier.

ExportNotifier &operator=(ExportNotifier const &in_that)

Associate this ExportNotifier with the same file export as the source ExportNotifier.

Parameters: in_that – The source ExportNotifier for the assignment.
Returns: A reference to this ExportNotifier.

virtual ~ExportNotifier()

Public Static Attributes

static const HPS::Type staticType = HPS::Type::StreamExportNotifier

class ExportOptionsKit : public HPS::Kit 

The HPS::Stream::ExportOptionsKit class contains settings controlling the export of HSF files. Calling HPS::Stream::ExportOptionsKit::GetDefault() will return an options kit with values found in this table.

Public Functions

virtual bool Empty() const

Indicates whether this ExportOptionsKit has any values set on it.

Returns: true if no values are set on this ExportOptionsKit, false otherwise.

bool Equals(ExportOptionsKit const &in_kit) const

Check if the source ExportOptionsKit is equivalent to this ExportOptionsKit.

Parameters: in_kit – The source ExportOptionsKit to compare to this ExportOptionsKit.
Returns: true if the objects are equivalent, false otherwise.

ExportOptionsKit(): The default constructor creates an empty ExportOptionsKit object.

ExportOptionsKit(ExportOptionsKit &&in_that)

The move constructor creates an ExportOptionsKit by transferring the underlying impl of the rvalue reference to this ExportOptionsKit thereby avoiding a copy and allocation.

Parameters: in_that – An rvalue reference to an ExportOptionsKit to take the impl from.

ExportOptionsKit(ExportOptionsKit const &in_kit)

The copy constructor creates a new ExportOptionsKit object that contains the same settings as the source ExportOptionsKit.

Parameters: in_kit – The source ExportOptionsKit to copy.

inline virtual HPS::Type ObjectType() const

This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

Returns: The declared type of the object in question, which may differ from the true, underlying type.

bool operator!=(ExportOptionsKit const &in_kit) const

Check if the source ExportOptionsKit is not equivalent to this ExportOptionsKit.

Parameters: in_kit – The source ExportOptionsKit to compare to this ExportOptionsKit.
Returns: true if the objects are not equivalent, false otherwise.

ExportOptionsKit &operator=(ExportOptionsKit &&in_that)

The move assignment operator transfers the underlying impl of the rvalue reference to this ExportOptionsKit thereby avoiding a copy.

Parameters: in_that – An rvalue reference to an ExportOptionsKit to take the impl from.
Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &operator=(ExportOptionsKit const &in_kit)

Copies the source ExportOptionsKit into this ExportOptionsKit.

Parameters: in_kit – The source ExportOptionsKit to copy.
Returns: A reference to this ExportOptionsKit.

bool operator==(ExportOptionsKit const &in_kit) const

Check if the source ExportOptionsKit is equivalent to this ExportOptionsKit.

Parameters: in_kit – The source ExportOptionsKit to compare to this ExportOptionsKit.
Returns: true if the objects are equivalent, false otherwise.

void Set(ExportOptionsKit const &in_kit)

Copies the source ExportOptionsKit into this ExportOptionsKit.

Parameters: in_kit – The source ExportOptionsKit to copy.

ExportOptionsKit &SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24)

Sets color compression state and maximum number of bits to use for each (r,g,b) color. Defaults to no compression.

See: Default value

Parameters

in_state – Whether color compression is enabled or not.
in_bits_per_color – Number of bits to use per color when performing color compression. Value must be in the range [0, 72]. Defaults to 24.

Returns

A reference to this ExportOptionsKit.

ExportOptionsKit &SetConnectivityCompression(bool in_state)

Sets connectivity (face list) compression state. Defaults to no compression.

See: Default value

Parameters: in_state – Whether color index compression is enabled or not.
Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &SetDefaultCamera(CameraKit const &in_camera)

Sets the default camera used for the export process. If no camera is specified, no default camera will be used during export.

Parameters: in_camera – The camera to apply as default.
Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &SetEventHandler(HPS::Stream::ExportEventHandler &in_handler, intptr_t in_type)

Sets the specified ExportEventHandler for the indicated ExportEvent type.

Parameters

in_handler – An ExportEventHandler to be set.
in_type – The type of the Stream ExportEvent for which the given event handler will be used.

Returns

A reference to this ExportOptionsKit.

ExportOptionsKit &SetImageCompression(bool in_state, float in_quality = 0.75f)

Sets image compression state for uncompressed images in segment tree. Defaults to no compression, though the images will be converted to lossless PNG data within the file.

See: Default value

Parameters

in_state – Whether to compress uncompressed images. If false, uncompressed images will be exported as lossless PNG, if true, they are exported as JPEG with the specified quality.
in_quality – Float in the range [0,1] indicating the quality of the JPEG image. Defaults to 0.75f.

Returns

A reference to this ExportOptionsKit.

ExportOptionsKit &SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8)

Sets color index compression state and maximum number of bits to use for each float index. Defaults to no compression.

See: Default value

Parameters

in_state – Whether color index compression is enabled or not.
in_bits_per_index – Number of bits to use per index when performing color index compression. Value must be in the range [0, 24]. Defaults to 8.

Returns

A reference to this ExportOptionsKit.

ExportOptionsKit &SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10)

Sets normal compression state and maximum number of bits to use for each (x,y,z) normal. Defaults to no compression.

See: Default value

Parameters

in_state – Whether normal compression is enabled or not.
in_bits_per_normal – Number of bits to use per normal when performing normal compression. Value must be in the range [0, 72]. Defaults to 10.

Returns

A reference to this ExportOptionsKit.

ExportOptionsKit &SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8)

Sets vertex parameter compression state and maximum number of bits to use for each (single) vertex parameter. Defaults to no compression.

Parameters

in_state – Whether parameter compression is enabled or not.
in_bits_per_parameter – Number of bits to use per parameter when performing parameter compression. Value must be in the range [0, 24]. Defaults to 8.

Returns

A reference to this ExportOptionsKit.

ExportOptionsKit &SetSerializeTristrips(bool in_state)

Sets tristrips serialization state. Defaults to tristrips are serialized.

See: Default value

Parameters: in_state – Whether tristrips serialization is enabled or not.
Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &SetToolkit(Toolkit const &in_toolkit)

Sets the toolkit used for the export process. If no toolkit is specified, a default tookit will be used during export.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24)

Sets vertex compression state and maximum number of bits to use for each (x,y,z) vertex. Defaults to no compression.

See: Default value

Parameters

in_state – Whether vertex compression is enabled or not.
in_bits_per_vertex – Number of bits to use per vertex when performing vertex compression. Value must be in the range [0, 72]. Defaults to 24.

Returns

A reference to this ExportOptionsKit.

void Show(ExportOptionsKit &out_kit) const

Copies this ExportOptionsKit into the given ExportOptionsKit.

Parameters: out_kit – The ExportOptionsKit to populate with the contents of this ExportOptionsKit.

bool ShowColorCompression(bool &out_state, unsigned int &out_bits_per_color) const

Shows color compression state and maximum number of bits to use for each (r,g,b) color.

Parameters

out_state – Whether color compression is enabled or not.
out_bits_per_color – Number of bits to use per color when performing color compression.

Returns

true if a color compression setting was specified, false otherwise.

bool ShowConnectivityCompression(bool &out_state) const

Shows connectivity (face list) compression state.

Parameters: out_state – Whether connectivity compression is enabled or not.
Returns: true if a connectivity compression setting was specified, false otherwise.

bool ShowDefaultCamera(CameraKit &out_camera) const

Shows the default camera used for the export process.

Parameters: out_camera – The camera being used as default.
Returns: A reference to this ExportOptionsKit.

bool ShowImageCompression(bool &out_state, float &out_quality) const

Shows image compression state for uncompressed images in segment tree.

Parameters

out_state – Whether image compression is enabled or not.
out_quality – Float in the range [0,1] indicating the quality of the JPEG image.

Returns

true if an image compression setting was specified, false otherwise.

bool ShowIndexCompression(bool &out_state, unsigned int &out_bits_per_index) const

Shows color index compression state and maximum number of bits to use for each float index.

Parameters

out_state – Whether color index compression is enabled or not.
out_bits_per_index – Number of bits to use per index when performing color index compression.

Returns

true if a color index compression setting was specified, false otherwise.

bool ShowNormalCompression(bool &out_state, unsigned int &out_bits_per_normal) const

Shows normal compression state and maximum number of bits to use for each (x,y,z) normal.

Parameters

out_state – Whether normal compression is enabled or not.
out_bits_per_normal – Number of bits to use per normal when performing normal compression.

Returns

true if a normal compression setting was specified, false otherwise.

bool ShowParameterCompression(bool &out_state, unsigned int &out_bits_per_parameter) const

Shows vertex parameter compression state and maximum number of bits to use for each (single) vertex parameter.

Parameters

out_state – Whether parameter compression is enabled or not.
out_bits_per_parameter – Number of bits to use per parameter when performing parameter compression.

Returns

true if a parameter compression setting was specified, false otherwise.

bool ShowSerializeTristrips(bool &out_state) const

Shows tristrips serialization state.

Parameters: out_state – Whether tristrips serialization is enabled or not.
Returns: true if a tristrips serialization setting was specified, false otherwise.

bool ShowToolkit(HPS::Stream::Toolkit &out_toolkit) const

Shows the root toolkit used for the export process.

Parameters: out_toolkit – The Toolkit used for the export process.
Returns: true if a toolkit was specified, false otherwise.

bool ShowVertexCompression(bool &out_state, unsigned int &out_bits_per_vertex) const

Shows vertex compression state and maximum number of bits to use for each (x,y,z) vertex.

Parameters

out_state – Whether vertex compression is enabled or not.
out_bits_per_vertex – Number of bits to use per vertex when performing vertex compression.

Returns

true if a vertex compression setting was specified, false otherwise.

ExportOptionsKit &UnsetColorCompression()

Removes color compression state and maximum number of bits to use for each (r,g,b) color.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetConnectivityCompression()

Removes connectivity (face list) compression state.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetDefaultCamera()

Removes the default camera used for the export process.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetEventHandler(intptr_t in_type)

Unsets the ExportEventHandler for the indicated ExportEvent type.

Parameters: in_type – The type of the Stream ExportEvent to unset.
Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetEventHandlers()

Unsets the ExportEventHandler for all ExportEvent types.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetEverything()

Removes all settings from this ExportOptionsKit.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetImageCompression()

Removes image compression state for uncompressed images in segment tree.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetIndexCompression()

Removes color index compression state and maximum number of bits to use for each float index.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetNormalCompression()

Removes normal compression state and maximum number of bits to use for each (x,y,z) normal.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetParameterCompression()

Removes vertex parameter compression state and maximum number of bits to use for each (single) vertex parameter.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetSerializeTristrips()

Removes tristrips serialization state.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetToolkit()

Removes the toolkit used for the export process.

Returns: A reference to this ExportOptionsKit.

ExportOptionsKit &UnsetVertexCompression()

Removes vertex compression state and maximum number of bits to use for each (x,y,z) vertex.

Returns: A reference to this ExportOptionsKit.

virtual ~ExportOptionsKit()

Public Static Functions

static ExportOptionsKit GetDefault()

Creates a ExportOptionsKit which contains the default settings. The returned object will not necessarily have values set for every option, but it will have settings for those options where it is reasonable to have a default.

Returns: A ExportOptionsKit with the default settings.

Public Static Attributes

static const HPS::Type staticType = HPS::Type::StreamExportOptionsKit

class ExportStartedEvent : public HPS::Event 

The ExportStartedEvent class indicates that a Stream export has started. It will always be injected synchronously.

Public Functions

inline virtual Event *Clone() const

Allocates and returns a copy of this ExportStartedEvent.

Returns: A copy of this TimerEvent.

inline virtual bool Drop(Event const *in_that_event) const

Determines if this ExportStartedEvent can be drop in favor of the following event of the same type

Parameters: in_that_event – Event to compare with this ExportStartedEvent.
Returns: true if this event can be dropped, false otherwise.

inline ExportStartedEvent(): The default constructor creates a ExportStartedEvent object.

inline ExportStartedEvent(Event const &in_event)

This constructor converts an Event Object to a ExportStartedEvent object.

Parameters: in_event – The Event Object to be converted.

inline virtual intptr_t Freshen() const

This optional function is used to determine if the current event can be dropped in favor of newer event of the same type if one is available.

Returns: A cookie representing the freshen category. Zero indicates a non-freshening event.

~ExportStartedEvent()

Public Members

HPS::Time export_started_time

class File

The File class provides functions to import and export HSF files.

Public Static Functions

static ExportNotifier Export(char const *in_file_name, SegmentKey const &in_segment, ExportOptionsKit const &in_options)

Performs an asynchronous HSF export of the given segment with the provided options to a given filename. An exception will be thrown if a problem is encountered during export.

Parameters

in_file_name – Name of the file to write the HSF data to.
in_segment – Segment containing the data to export.
in_options – Options controlling the export of the HSF data.

Returns

An ExportNotifier object that can be used to query the export progress and status.

static ExportNotifier Export(SegmentKey const &in_segment, ExportOptionsKit const &in_options, ByteArrayArray &out_hsf_buffers)

Performs an asynchronous HSF export of the given segment with the provided options to a list of output buffers. An exception will be thrown if a problem is encountered during export.

Parameters

in_segment – Segment containing the data to export.
in_options – Options controlling the export of the HSF data.
out_hsf_buffers – The output buffers the exported HSF data is written to.

Returns

An ExportNotifier object that can be used to query the export progress and status.

static ImportNotifier Import(ByteArrayArray const &in_hsf_buffers, ImportOptionsKit const &in_options)

Performs an asynchronous import of the specified HSF file with the provided options. May throw an IOException prior to starting the asynchronous import.

Parameters

in_hsf_buffers – The buffer of HSF data to import.
in_options – Options controlling the import of the HSF file (e.g., segment to import into).

Returns

An ImportNotfier object that can be used to query the import progress and status.

static ImportNotifier Import(char const *in_file_name, ImportOptionsKit const &in_options)

Performs an asynchronous import of the specified HSF file with the provided options. May throw an IOException prior to starting the asynchronous import.

Parameters

in_file_name – Name of HSF file to import.
in_options – Options controlling the import of the HSF file (e.g., segment to import into).

Returns

An ImportNotfier object that can be used to query the import progress and status.

class GeometryExportEvent : public HPS::Stream::ExportEvent 

The GeometryExportEvent class indicates that geometry is about to be exported by Stream.

Public Functions

GeometryExportEvent()

GeometryExportEvent(HPS::Key &in_key)

virtual ~GeometryExportEvent()

Public Members

HPS::Key &key: A key to geometry that is about to be exported by stream.

class GlyphDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

GlyphDefinitionImportEvent()

GlyphDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::GlyphKit &in_glyph_kit)

virtual ~GlyphDefinitionImportEvent()

Public Members

HPS::GlyphKit &glyph_kit

UTF8 name

HPS::PortfolioKey &portfolio_key

class GridImportEvent : public HPS::Stream::ImportEvent 

Public Functions

GridImportEvent()

GridImportEvent(HPS::SegmentKey &in_segment_key, HPS::GridKit &in_grid_kit)

virtual ~GridImportEvent()

Public Members

HPS::GridKit &grid_kit

HPS::SegmentKey &segment_key

class HiddenLineAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

HiddenLineAttributeImportEvent()

HiddenLineAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::HiddenLineAttributeKit &in_hidden_attribute_kit)

virtual ~HiddenLineAttributeImportEvent()

Public Members

HPS::HiddenLineAttributeKit &hidden_line_attribute_kit

HPS::SegmentKey &segment_key

class ImageDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ImageDefinitionImportEvent()

ImageDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::ImageKit &in_image_kit)

virtual ~ImageDefinitionImportEvent()

Public Members

HPS::ImageKit &image_kit

UTF8 name

HPS::PortfolioKey &portfolio_key

class ImportCompletedEvent : public HPS::Event 

The ImportCompletedEvent class indicates that a Stream import is complete. It will always be injected synchronously.

Public Functions

inline virtual Event *Clone() const

Allocates and returns a copy of this ImportCompletedEvent.

Returns: A copy of this TimerEvent.

inline virtual bool Drop(Event const *in_that_event) const

Determines if this ImportCompletedEvent can be drop in favor of the following event of the same type

Parameters: in_that_event – Event to compare with this ImportCompletedEvent.
Returns: true if this event can be dropped, false otherwise.

inline virtual intptr_t Freshen() const

This optional function is used to determine if the current event can be dropped in favor of newer event of the same type if one is available.

Returns: A cookie representing the freshen category. Zero indicates a non-freshening event.

inline ImportCompletedEvent(): The default constructor creates a ImportCompletedEvent object.

inline ImportCompletedEvent(Event const &in_event)

This constructor converts an Event Object to a ImportCompletedEvent object.

Parameters: in_event – The Event Object to be converted.

~ImportCompletedEvent()

Public Members

HPS::Time import_completed_time

class ImportEvent

The ImportEvent class is the base class for events signaled during Stream export.

Public Functions

intptr_t GetClassID() const: Returns a unique identifier that is shared by all objects of the same class.

virtual ~ImportEvent()

class ImportEventHandler

The ImportEventHandler class is the base class for user-defined ImportEvent handlers. If your ImportEventHandler elects not to import incoming geometry, then subsequent operations on that geometry along with follow-up attributes (priority, user-data, etc…) will throw an InvalidObjectException.

Public Functions

virtual bool Handle(ImportEvent *in_event)

The handler function for Stream ImportEvents. Override this function to process the ImportEvent to suit your needs. This function is called synchronously as data is imported by Stream; Stream import will be paused until this function returns.

Parameters: in_event – A pointer to the ImportEvent representing the impending change to the database.
Returns: A bool that specifies if the database change indicated by in_event should be applied. true means that the change will be applied to the database; false means that no change will be made.

inline ImportEventHandler()

virtual ~ImportEventHandler()

class ImportNotifier : public HPS::IONotifier 

The ImportNotifier class is a smart-pointer that is associated with an asynchronous file import. It is used to interact with an ongoing import or get the results from a completed import.

Public Functions

void Assign(ImportNotifier const &in_that)

Associate this ImportNotifier with the same file import as the source ImportNotifier.

Parameters: in_that – The source ImportNotifier for the assignment.

ImportResultsKit GetResults() const

Get the ImportResultsKit for the file import. Throws an IOException if the import is not complete or was not successful.

Returns: The ImportResultsKit for a successful file import.

ImportNotifier(): The default constructor creates an ImportNotifier object which is not associated with any file import.

ImportNotifier(ImportNotifier &&in_that)

The move constructor creates an ImportNotifier by transferring the underlying impl of the rvalue reference to this ImportNotifier thereby avoiding a copy and allocation.

Parameters: in_that – An rvalue reference to an ImportNotifier to take the impl from.

ImportNotifier(ImportNotifier const &in_that)

The copy constructor creates a new ImportNotifier object that is associated with the same file import as the source ImportNotifier.

Parameters: in_that – The source ImportNotifier to copy.

ImportNotifier(IONotifier const &in_that)

The conversion constructor creates a new derived ImportNotifier object from a base IONotifier object. The copy will only be successful if the source notifier is really an upcast of this notifier type. Otherwise the copy will fail and the resulting ImportNotifier will be invalid.

Parameters: in_that – The source IONotifier to copy.

inline virtual HPS::Type ObjectType() const

This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

Returns: The declared type of the object in question, which may differ from the true, underlying type.

ImportNotifier &operator=(ImportNotifier &&in_that)

The move assignment operator transfers the underlying impl of the rvalue reference to this ImportNotifier thereby avoiding a copy.

Parameters: in_that – An rvalue reference to an ImportNotifier to take the impl from.
Returns: A reference to this ImportNotfier.

ImportNotifier &operator=(ImportNotifier const &in_that)

Associate this ImportNotifier with the same file import as the source ImportNotifier.

Parameters: in_that – The source ImportNotifier for the assignment.
Returns: A reference to this ImportNotifier.

virtual ~ImportNotifier()

Public Static Attributes

static const HPS::Type staticType = HPS::Type::StreamImportNotifier

class ImportOptionsKit : public HPS::Kit 

The ImportOptionsKit class contains any settings controlling the import of HSF files.

Public Functions

virtual bool Empty() const

Indicates whether this ImportOptionsKit has any values set on it.

Returns: true if no values are set on this ImportOptionsKit, false otherwise.

bool Equals(ImportOptionsKit const &in_kit) const

Check if the source ImportOptionsKit is equivalent to this ImportOptionsKit.

Parameters: in_kit – The source ImportOptionsKit to compare to this ImportOptionsKit.
Returns: true if the objects are equivalent, false otherwise.

ImportOptionsKit(): The default constructor creates an empty ImportOptionsKit object.

ImportOptionsKit(ImportOptionsKit &&in_that)

The move constructor creates an ImportOptionsKit by transferring the underlying impl of the rvalue reference to this ImportOptionsKit thereby avoiding a copy and allocation.

Parameters: in_that – An rvalue reference to an ImportOptionsKit to take the impl from.

ImportOptionsKit(ImportOptionsKit const &in_kit)

The copy constructor creates a new ImportOptionsKit object that contains the same settings as the source ImportOptionsKit.

Parameters: in_kit – The source ImportOptionsKit to copy.

inline virtual HPS::Type ObjectType() const

This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

Returns: The declared type of the object in question, which may differ from the true, underlying type.

bool operator!=(ImportOptionsKit const &in_kit) const

Check if the source ImportOptionsKit is not equivalent to this ImportOptionsKit.

Parameters: in_kit – The source ImportOptionsKit to compare to this ImportOptionsKit.
Returns: true if the objects are not equivalent, false otherwise.

ImportOptionsKit &operator=(ImportOptionsKit &&in_that)

The move assignment operator transfers the underlying impl of the rvalue reference to this ImportOptionsKit thereby avoiding a copy.

Parameters: in_that – An rvalue reference to an ImportOptionsKit to take the impl from.
Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &operator=(ImportOptionsKit const &in_kit)

Copies the source ImportOptionsKit into this ImportOptionsKit.

Parameters: in_kit – The source ImportOptionsKit to copy.
Returns: A reference to this ImportOptionsKit.

bool operator==(ImportOptionsKit const &in_kit) const

Check if the source ImportOptionsKit is equivalent to this ImportOptionsKit.

Parameters: in_kit – The source ImportOptionsKit to compare to this ImportOptionsKit.
Returns: true if the objects are equivalent, false otherwise.

void Set(ImportOptionsKit const &in_kit)

Copies the source ImportOptionsKit into this ImportOptionsKit.

Parameters: in_kit – The source ImportOptionsKit to copy.

ImportOptionsKit &SetAlternateRoot(SegmentKey const &in_segment)

Sets the segment which will be used when the import file tries to access segments above the root segment. If no segment is specified, a root segment will be created for this purpose during import.

Parameters: in_segment – Segment that will be used when the import file tries to access segments above the root segment.
Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &SetEventHandler(HPS::Stream::ImportEventHandler &in_handler, intptr_t in_type)

Sets the specified ImportEventHandler for the indicated ImportEvent type.

Parameters

in_handler – An ImportEventHandler to be set.
in_type – The type of the Stream ImportEvent for which the given event handler will be used.

Returns

A reference to this ImportOptionsKit.

ImportOptionsKit &SetPortfolio(PortfolioKey const &in_portfolio)

Sets the portfolio which will be used for any definitions that need to be created during import. If no portfolio is specified, a portfolio will be created for this purpose during import.

Parameters: in_portfolio – Portfolio that will be used for any definitions that need to be created during import.
Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &SetSegment(SegmentKey const &in_segment)

Sets the root segment where the HSF data will be imported into. If no segment is specified, a root segment will be created for this purpose during import.

Parameters: in_segment – Segment the HSF data will be imported into.
Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &SetToolkit(Toolkit const &in_toolkit)

Sets the toolkit used for the import process. If no tooklkit is specified, a default tookit will be used during import.

Returns: A reference to this ImportOptionsKit.

void Show(ImportOptionsKit &out_kit) const

Copies this ImportOptionsKit into the given ImportOptionsKit.

Parameters: out_kit – The ImportOptionsKit to populate with the contents of this ImportOptionsKit.

bool ShowAlternateRoot(SegmentKey &out_segment) const

Shows the segment which will be used when the import file tries to access segments above the root segment.

Parameters: out_segment – Segment that will be used when the import file tries to access segments above the root segment.
Returns: true if an alternate root segment was specified, false otherwise.

bool ShowPortfolio(PortfolioKey &out_portfolio) const

Shows the portfolio which will be used for any definitions that need to be created during import.

Parameters: out_portfolio – Portfolio that will be used for any definitions that need to be created during import.
Returns: true if a portfolio was specified, false otherwise.

bool ShowSegment(SegmentKey &out_segment) const

Shows the root segment where the HSF data will be imported into.

Parameters: out_segment – Segment the HSF data will be imported into.
Returns: true if a root segment was specified, false otherwise.

bool ShowToolkit(HPS::Stream::Toolkit &out_toolkit) const

Shows the root toolkit used for the import process.

Parameters: out_toolkit – The Toolkit used for the import process.
Returns: true if a toolkit was specified, false otherwise.

ImportOptionsKit &UnsetAlternateRoot()

Removes the segment which will be used when the import file tries to access segments above the root segment.

Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &UnsetEventHandler(intptr_t in_type)

Unsets the ImportEventHandler for the indicated ImportEvent type.

Parameters: in_type – The type of the Stream ImportEvent to unset.
Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &UnsetEventHandlers()

Unsets the ImportEventHandler for all ImportEvent types.

Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &UnsetEverything()

Removes all settings from this ImportOptionsKit.

Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &UnsetPortfolio()

Removes the portfolio which will be used for any definitions that need to be created during import.

Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &UnsetSegment()

Removes the root segment speciyfing where the HSF data will be imported into.

Returns: A reference to this ImportOptionsKit.

ImportOptionsKit &UnsetToolkit()

Removes the toolkit used for the import process.

Returns: A reference to this ImportOptionsKit.

virtual ~ImportOptionsKit()

Public Static Attributes

static const HPS::Type staticType = HPS::Type::StreamImportOptionsKit

class ImportResultsKit : public HPS::Kit 

The ImportResultsKit class contains the results of a successful HSF import.

Public Functions

virtual bool Empty() const

Indicates whether this ImportResultsKit has any values set on it.

Returns: true if no values are set on this ImportResultsKit, false otherwise.

bool Equals(ImportResultsKit const &in_kit) const

Check if the source ImportResultsKit is equivalent to this ImportResultsKit.

Parameters: in_kit – The source ImportResultsKit to compare to this ImportResultsKit.
Returns: true if the objects are equivalent, false otherwise.

ImportResultsKit(): The default constructor creates an empty ImportResultsKit object.

ImportResultsKit(ImportResultsKit &&in_that)

The move constructor creates an ImportResultsKit by transferring the underlying impl of the rvalue reference to this ImportResultsKit thereby avoiding a copy and allocation.

Parameters: in_that – An rvalue reference to an ImportResultsKit to take the impl from.

ImportResultsKit(ImportResultsKit const &in_kit)

The copy constructor creates a new ImportResultsKit object that contains the same settings as the source ImportResultsKit.

Parameters: in_kit – The source ImportResultsKit to copy.

inline virtual HPS::Type ObjectType() const

This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

Returns: The declared type of the object in question, which may differ from the true, underlying type.

bool operator!=(ImportResultsKit const &in_kit) const

Check if the source ImportResultsKit is not equivalent to this ImportResultsKit.

Parameters: in_kit – The source ImportResultsKit to compare to this ImportResultsKit.
Returns: true if the objects are not equivalent, false otherwise.

ImportResultsKit &operator=(ImportResultsKit &&in_that)

The move assignment operator transfers the underlying impl of the rvalue reference to this ImportResultsKit thereby avoiding a copy.

Parameters: in_that – An rvalue reference to an ImportResultsKit to take the impl from.
Returns: A reference to this ImportResultsKit.

ImportResultsKit &operator=(ImportResultsKit const &in_kit)

Copies the source ImportResultsKit into this ImportResultsKit.

Parameters: in_kit – The source ImportResultsKit to copy.
Returns: A reference to this ImportResultsKit.

bool operator==(ImportResultsKit const &in_kit) const

Check if the source ImportResultsKit is equivalent to this ImportResultsKit.

Parameters: in_kit – The source ImportResultsKit to compare to this ImportResultsKit.
Returns: true if the objects are equivalent, false otherwise.

void Set(ImportResultsKit const &in_kit)

Copies the source ImportResultsKit into this ImportResultsKit.

Parameters: in_kit – The source ImportResultsKit to copy.

ImportResultsKit &SetAlternateCameras(UTF8Array const &in_names, CameraKitArray &in_cameras)

Sets the alternate named cameras that were present in the HSF file. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Parameters

in_names – The names of the cameras in the HSF file.
in_cameras – The cameras in the HSF file.

Returns

A reference to this ImportResultsKit.

ImportResultsKit &SetAlternateRoot(SegmentKey const &in_segment)

Sets the segment which was used when the import file tried to access segments above the root segment. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Parameters: in_segment – Segment that was used when the import file tried to access segments above the root segment during import.
Returns: A reference to this ImportResultsKit.

ImportResultsKit &SetDefaultCamera(CameraKit const &in_camera)

Sets the “default” camera for this ImportResultsKit. This is generally only used during a Stream Import to record the default camera read from the Stream file.

Parameters: in_camera – The “default” named camera from the HSF file.
Returns: A reference to this ImportResultsKit.

ImportResultsKit &SetPortfolio(PortfolioKey const &in_portfolio)

Sets the portfolio which was used for any definitions that had to be created during import. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Parameters: in_portfolio – Portfolio that was used for any definitions that had to be created during import.
Returns: A reference to this ImportResultsKit.

ImportResultsKit &SetSegment(SegmentKey const &in_segment)

Sets the root segment which the HSF data was imported into. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Parameters: in_segment – Segment the HSF data was imported into.
Returns: A reference to this ImportResultsKit.

void Show(ImportResultsKit &out_kit) const

Copies this ImportResultsKit into the given ImportResultsKit.

Parameters: out_kit – The ImportResultsKit to populate with the contents of this ImportResultsKit.

bool ShowAlternateCameras(UTF8Array &out_names, CameraKitArray &out_cameras) const

Shows the alternate named cameras that were present in the HSF file. This includes all cameras other than “default”.

Parameters

out_names – The names of the cameras in the HSF file.
out_cameras – The cameras in the HSF file.

Returns

true if alternate cameras were specified, false otherwise.

bool ShowAlternateRoot(SegmentKey &out_segment) const

Shows the segment which was used when the import file tried to access segments above the root segment. This was either the alternate root specified by the user in the ImportOptionsKit passed to Stream::File::Import, or the root segment that was created for this purpose during import.

Parameters: out_segment – Segment that was used when the import file tried to access segments above the root segment.
Returns: true if an alternate root segment was specified, false otherwise.

bool ShowDefaultCamera(CameraKit &out_camera) const

Shows the “default” camera for this ImportOptionsKit. The “default” camera is set during a Stream Import. There can only be a single default camera in a Stream file.

Parameters: out_camera – The “default” camera from the Stream file.
Returns: true if a default camera was specified, false otherwise.

bool ShowPortfolio(PortfolioKey &out_portfolio) const

Shows the portfolio which was used for any definitions that had to be created during import. This was either the portfolio specified by the user in the ImportOptionsKit passed to Stream::File::Import, or the portfolio that was created for this purpose during import.

Parameters: out_portfolio – Portfolio that was used for any definitions that had to be created during import.
Returns: true if a portfolio was specified, false otherwise.

bool ShowSegment(SegmentKey &out_segment) const

Shows the root segment which the HSF data was imported into. This was either the root segment specified by the user in the ImportOptionsKit passed to Stream::File::Import, or the root segment that was created for this purpose during import.

Parameters: out_segment – Segment the HSF data was imported into.
Returns: true if a root segment was specified, false otherwise.

ImportResultsKit &UnsetAlternateCameras()

Removes the alternate named cameras that were present in the HSF file. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Returns: A reference to this ImportResultsKit.

ImportResultsKit &UnsetAlternateRoot()

Removes the segment which was used when the import file tried to access segments above the root segment. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Returns: A reference to this ImportResultsKit.

ImportResultsKit &UnsetDefaultCamera()

Removes the “default” camera from this ImportResultsKit. This is generally only used for ImportResultsKits that are generated from a Stream import.

Returns: A reference to this ImportResultsKit.

ImportResultsKit &UnsetEverything()

Removes all settings from this ImportResultsKit.

Returns: A reference to this ImportResultsKit.

ImportResultsKit &UnsetPortfolio()

Removes the portfolio which was used for any definitions that had to be created during import. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Returns: A reference to this ImportResultsKit.

ImportResultsKit &UnsetSegment()

Removes the root segment which the HSF data was imported into. This is really only used when generating an ImportResultsKit which is being returned to a user following an HSF import.

Returns: A reference to this ImportResultsKit.

virtual ~ImportResultsKit()

Public Static Attributes

static const HPS::Type staticType = HPS::Type::StreamImportResultsKit

class IncludeSegmentImportEvent : public HPS::Stream::ImportEvent 

Public Functions

IncludeSegmentImportEvent()

IncludeSegmentImportEvent(HPS::SegmentKey &in_segment_key, HPS::SegmentKey &in_reference_segment_key, HPS::ConditionalExpression &in_conditional, HPS::AttributeLockTypeArray &&in_filter_types)

virtual ~IncludeSegmentImportEvent()

Public Members

HPS::ConditionalExpression &condition

HPS::AttributeLockTypeArray filter_types

HPS::SegmentKey &reference_segment_key

HPS::SegmentKey &segment_key

class InfiniteLineImportEvent : public HPS::Stream::ImportEvent 

Public Functions

InfiniteLineImportEvent()

InfiniteLineImportEvent(HPS::SegmentKey &in_segment_key, HPS::InfiniteLineKit &in_infinite_line_kit)

virtual ~InfiniteLineImportEvent()

Public Members

HPS::InfiniteLineKit &infinite_line_kit

HPS::SegmentKey &segment_key

class LegacyShaderDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

LegacyShaderDefinitionImportEvent()

LegacyShaderDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::LegacyShaderKit &in_shader_kit)

virtual ~LegacyShaderDefinitionImportEvent()

Public Members

UTF8 name

HPS::PortfolioKey &portfolio_key

HPS::LegacyShaderKit &shader_kit

class LightingAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

LightingAttributeImportEvent()

LightingAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::LightingAttributeKit &in_lighting_attribute_kit)

virtual ~LightingAttributeImportEvent()

Public Members

HPS::LightingAttributeKit &lighting_attribute_kit

HPS::SegmentKey &segment_key

class LineAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

LineAttributeImportEvent()

LineAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::LineAttributeKit &in_line_attribute_kit)

virtual ~LineAttributeImportEvent()

Public Members

HPS::LineAttributeKit &line_attribute_kit

HPS::SegmentKey &segment_key

class LineImportEvent : public HPS::Stream::ImportEvent 

Public Functions

LineImportEvent()

LineImportEvent(HPS::SegmentKey &in_segment_key, HPS::LineKit &in_line_kit)

virtual ~LineImportEvent()

Public Members

HPS::LineKit &line_kit

HPS::SegmentKey &segment_key

class LinePatternDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

LinePatternDefinitionImportEvent()

LinePatternDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::LinePatternKit &in_line_pattern_kit)

virtual ~LinePatternDefinitionImportEvent()

Public Members

HPS::LinePatternKit &line_pattern_kit

UTF8 name

HPS::PortfolioKey &portfolio_key

class MarkerAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MarkerAttributeImportEvent()

MarkerAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::MarkerAttributeKit &in_marker_attribute_kit)

virtual ~MarkerAttributeImportEvent()

Public Members

HPS::MarkerAttributeKit &marker_attribute_kit

HPS::SegmentKey &segment_key

class MarkerImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MarkerImportEvent()

MarkerImportEvent(HPS::SegmentKey &in_segment_key, HPS::MarkerKit &in_marker_kit)

virtual ~MarkerImportEvent()

Public Members

HPS::MarkerKit &marker_kit

HPS::SegmentKey &segment_key

class MaterialImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MaterialImportEvent()

MaterialImportEvent(HPS::Key &in_key, HPS::MaterialMappingKit &in_material_mapping_kit)

virtual ~MaterialImportEvent()

Public Members

HPS::Key &key

HPS::MaterialMappingKit &material_mapping_kit

class MaterialPaletteDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MaterialPaletteDefinitionImportEvent()

MaterialPaletteDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::MaterialKitArray &in_material_mapping_kit_array)

virtual ~MaterialPaletteDefinitionImportEvent()

Public Members

HPS::MaterialKitArray &material_mapping_kit_array

HPS::UTF8 name

HPS::PortfolioKey &portfolio_key

class MaterialPaletteImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MaterialPaletteImportEvent()

MaterialPaletteImportEvent(HPS::SegmentKey &in_segment_key, char const *in_name)

virtual ~MaterialPaletteImportEvent()

Public Members

HPS::UTF8 name

HPS::SegmentKey &segment_key

class MatrixImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MatrixImportEvent()

MatrixImportEvent(HPS::Key &in_key, HPS::MatrixKit &in_matrix_kit)

virtual ~MatrixImportEvent()

Public Members

HPS::Key &key

HPS::MatrixKit &matrix_kit

class MeshImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MeshImportEvent()

MeshImportEvent(HPS::SegmentKey &in_segment_key, HPS::MeshKit &in_mesh_kit)

virtual ~MeshImportEvent()

Public Members

HPS::MeshKit &mesh_kit

HPS::SegmentKey &segment_key

class MeshInstanceImportEvent : public HPS::Stream::ImportEvent 

Public Functions

MeshInstanceImportEvent()

MeshInstanceImportEvent(HPS::SegmentKey &in_segment_key, HPS::MeshKit &in_mesh_kit, HPS::MatrixKit &in_modelling_matrix)

virtual ~MeshInstanceImportEvent()

Public Members

HPS::MeshKit &mesh_kit

HPS::MatrixKit &modelling_matrix

HPS::SegmentKey &segment_key

class NamedStyleDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

NamedStyleDefinitionImportEvent()

NamedStyleDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::SegmentKey &in_style_key)

virtual ~NamedStyleDefinitionImportEvent()

Public Members

HPS::UTF8 name

HPS::PortfolioKey &portfolio_key

HPS::SegmentKey &style_key

class NamedStyleImportEvent : public HPS::Stream::ImportEvent 

Public Functions

NamedStyleImportEvent()

NamedStyleImportEvent(HPS::SegmentKey &in_segment_key, char const *in_name, HPS::ConditionalExpression &in_conditional, HPS::AttributeLockTypeArray &&in_filter_types)

virtual ~NamedStyleImportEvent()

Public Members

HPS::ConditionalExpression &condition

HPS::AttributeLockTypeArray filter_types

HPS::UTF8 name

HPS::SegmentKey &segment_key

class NonDBUserDataImportEvent : public HPS::Stream::ImportEvent 

This class indicates non-database user data is being imported by Stream.

Public Functions

inline NonDBUserDataImportEvent()

NonDBUserDataImportEvent(size_t in_count, HPS::byte const in_data[])

virtual ~NonDBUserDataImportEvent()

Public Members

HPS::ByteArray user_data: An HPS::ByteArray of user data that is not associated with the database.

class NURBSCurveImportEvent : public HPS::Stream::ImportEvent 

Public Functions

NURBSCurveImportEvent()

NURBSCurveImportEvent(HPS::SegmentKey &in_segment_key, HPS::NURBSCurveKit &in_nurbs_curve_kit)

virtual ~NURBSCurveImportEvent()

Public Members

HPS::NURBSCurveKit &nurbs_curve_kit

HPS::SegmentKey &segment_key

class NURBSSurfaceAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

NURBSSurfaceAttributeImportEvent()

NURBSSurfaceAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::NURBSSurfaceAttributeKit &in_nurbs_surface_attribute_kit)

virtual ~NURBSSurfaceAttributeImportEvent()

Public Members

HPS::NURBSSurfaceAttributeKit &nurbs_surface_attribute_kit

HPS::SegmentKey &segment_key

class NURBSSurfaceImportEvent : public HPS::Stream::ImportEvent 

Public Functions

NURBSSurfaceImportEvent()

NURBSSurfaceImportEvent(HPS::SegmentKey &in_segment_key, HPS::NURBSSurfaceKit &in_nurbs_surface_kit)

virtual ~NURBSSurfaceImportEvent()

Public Members

HPS::NURBSSurfaceKit &nurbs_surface_kit

HPS::SegmentKey &segment_key

class PerformanceImportEvent : public HPS::Stream::ImportEvent 

Public Functions

PerformanceImportEvent()

PerformanceImportEvent(HPS::SegmentKey &in_segment_key, HPS::PerformanceKit &in_performance_kit)

virtual ~PerformanceImportEvent()

Public Members

HPS::PerformanceKit &performance_kit

HPS::SegmentKey &segment_key

class PolygonImportEvent : public HPS::Stream::ImportEvent 

Public Functions

PolygonImportEvent()

PolygonImportEvent(HPS::SegmentKey &in_segment_key, HPS::PolygonKit &in_polygon_kit)

virtual ~PolygonImportEvent()

Public Members

HPS::PolygonKit &polygon_kit

HPS::SegmentKey &segment_key

class PriorityImportEvent : public HPS::Stream::ImportEvent 

Public Functions

PriorityImportEvent()

PriorityImportEvent(HPS::Key &in_key, int in_priority)

virtual ~PriorityImportEvent()

Public Members

HPS::Key &key

int priority

class ReferenceGeometryImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ReferenceGeometryImportEvent()

ReferenceGeometryImportEvent(HPS::SegmentKey &in_segment_key, HPS::Key &in_reference_geometry_key, HPS::ConditionalExpression &in_conditional)

virtual ~ReferenceGeometryImportEvent()

Public Members

HPS::ConditionalExpression &condition

HPS::Key &reference_geometry_key

HPS::SegmentKey &segment_key

class SegmentExportEvent : public HPS::Stream::ExportEvent 

The SegmentExportEvent class indicates that a segment is about to be exported by Stream.

Public Functions

SegmentExportEvent()

SegmentExportEvent(HPS::SegmentKey &in_segment_key)

virtual ~SegmentExportEvent()

Public Members

HPS::SegmentKey &segment_key: A SegmentKey that is about to be exported by stream.

class SegmentImportEvent : public HPS::Stream::ImportEvent 

Public Functions

SegmentImportEvent()

SegmentImportEvent(HPS::SegmentKey &in_segment_key, char const *in_name)

virtual ~SegmentImportEvent()

Public Members

HPS::UTF8 name

HPS::SegmentKey &segment_key

class SelectabilityImportEvent : public HPS::Stream::ImportEvent 

Public Functions

SelectabilityImportEvent()

SelectabilityImportEvent(HPS::SegmentKey &in_segment_key, HPS::SelectabilityKit &in_selectability_kit)

virtual ~SelectabilityImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::SelectabilityKit &selectability_kit

class ShapeDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ShapeDefinitionImportEvent()

ShapeDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::ShapeKit &in_shape_kit)

virtual ~ShapeDefinitionImportEvent()

Public Members

UTF8 name

HPS::PortfolioKey &portfolio_key

HPS::ShapeKit &shape_kit

class ShellImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ShellImportEvent()

ShellImportEvent(HPS::SegmentKey &in_segment_key, HPS::ShellKit &in_shell_kit)

virtual ~ShellImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::ShellKit &shell_kit

class ShellInstanceImportEvent : public HPS::Stream::ImportEvent 

Public Functions

ShellInstanceImportEvent()

ShellInstanceImportEvent(HPS::SegmentKey &in_segment_key, HPS::ShellKit &in_shell_kit, HPS::MatrixKit &in_modelling_matrix)

virtual ~ShellInstanceImportEvent()

Public Members

HPS::MatrixKit &modelling_matrix

HPS::SegmentKey &segment_key

HPS::ShellKit &shell_kit

class SphereAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

SphereAttributeImportEvent()

SphereAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::SphereAttributeKit &in_sphere_attribute_kit)

virtual ~SphereAttributeImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::SphereAttributeKit &sphere_attribute_kit

class SphereImportEvent : public HPS::Stream::ImportEvent 

Public Functions

SphereImportEvent()

SphereImportEvent(HPS::SegmentKey &in_segment_key, HPS::SphereKit &in_sphere_kit)

virtual ~SphereImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::SphereKit &sphere_kit

class SpotlightImportEvent : public HPS::Stream::ImportEvent 

Public Functions

SpotlightImportEvent()

SpotlightImportEvent(HPS::SegmentKey &in_segment_key, HPS::SpotlightKit &in_spotlight_kit)

virtual ~SpotlightImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::SpotlightKit &spotlight_kit

class StyleSegmentImportEvent : public HPS::Stream::ImportEvent 

Public Functions

StyleSegmentImportEvent()

StyleSegmentImportEvent(HPS::SegmentKey &in_segment_key, HPS::SegmentKey &in_style_segment_key, HPS::ConditionalExpression &in_conditional, HPS::AttributeLockTypeArray &&in_filter_types)

virtual ~StyleSegmentImportEvent()

Public Members

HPS::ConditionalExpression &condition

HPS::AttributeLockTypeArray filter_types

HPS::SegmentKey &segment_key

HPS::SegmentKey &style_segment_key

class SubwindowImportEvent : public HPS::Stream::ImportEvent 

Public Functions

SubwindowImportEvent()

SubwindowImportEvent(HPS::SegmentKey &in_segment_key, HPS::SubwindowKit &in_subwindow_kit)

virtual ~SubwindowImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::SubwindowKit &subwindow_kit

class TextAttributeImportEvent : public HPS::Stream::ImportEvent 

Public Functions

TextAttributeImportEvent()

TextAttributeImportEvent(HPS::SegmentKey &in_segment_key, HPS::TextAttributeKit &in_text_attribute_kit)

TextAttributeImportEvent(HPS::TextKey &in_text_key, HPS::TextAttributeKit &in_text_attribute_kit)

virtual ~TextAttributeImportEvent()

Public Members

HPS::Key &key

HPS::TextAttributeKit &text_attribute_kit

class TextImportEvent : public HPS::Stream::ImportEvent 

Public Functions

TextImportEvent()

TextImportEvent(HPS::SegmentKey &in_segment_key, HPS::TextKit &in_text_kit)

virtual ~TextImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::TextKit &text_kit

class TextureDefinitionImportEvent : public HPS::Stream::ImportEvent 

Public Functions

TextureDefinitionImportEvent()

TextureDefinitionImportEvent(HPS::PortfolioKey &in_portfolio_key, char const *in_name, HPS::ImageDefinition &in_source_definition, HPS::TextureOptionsKit &in_texture_kit)

virtual ~TextureDefinitionImportEvent()

Public Members

UTF8 name

HPS::PortfolioKey &portfolio_key

HPS::ImageDefinition &source_definition

HPS::TextureOptionsKit &texture_kit

class Toolkit : public HPS::Object 

The Toolkit class is the primary support class which manages streaming of HSF data.

Public Functions

inline virtual HPS::Type ObjectType() const

This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

Returns: The declared type of the object in question, which may differ from the true, underlying type.

Toolkit &operator=(Toolkit &&in_toolkit)

The move assignment operator transfers the underlying impl of the rvalue reference to this Toolkit thereby avoiding a copy.

Parameters: in_toolkit – An rvalue reference to a Toolkit to take the impl from.
Returns: A reference to this Toolkit.

Toolkit &operator=(Toolkit const &in_toolkit)

Associate this Toolkit with the same underlying impl as the source Toolkit.

Parameters: in_toolkit – The source Toolkit for the assignment.
Returns: A reference to this ShellKey.

ImportNotifier ParseBuffers(ByteArrayArray const &in_hsf_buffers, ImportOptionsKit const &in_options)

virtual void Restart(): Restarts the Toolkit object so that it can be reused for importing or exporting.

Toolkit(): The Default constructor creates an empty Toolkit object.

Toolkit(Toolkit &&in_toolkit)

The move constructor creates a Toolkit by transferring the underlying impl of the rvalue reference to this Toolkit thereby avoiding a copy and allocation.

Parameters: in_toolkit – An rvalue reference to a Toolkit to take the impl from.

Toolkit(Toolkit const &in_toolkit)

This constructor creates an Toolkit object that shares the underlying smart-pointer of the source Toolkit.

Parameters: in_toolkit – The source Toolkit to copy.

Public Static Attributes

static const HPS::Type staticType = HPS::Type::StreamToolkit

class TransformMaskImportEvent : public HPS::Stream::ImportEvent 

Public Functions

TransformMaskImportEvent()

TransformMaskImportEvent(HPS::SegmentKey &in_segment_key, HPS::TransformMaskKit &in_transform_mask_kit)

virtual ~TransformMaskImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::TransformMaskKit &transform_mask_kit

class TransparencyImportEvent : public HPS::Stream::ImportEvent 

Public Functions

TransparencyImportEvent()

TransparencyImportEvent(HPS::SegmentKey &in_segment_key, HPS::TransparencyKit &in_transparency_kit)

virtual ~TransparencyImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::TransparencyKit &transparency_kit

class UserDataImportEvent : public HPS::Stream::ImportEvent 

This class indicates that user data contained within the database (associated with either a segment or geometry key) is being imported by Stream.

Public Functions

UserDataImportEvent()

UserDataImportEvent(HPS::Key &in_key, intptr_t in_index, size_t in_count, HPS::byte const in_data[])

virtual ~UserDataImportEvent()

Public Members

intptr_t index

HPS::Key key

HPS::ByteArray user_data: An HPS::ByteArray of user data that is associated with the database.

class VisibilityImportEvent : public HPS::Stream::ImportEvent 

Public Functions

VisibilityImportEvent()

VisibilityImportEvent(HPS::SegmentKey &in_segment_key, HPS::VisibilityKit &in_visibility_kit)

virtual ~VisibilityImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::VisibilityKit &visibility_kit

class VisualEffectsImportEvent : public HPS::Stream::ImportEvent 

Public Functions

VisualEffectsImportEvent()

VisualEffectsImportEvent(HPS::SegmentKey &in_segment_key, HPS::VisualEffectsKit &in_visual_effects_kit)

virtual ~VisualEffectsImportEvent()

Public Members

HPS::SegmentKey &segment_key

HPS::VisualEffectsKit &visual_effects_kit