Alembic::Abc

The Abc library is the human-friendly data-manipulation library in Alembic, and provides object-based wrappers around the AbcCoreAbstract layer.

As well, and in contrast with AbcCoreAbstract, the Abc layer provides for interpretation of the data manipulated with it, e.g., rather than a pointer to a contiguous block of 1024 bytes at the AbcCoreAbstract layer, at the Abc layer those bytes can be thought of as a value instance of Imath objects.

class Argument

Public Functions

Argument()
Argument(ErrorHandler::Policy iPolicy)
Argument(Alembic::Util::uint32_t iTsIndex)
Argument(const AbcA::MetaData &iMetaData)
Argument(const AbcA::TimeSamplingPtr &iTsPtr)
Argument(SchemaInterpMatching iMatch)
void setInto(Arguments &iArgs) const

Private Types

enum ArgumentWhichFlag

Values:

kArgumentNone
kArgumentErrorHandlerPolicy
kArgumentTimeSamplingIndex
kArgumentMetaData
kArgumentTimeSamplingPtr
kArgumentSchemaInterpMatching

Private Functions

const Argument &operator=(const Argument&)
class Arguments

Public Functions

Arguments(ErrorHandler::Policy iPolicy = ErrorHandler::kThrowPolicy, const AbcA::MetaData &iMetaData = AbcA::MetaData(), AbcA::TimeSamplingPtr iTimeSampling = AbcA::TimeSamplingPtr(), uint32_t iTimeIndex = 0, SchemaInterpMatching iMatch = kNoMatching)
void operator()(const uint32_t &iTimeSamplingIndex)
void operator()(const ErrorHandler::Policy &iPolicy)
void operator()(const AbcA::MetaData &iMetaData)
void operator()(const AbcA::TimeSamplingPtr &iTimeSampling)
void operator()(const SchemaInterpMatching &iMatching)
ErrorHandler::Policy getErrorHandlerPolicy() const
const AbcA::MetaData &getMetaData() const
AbcA::TimeSamplingPtr getTimeSampling() const
uint32_t getTimeSamplingIndex() const
SchemaInterpMatching getSchemaInterpMatching() const

Private Members

ErrorHandler::Policy m_errorHandlerPolicy
AbcA::MetaData m_metaData
AbcA::TimeSamplingPtr m_timeSampling
uint32_t m_timeSamplingIndex
SchemaInterpMatching m_matching
union ArgumentVariant

Public Functions

ArgumentVariant()
ArgumentVariant(ErrorHandler::Policy iPolicy)
ArgumentVariant(Alembic::Util::uint32_t iTsIndex)
ArgumentVariant(const AbcA::MetaData *iMetaData)
ArgumentVariant(const AbcA::TimeSamplingPtr *iTsPtr)
ArgumentVariant(SchemaInterpMatching iMatch)

Public Members

ErrorHandler::Policy policy
Alembic::Util::uint32_t timeSamplingIndex
const AbcA::MetaData *metaData
const AbcA::TimeSamplingPtr *timeSamplingPtr
SchemaInterpMatching schemaInterpMatching
class Base

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::IArchive, Alembic::Abc::ALEMBIC_VERSION_NS::IBasePropertyT< PROP_PTR >, Alembic::Abc::ALEMBIC_VERSION_NS::IObject, Alembic::Abc::ALEMBIC_VERSION_NS::OArchive, Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT< PROP_PTR >, Alembic::Abc::ALEMBIC_VERSION_NS::OObject, Alembic::Abc::ALEMBIC_VERSION_NS::IBasePropertyT< AbcA::ArrayPropertyReaderPtr >, Alembic::Abc::ALEMBIC_VERSION_NS::IBasePropertyT< AbcA::CompoundPropertyReaderPtr >, Alembic::Abc::ALEMBIC_VERSION_NS::IBasePropertyT< AbcA::ScalarPropertyReaderPtr >, Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT< AbcA::ArrayPropertyWriterPtr >, Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT< AbcA::CompoundPropertyWriterPtr >, Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT< AbcA::ScalarPropertyWriterPtr >

Public Functions

ErrorHandler &getErrorHandler() const
ErrorHandler::Policy getErrorHandlerPolicy() const

Protected Functions

Base()
Base(ErrorHandler::Policy iPolicy)
Base(const Base &iCopy)
Base &operator=(const Base &iCopy)
bool valid() const
void reset()

Private Members

ErrorHandler m_errorHandler
class Context

Public Functions

Context(ErrorHandler &iEhnd, const std::string &iCtxMsg)
void operator()(std::exception &iExc)
void operator()(const std::string &iMsg)
void operator()(UnknownExceptionFlag iUef)

Private Functions

const Context &operator=(const Context&)

Private Members

ErrorHandler &m_handler
std::string m_message
class ErrorHandler

Public Types

enum Policy

Values:

kQuietNoopPolicy
kNoisyNoopPolicy
kThrowPolicy
enum UnknownExceptionFlag

Values:

kUnknownException

Public Functions

ErrorHandler()
ErrorHandler(Policy iPolicy)
void operator()(std::exception &iExc, const std::string &iCtx = "")

Default copy constructor Default assignment operator

void operator()(const std::string &iErrMsg, const std::string &iCtx = "")
void operator()(UnknownExceptionFlag iUef, const std::string &iCtx = "")
Policy getPolicy() const
void setPolicy(Policy iPolicy)
const std::string getErrorLog() const
bool valid() const
void clear()

Private Functions

void handleIt(const std::string &iErr)

Private Members

Policy m_policy
std::string m_errorLog
class IArchive

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::Base

Public Types

typedef IArchive this_type

By convention, we always define “this_type” in every Abc class. This convention is relied upon by the unspecified-bool-type cast

Public Functions

IArchive()

The default constructor creates an empty IArchive function set. ...

template <class ARCHIVE_CTOR>
IArchive(ARCHIVE_CTOR iCtor, const std::string &iFileName, ErrorHandler::Policy iPolicy = ErrorHandler::kThrowPolicy, AbcA::ReadArraySampleCachePtr iCachePtr = AbcA::ReadArraySampleCachePtr())

Parameters
  • iCtor -

    We need to pass in a constructor which provides an explicit link to the concrete implementation of AbcCoreAbstract that we’re using.

  • iFileName -

    The file name.

The explicit constructor opens an existing archive with the given file name. Additional arguments that may be passed are the error handler policy and a pointer to a cache instance. By default, an archive-local cache will be created.

IArchive(AbcA::ArchiveReaderPtr iPtr, WrapExistingFlag, ErrorHandler::Policy iPolicy = ErrorHandler::kThrowPolicy)

Parameters
  • iPtr -

    The pointer ...

  • iPolicy -

    Optional error handling policy ...

This attaches an IArchive wrapper around an existing ArchiveReaderPtr, with an optional error handling policy.

~IArchive()

Destructor ...

std::string getName() const

Default copy constructor Default assignment operator Returns the file name. It is an error to do so with an invalid object.

IObject getTop()

This returns the single top-level IObject that exists automatically as part of the archive.

AbcA::ReadArraySampleCachePtr getReadArraySampleCachePtr()

Get the read array sample cache. It may be a NULL pointer. Caches can be shared amongst separate archives, and caching will is disabled if a NULL cache is returned here.

void setReadArraySampleCachePtr(AbcA::ReadArraySampleCachePtr iPtr)

Set the read array sample cache. It may also be a NULL pointer. Caches can be shared amongst separate archives, and caching will be disabled if a NULL cache is passed here.

AbcA::ArchiveReaderPtr getPtr()

getPtr, as usual, returns a shared ptr to the underlying AbcCoreAbstract object, in this case the ArchiveReaderPtr.

void reset()

Reset returns this function et to an empty, default state.

AbcA::TimeSamplingPtr getTimeSampling(uint32_t iIndex)

Returns the TimeSampling at a given index.

uint32_t getNumTimeSamplings()

Returns the total number of TimeSamplingPtrs in the Archive TimeSampling pool.

index_t getMaxNumSamplesForTimeSamplingIndex(uint32_t iIndex)

Returns the maximum number of samples written for the TimeSampling at the given index. If an illegal iIndex is specified, or a max number of samplings couldn’t be found for that iIndex (for older archives pre 1.1.3) INDEX_UNKNOWN will be returned.

bool valid() const

Valid returns whether this function set is valid.

int32_t getArchiveVersion()

Returns the Alembic library numeric version (see Foundation.h) of this archive file.

ALEMBIC_OPERATOR_BOOL(valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Private Members

AbcA::ArchiveReaderPtr m_archive
class IArrayProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::IBasePropertyT< AbcA::ArrayPropertyReaderPtr >

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::ITypedArrayProperty< TRAITS >

Public Types

typedef IArrayProperty this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

IArrayProperty()

The default constructor creates an empty IArrayProperty function set. ...

template <class OBJECT_PTR>
IArrayProperty(OBJECT_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This templated, explicit function creates a new array property reader. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to a CompoundPropertyReaderPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, to specify protocol matching policy, and that’s it.

IArrayProperty(AbcA::ArrayPropertyReaderPtr iPtr, WrapExistingFlag iWrapFlag, ErrorHandler::Policy iPolicy = ErrorHandler::kThrowPolicy)

Parameters
  • iPtr -

    The pointer ...

  • iWrapFlag -

    The flag indicating that wrapping is intended. Even though it’s nonambiguous here, we use it anyway for readability

  • iPolicy -

    Optional error handling policy ...

This attaches an IArrayProperty wrapper around an existing ArrayPropertyReaderPtr, with an optional error handling policy.

~IArrayProperty()

Default copy constructor used Default assignment operator used. Destructor ...

size_t getNumSamples() const

Return the number of samples contained in the property. This can be any number, including zero. This returns the number of samples that were written, independently of whether or not they were constant.

bool isConstant() const

Ask if we’re constant - no change in value amongst samples, regardless of the time sampling.

bool isScalarLike() const

Ask if we are like a scalar - we have 1 and only 1 DataType per sample.

AbcA::TimeSamplingPtr getTimeSampling() const

Time information.

void get(AbcA::ArraySamplePtr &oSample, const ISampleSelector &iSS = ISampleSelector ()) const

Get a sample into the address of a datum. ...

void getAs(void *oSample, AbcA::PlainOldDataType iPod, const ISampleSelector &iSS = ISampleSelector ())

Get a sample into the address of a datum as a particular POD type.

void getAs(void *oSample, const ISampleSelector &iSS = ISampleSelector ())

Get a sample into the address of a datum as the POD type of this array property.

bool getKey(AbcA::ArraySampleKey &oKey, const ISampleSelector &iSS = ISampleSelector ()) const

Get a key from an address of a datum. ...

void getDimensions(Util::Dimensions &oDim, const ISampleSelector &iSS = ISampleSelector ()) const

Get the dimensions of the datum.

ICompoundProperty getParent() const

Return the parent compound property, handily wrapped in a ICompoundProperty wrapper.

template <class CPROP_PTR>
IArrayProperty(CPROP_PTR iParentProp, const std::string &iName, const Argument &iArg0, const Argument &iArg1)

Private Functions

void init(AbcA::CompoundPropertyReaderPtr iParentObject, const std::string &iName, ErrorHandler::Policy iParentPolicy, const Argument &iArg0, const Argument &iArg1)
template <class PROP_PTR>
class IBasePropertyT
#include <IBaseProperty.h>

Most of the functionality of properties (getting information about the properties and so on) is common to all property types, so we create a base class to contain all that functionality. This is purely a base class for other properties to derive from, it will never be created directly.

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::Base

Public Functions

const AbcA::PropertyHeader &getHeader() const

Default copy constructor used Default assignment operator used. Return the property’s header. ...

const std::string &getName() const

This function returns the property’s local name ...

AbcA::PropertyType getPropertyType() const

This function returns the property’s type ...

bool isScalar() const

Convenience to return whether the property is scalar. Same as getPropertyType() == kScalarProperty

bool isArray() const

Convenience to return whether the property is array. Same as getPropertyType() == kArrayProperty

bool isCompound() const

Convenience to return whether the property is compound. Same as getPropertyType() == kCompoundProperty

bool isSimple() const

Convenience to return whether the property is simple (non-compound) Same as getPropertyType() != kCompoundProperty

const AbcA::MetaData &getMetaData() const

All properties have MetaData. This just returns the MetaData portion of the header that was used in creation.

const AbcA::DataType &getDataType() const

Non-compound properties have a DataType. It is an error to call this function for CompoundProperties, and an exception will be thrown. This is a convenience function which just returns the DataType from the header that was used in creation.

AbcA::TimeSamplingPtr getTimeSampling() const

Non-compound properties have a TimeSamplingPtr. It is an error to call this function for CompoundProperties, and an exception will be thrown. This is a convenience function which just returns the TimeSamplingPtr from the header that was used in creation.

IObject getObject() const

This function returns the property’s object, handily wrapped in an IObject wrapper.

PROP_PTR getPtr() const

Can’t wrap OCompoundProperty getParent(); getPtr, as usual, returns a shared ptr to the underlying AbcCoreAbstract object, in this case the PROP_PTR.

void reset()

Reset returns this function set to an empty, default state.

bool valid() const

Valid returns whether this function set is valid.

ALEMBIC_OPERATOR_BOOL(valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Protected Types

typedef IBasePropertyT<PROP_PTR> this_type
typedef IBasePropertyT<PROP_PTR> operator_bool_base_type

Protected Functions

IBasePropertyT()

The default constructor creates an empty IBasePropertyT function set. ...

IBasePropertyT(PROP_PTR iPtr, WrapExistingFlag iWrapFlag, ErrorHandler::Policy iPolicy)

Parameters
  • iPtr -

    The pointer ...

  • iWrapFlag -

    The flag indicating that wrapping is intended. Even though it’s nonambiguous here, we use it anyway for readability

  • iPolicy -

    Optional error handling policy ...

This attaches an IBasePropertyT wrapper around an existing PROP_PTR, with an optional error handling policy.

Protected Attributes

PROP_PTR m_property
class ICompoundProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::IBasePropertyT< AbcA::CompoundPropertyReaderPtr >

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::ISchema< INFO >

Public Types

typedef ICompoundProperty this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

ICompoundProperty()

The default constructor creates an empty ICompoundProperty function set. ...

template <class CPROP_PTR>
ICompoundProperty(CPROP_PTR iParentProp, const std::string &iName, const Argument &iArg0 = Argument ())

This templated, explicit function creates a new compound property reader. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to an CompoundPropertyReaderPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy

template <class CPROP_PTR>
ICompoundProperty(CPROP_PTR iThisObject, WrapExistingFlag iWrap, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This attaches an ICompoundProperty wrapper around an existing CompoundPropertyReaderPtr, with an optional error handling policy.

The extra argument is to support ISchema, which is publicly derived from ICompoundProperty (see ISchema.h).

template <class OBJECT_PTR>
ICompoundProperty(OBJECT_PTR iThisObject, TopFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This attaches an ICompoundProperty wrapper around the top properties of any object, with an optional error handling policy.

The extra argument is to support ISchema, which is publicly derived from ICompoundProperty (see ISchema.h).

~ICompoundProperty()

Default copy constructor used Default assignment operator used. Destructor ...

size_t getNumProperties() const

Returns the number of properties contained in this ICompoundProperty.

const AbcA::PropertyHeader &getPropertyHeader(size_t i) const

Return the header of a child property. Property is selected by index. This will throw an exception on out-of-range access.

const AbcA::PropertyHeader *getPropertyHeader(const std::string &iName) const

Return the header of a property name. This will return a NULL pointer if no header by that name is found.

ICompoundProperty getParent() const

There is no distinction between already added properties and created properties with an AbcA::CompoundPropertyReader, therefore we have no need to expose “getProperty”. Simply use the appropriate IScalarProperty, ICompoundProperty, or IArrayProperty wrappers. Return the parent compound property, handily wrapped in a ICompoundProperty wrapper.

Private Functions

void init(AbcA::CompoundPropertyReaderPtr iParentObject, const std::string &iName, ErrorHandler::Policy iParentPolicy, const Argument &iArg0)
class IObject

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::Base

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::ISchemaObject< SCHEMA >

Public Types

typedef IObject this_type

By convention, we always define “this_type” in every Abc class. This convention is relied upon by the unspecified-bool-type conversion.

typedef IObject operator_bool_base_type

Public Functions

IObject()

The default constructor creates an empty IObject function set. ...

template <class OBJECT_PTR>
IObject(OBJECT_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument ())

This templated, explicit function creates a new object reader. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to an AbcA::ObjectReaderPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy.

template <class OBJECT_PTR>
IObject(OBJECT_PTR iPtr, WrapExistingFlag, const Argument &iArg0 = Argument ())

This attaches an IObject wrapper around an existing ObjectReaderPtr, with an optional error handling policy.

template <class ARCHIVE_PTR>
IObject(ARCHIVE_PTR iPtr, TopFlag iFlag, const Argument &iArg0 = Argument ())

This attaches an IObject wrapper around the top object of an archive.

virtual ~IObject()

Default copy constructor used Default assignment operator used. Destructor ...

const AbcA::ObjectHeader &getHeader() const

All objects have a header, which contains all the MetaData that was specified upon their creation. This function returns a constant reference to that Header.

const std::string &getName() const

All objects have a name. This name is unique amongst their siblings Returned by reference, since it is guaranteed to exist and be unchanging. This is a convenience function which returns the header’s name.

const std::string &getFullName() const

The full name of an object is the complete path name all the way to the root object of the archive. It is guaranteed to be fully unique within the entire archive. This is a convenience function which returns the header’s full name.

const AbcA::MetaData &getMetaData() const

All objects have metadata. This metadata is identical to the Metadata of the top level compoundProperty “properties”. Because the metadata must exist and be initialized in order to bootstrap the object, it is guaranteed to exist and is returned by reference. This is a convenience function which returns the header’s MetaData.

IArchive getArchive() const

This function returns the object’s archive, handily wrapped in an IArchive wrapper.

IObject getParent() const

This function returns the object’s parent, handily wrapped in an IObject wrapper. If the object is the top level object, the IObject returned will be NULL.

size_t getNumChildren() const

This function returns the number of child objects that this object has.

const AbcA::ObjectHeader &getChildHeader(size_t i) const

This function returns the headers of each of the child objects that were written as children of this object.

const AbcA::ObjectHeader *getChildHeader(const std::string &iName) const

Return the header of an object by name. This will return a NULL pointer if no header by that name is found.

ICompoundProperty getProperties() const

This returns the single top-level CompoundPropertyReader that exists automatically as part of the object.

IObject getChild(size_t iChildIndex) const

This function returns an IObject constructed from the indexed object.

IObject getChild(const std::string &iChildName) const

This function returns an IObject wrapped constructed from the header referenced by the name. If the child of the given name does not exist, this will fail in the same way as if the equivalent constructor was called.

bool isInstanceRoot() const

-************************************************************************

-************************************************************************ Returns whether this object directly instances another object.

bool isInstanceDescendant() const

Returns whether this object has been arrived at via an instance, or if this object is an instance itself.

std::string instanceSourcePath()

If this object is an instance (isInstanceRoot), returns the source path that the instance points at. Otherwise and empty string is returned.

bool isChildInstance(size_t iChildIndex) const
bool isChildInstance(const std::string &iChildName) const
AbcA::ObjectReaderPtr getInstancePtr() const

Returns the original ObjectReaderPtr, if this object is an instance.

AbcA::ObjectReaderPtr getPtr() const

getPtr, as usual, returns a shared ptr to the underlying AbcCoreAbstract object, in this case the ObjectReaderPtr. If this object happens to be an instance, it points to the instance source ObjectReaderPtr

void reset()

Reset returns this function set to an empty, default state.

bool valid() const

Valid returns whether this function set is valid.

bool getPropertiesHash(Util::Digest &oDigest)

If an aggregated properties hash exists fill oDigest with it and return true, if it doesn’t exist return false

bool getChildrenHash(Util::Digest &oDigest)

If an aggregated child objects hash exists fill oDigest with it and return true, if it doesn’t exist return false

ALEMBIC_OPERATOR_BOOL(valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Public Members

AbcA::ObjectReaderPtr m_object

Private Functions

void init(AbcA::ObjectReaderPtr iParentObject, const std::string &iName, ErrorHandler::Policy iPolicy)
void initInstance()
void setInstancedFullName(const std::string &parentPath) const

Private Members

AbcA::ObjectReaderPtr m_instanceObject
std::string m_instancedFullName
class ISampleSelector

Public Types

enum TimeIndexType

Values:

kFloorIndex
kCeilIndex
kNearIndex

Public Functions

ISampleSelector()
ISampleSelector(index_t iReqIdx)
ISampleSelector(chrono_t iReqTime, TimeIndexType iReqIdxType = kNearIndex)
index_t getRequestedIndex() const
chrono_t getRequestedTime() const
TimeIndexType getRequestedTimeIndexType() const
index_t getIndex(const AbcA::TimeSamplingPtr &iTsmp, index_t iNumSamples) const

Private Members

index_t m_requestedIndex
chrono_t m_requestedTime
TimeIndexType m_requestedTimeIndexType
class IScalarProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::IBasePropertyT< AbcA::ScalarPropertyReaderPtr >

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::ITypedScalarProperty< TRAITS >

Public Types

typedef IScalarProperty this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

IScalarProperty()

The default constructor creates an empty IScalarProperty function set. ...

template <class OBJECT_PTR>
IScalarProperty(OBJECT_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument ())

This templated, explicit function creates a new scalar property reader. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to a CompoundPropertyReaderPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, and that’s it.

IScalarProperty(AbcA::ScalarPropertyReaderPtr iPtr, WrapExistingFlag iWrapFlag, const Argument &iArg0 = Argument ())

Parameters
  • iPtr -

    The pointer ...

  • iWrapFlag -

    The flag indicating that wrapping is intended. Even though it’s nonambiguous here, we use it anyway for readability

  • iArg0 -

    Optional error handling policy ...

This attaches an IScalarProperty wrapper around an existing ScalarPropertyReaderPtr, with an optional error handling policy.

~IScalarProperty()

Default copy constructor used Default assignment operator used. Destructor ...

size_t getNumSamples() const

Return the number of samples contained in the property. This can be any number, including zero. This returns the number of samples that were written, independently of whether or not they were constant.

bool isConstant() const

Ask if we’re constant - no change in value amongst samples, regardless of the time sampling.

AbcA::TimeSamplingPtr getTimeSampling() const

Time information. This will be valid regardless of TimeSamplingType or number of samples.

void get(void *oSample, const ISampleSelector &iSS = ISampleSelector ()) const

Get a sample into the address of a datum. ...

ICompoundProperty getParent() const

Return the parent compound property, handily wrapped in a ICompoundProperty wrapper.

template <class CPROP_PTR>
IScalarProperty(CPROP_PTR iParentProp, const std::string &iName, const Argument &iArg0)

Private Functions

void init(AbcA::CompoundPropertyReaderPtr iParentObject, const std::string &iName, ErrorHandler::Policy iParentPolicy, const Argument &iArg0)
template <class INFO>
class ISchema
#include <ISchema.h>

See Schema Notes in OSchema.h ... Usually used as a base class, but could also theoretically be used as a standalone

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::ICompoundProperty

Public Types

typedef INFO info_type
typedef ISchema<INFO> this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

ISchema()

The default constructor creates an empty ISchema function set.

template <class CPROP_PTR>
ISchema(CPROP_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Creates a new Compound Property Reader with the schema information added to the metadata. arguments count include error handling, strictness matching.

template <class CPROP_PTR>
ISchema(CPROP_PTR iParentObject, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Creates a new Compound Property Reader with the schema information and also the default name.

template <class CPROP_PTR>
ISchema(CPROP_PTR iProperty, WrapExistingFlag iFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Wrap an existing compound property, checking that it matches the schema title info, if strict matching has been selected. Arguments allow selection of error handling and matching strictness

virtual ~ISchema()

Default copy constructor used Default assignment operator used.

template <class COMPOUND_PTR>
ISchema(COMPOUND_PTR iProperty, WrapExistingFlag iFlag, const Argument &iArg0, const Argument &iArg1)

Public Static Functions

static const char *getSchemaTitle()

Return the schema title expected of this property. An empty title matches everything

static const char *getDefaultSchemaName()

Return the default name for instances of this schema. Often something like ”.geom”

static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this schema object

static bool matches(const AbcA::PropertyHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an object header) strictly matches the interpretation of this schema object, as well as the data type.

Private Functions

template <class CPROP_PTR>
void init(CPROP_PTR iParentObject, const std::string &iName, const Argument &iArg0, const Argument &iArg1)
template <class SCHEMA>
class ISchemaObject
#include <ISchemaObject.h>

An ISchemaObject is an object with a single schema. This is just a convenience class, really, but it also deals with setting up and validating metadata

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::IObject

Public Types

typedef SCHEMA schema_type
typedef ISchemaObject<SCHEMA> this_type

By convention, we always define “this_type” in every Abc class. This convention is relied upon by the unspecified-bool-type conversion.

Public Functions

ISchemaObject()

The default constructor creates an empty ISchemaObject function set. ...

template <class OBJECT_PTR>
ISchemaObject(OBJECT_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

The primary constructor creates an ISchemaObject as a child of the first argument, which is any Abc or AbcCoreAbstract (or other) object which can be intrusively cast to an ObjectReaderPtr.

template <class OBJECT_PTR>
ISchemaObject(OBJECT_PTR iThisObject, WrapExistingFlag iFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Wrap an existing schema object. ...

SCHEMA &getSchema()

Schemas are not necessarily cheap to copy, so we return by reference rather than by value.

const SCHEMA &getSchema() const
void reset()

Reset returns this function set to an empty, default state.

bool valid() const

Valid returns whether this function set is valid.

ALEMBIC_OVERRIDE_OPERATOR_BOOL(this_type::valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Public Static Functions

static std::string getSchemaObjTitle()

Our schema title contains the schema title of the underlying compound property, along with the default name of that compound property. So, for example - most AbcGeom types put their data in ”.geom”, so, “AbcGeom_PolyMesh_v1:.geom” Sometimes schema titles from underlying schemas are “”, but ours never are.

static const char *getSchemaTitle()
static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this schema object

static bool matches(const AbcA::ObjectHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an object header) strictly matches the interpretation of this schema object, as well as the data type.

Protected Attributes

SCHEMA m_schema
template <class TRAITS>
class ITypedArrayProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::IArrayProperty

Public Types

typedef TRAITS traits_type
typedef ITypedArrayProperty<TRAITS> this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

typedef TRAITS::value_type value_type
typedef TypedArraySample<TRAITS> sample_type
typedef shared_ptr<sample_type> sample_ptr_type

Public Functions

ITypedArrayProperty()

Default constructor ...

template <class COMPOUND_PTR>
ITypedArrayProperty(COMPOUND_PTR iParent, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This templated, explicit function creates a new typed array property reader. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to a CompoundPropertyReaderPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, to specify schema matching policy, and that’s it.

ITypedArrayProperty(AbcA::ArrayPropertyReaderPtr iProp, WrapExistingFlag iWrapFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Explicitly wrap an existing property It will check the data type and also verify the schema, if requested.

void get(sample_ptr_type &iVal, const ISampleSelector &iSS = ISampleSelector ()) const

Get the typed sample. ...

sample_ptr_type getValue(const ISampleSelector &iSS = ISampleSelector ()) const

Return the typed sample by value. ...

Public Static Functions

static const char *getInterpretation()

Return the interpretation expected of this property. An empty interpretation matches everything

static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this schema object

static bool matches(const AbcA::PropertyHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an object header) strictly matches the interpretation of this schema object

template <class TRAITS>
class ITypedScalarProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::IScalarProperty

Public Types

typedef TRAITS traits_type
typedef ITypedScalarProperty<TRAITS> this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

typedef TRAITS::value_type value_type

Public Functions

ITypedScalarProperty()

Default constructor ...

template <class COMPOUND_PTR>
ITypedScalarProperty(COMPOUND_PTR iParent, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This templated, explicit function creates a new typed scalar property reader. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to a CompoundPropertyReaderPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, to specify schema matching policy, and that’s it.

ITypedScalarProperty(AbcA::ScalarPropertyReaderPtr iProp, WrapExistingFlag iWrapFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Explicitly wrap an existing property It will check the data type and also verify the schema, if requested.

void get(value_type &iVal, const ISampleSelector &iSS = ISampleSelector ()) const

Get the typed sample. ...

value_type getValue(const ISampleSelector &iSS = ISampleSelector ()) const

Return the typed sample by value. ...

Public Static Functions

static const char *getInterpretation()

Return the interpretation expected of this property. An empty interpretation matches everything

static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this schema object

static bool matches(const AbcA::PropertyHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an object header) strictly matches the interpretation of this schema object

class OArchive

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::Base

Public Types

typedef OArchive this_type

By convention, we always define “this_type” in every Abc class. This convention is relied upon by the unspecified-bool-type conversion.

Public Functions

OArchive()

The default constructor creates an empty OArchive function set. ...

template <class ARCHIVE_CTOR>
OArchive(ARCHIVE_CTOR iCtor, const std::string &iFileName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Parameters
  • iCtor -

    We need to pass in a constructor which provides an explicit link to the concrete implementation of AbcCoreAbstract that we’re using.

  • iFileName -

    File name

  • iArg0 -

    Optionally could be the error handling policy, or the meta data.

  • iArg1 -

    Optionally could be the error handling policy, or the meta data.

The explicit constructor creates an archive with the given file name. Additional arguments that may be passed are the error handling policy and meta data.

OArchive(AbcA::ArchiveWriterPtr iPtr, WrapExistingFlag, ErrorHandler::Policy iPolicy = ErrorHandler::kThrowPolicy)

Parameters
  • iPtr -

    The pointer ...

  • iPolicy -

    Optional error handling policy ...

This attaches an OArchive wrapper around an existing ArchiveWriterPtr, with an optional error handling policy.

~OArchive()

Destructor ...

std::string getName() const

Default copy constructor Default assignment operator Returns the file name. It is an error to do so with an invalid object.

OObject getTop()

This returns the single top-level OObject that exists automatically as part of the archive.

int8_t getCompressionHint() const

Get the compression applied to array properties. The value will be -1 for uncompressed, and 0-9 for weak through strong gzip compression.

void setCompressionHint(int8_t iCh)

Set the compression applied to array properties. Value of -1 means uncompressed, and values of 0-9 indicate increasingly compressed data, at the expense of time.

uint32_t addTimeSampling(const AbcA::TimeSampling &iTs)

Adds the TimeSampling to the Archive TimeSampling pool. If the TimeSampling already exists in the pool, the index for the match should be returned. index 0 is automatically reserved for uniform time sampling with a start time of 0 and time per cycle of 1 (aka identity sampling)

AbcA::TimeSamplingPtr getTimeSampling(uint32_t iIndex)

Returns the TimeSampling at a given index. index 0 is automatically reserved for uniform time sampling with a start time of 0 and time per cycle of 1 (aka identity sampling)

uint32_t getNumTimeSamplings()

Returns the total number of TimeSamplingPtrs in the Archive TimeSampling pool.

AbcA::ArchiveWriterPtr getPtr()

getPtr, as usual, returns a shared ptr to the underlying AbcCoreAbstract object, in this case the ArchiveWriterPtr.

void reset()

Reset returns this function set to an empty, default state.

bool valid() const

Valid returns whether this function set is valid.

ALEMBIC_OPERATOR_BOOL(valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Private Members

AbcA::ArchiveWriterPtr m_archive
class OArrayProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT< AbcA::ArrayPropertyWriterPtr >

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::OTypedArrayProperty< TRAITS >

Public Types

typedef OArrayProperty this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

OArrayProperty()

The default constructor creates an empty OArrayProperty function set. ...

template <class OBJECT_PTR>
OArrayProperty(OBJECT_PTR iParentObject, const std::string &iName, const AbcA::DataType &iDataType, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

This templated, explicit function creates a new scalar property writer. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to a CompoundPropertyWriterPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, to specify MetaData, and to specify time sampling or time sampling index.

OArrayProperty(AbcA::ArrayPropertyWriterPtr iPtr, WrapExistingFlag iWrapFlag, ErrorHandler::Policy iPolicy = ErrorHandler::kThrowPolicy)

Parameters
  • iPtr -

    The pointer ...

  • iWrapFlag -

    The flag indicating that wrapping is intended. Even though it’s nonambiguous here, we use it anyway for readability

  • iPolicy -

    Optional error handling policy ...

This attaches an OArrayProperty wrapper around an existing ArrayPropertyWriterPtr, with an optional error handling policy.

~OArrayProperty()

Default copy constructor used Default assignment operator used. Destructor ...

size_t getNumSamples() const

Get the number of samples written so far. May change over time as more samples are written.

void set(const AbcA::ArraySample &iSample)

Set a sample from the address of a datum. ...

void setFromPrevious()

Set a sample from the previous sample. ...

void setTimeSampling(uint32_t iIndex)

Changes the TimeSampling used by this property. If the TimeSampling is changed to Acyclic and the number of samples currently set is more than the number of times provided in the Acyclic TimeSampling, an exception will be thrown.

void setTimeSampling(AbcA::TimeSamplingPtr iTime)

Changes the TimeSampling used by this property. If the TimeSampling is changed to Acyclic and the number of samples currently set is more than the number of times provided in the Acyclic TimeSampling, an exception will be thrown.

OCompoundProperty getParent() const

Return the parent compound property, handily wrapped in a OCompoundProperty wrapper.

template <class CPROP_PTR>
OArrayProperty(CPROP_PTR iParentProp, const std::string &iName, const AbcA::DataType &iDataType, const Argument &iArg0, const Argument &iArg1, const Argument &iArg2)

Private Functions

void init(AbcA::CompoundPropertyWriterPtr iParentObject, const std::string &iName, const AbcA::DataType &iDataType, ErrorHandler::Policy iParentPolicy, const Argument &iArg0, const Argument &iArg1, const Argument &iArg2)
template <class PROP_PTR>
class OBasePropertyT
#include <OBaseProperty.h>

Most of the functionality of properties (getting information about the properties and so on) is common to all property types, so we create a base class to contain all that functionality. This is purely a base class for other properties to derive from, it will never be created directly.

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::Base

Public Types

typedef OBasePropertyT<PROP_PTR> this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

typedef OBasePropertyT<PROP_PTR> operator_bool_base_type

Public Functions

const AbcA::PropertyHeader &getHeader() const

Default copy constructor used Default assignment operator used. Return the property’s header. ...

const std::string &getName() const

This function returns the property’s local name ...

AbcA::PropertyType getPropertyType() const

This function returns the property’s type ...

bool isScalar() const

Convenience to return whether the property is scalar. Same as getPropertyType() == kScalarProperty

bool isArray() const

Convenience to return whether the property is array. Same as getPropertyType() == kArrayProperty

bool isCompound() const

Convenience to return whether the property is compound. Same as getPropertyType() == kCompoundProperty

bool isSimple() const

Convenience to return whether the property is simple (non-compound) Same as getPropertyType() != kCompoundProperty

const AbcA::MetaData &getMetaData() const

All properties have MetaData. This just returns the MetaData portion of the header that was used in creation.

const AbcA::DataType &getDataType() const

Non-compound properties have a DataType. It is an error to call this function for CompoundProperties, and an exception will be thrown. This is a convenience function which just returns the DataType from the header that was used in creation.

AbcA::TimeSamplingPtr getTimeSampling() const

Non-compound properties have a TimeSamplingPtr. It is an error to call this function for CompoundProperties, and an exception will be thrown. This is a convenience function which just returns the TimeSamplingPtr from the header that was used in creation.

OObject getObject() const

This function returns the property’s object, handily wrapped in an OObject wrapper.

PROP_PTR getPtr() const

Can’t wrap OCompoundProperty getParent(); getPtr, as usual, returns a shared ptr to the underlying AbcCoreAbstract object, in this case the PROP_PTR.

void reset()

Reset returns this function set to an empty, default state.

bool valid() const

Valid returns whether this function set is valid.

ALEMBIC_OPERATOR_BOOL(valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Protected Functions

OBasePropertyT()

The default constructor creates an empty OBaseProperty function set. ...

OBasePropertyT(PROP_PTR iPtr, WrapExistingFlag, ErrorHandler::Policy iPolicy)

Parameters
  • iPtr -

    The pointer ...

  • iPolicy -

    The error handling. ...

This attaches an OBaseProperty wrapper around an existing PROP_PTR, with the given error handler policy

Protected Attributes

PROP_PTR m_property

Friends

friend Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT::OCompoundProperty
class OCompoundProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT< AbcA::CompoundPropertyWriterPtr >

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::OSchema< INFO >

Public Types

typedef OCompoundProperty this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

OCompoundProperty()

The default constructor creates an empty OCompoundProperty function set. ...

template <class CPROP_PTR>
OCompoundProperty(CPROP_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This templated, explicit function creates a new scalar property writer. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to a CompoundPropertyWriterPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, to specify MetaData.

template <class CPROP_PTR>
OCompoundProperty(CPROP_PTR iThisObject, WrapExistingFlag iWrapFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This attaches an OCompoundProperty wrapper around an existing CompoundPropertyWriterPtr, with an optional error handling policy.

template <class OBJECT_PTR>
OCompoundProperty(OBJECT_PTR iObject, TopFlag iTop, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

This attaches an OCompoundProperty wrapper around the top properties of an OObject.

~OCompoundProperty()

Default copy constructor used Default assignment operator used. Destructor ...

size_t getNumProperties() const

Returns the number of properties that have been created thus far. May change as more are created.

const AbcA::PropertyHeader &getPropertyHeader(size_t i) const

Return the header of a property that has already been added. Property is selected by index. This will throw an exception on out-of-range access.

const AbcA::PropertyHeader *getPropertyHeader(const std::string &iName) const

Return the header of a property that has already been added. Property is selected by name. This will return NULL if no property with the given name is found.

OBaseProperty getProperty(size_t i) const

Return a wrapped base property version of an ALREADY ADDED property. Will return an empty pointer if the writer for this property no longer exists or was never added. This would primarily be used for introspection.

OBaseProperty getProperty(const std::string &iName) const

Return a wrapped base property version of an ALREADY ADDED property. Will return an empty pointer if the writer for this property no longer exists or was never added. This would primarily be used for introspection.

OCompoundProperty getParent() const

Return the parent compound property, handily wrapped in a OCompoundProperty wrapper.

Private Functions

void init(AbcA::CompoundPropertyWriterPtr iParentObject, const std::string &iName, ErrorHandler::Policy iParentPolicy, const Argument &iArg0, const Argument &iArg1)
class OObject

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::Base

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::OSchemaObject< SCHEMA >

Public Types

typedef OObject this_type

By convention, we always define “this_type” in every Abc class. This convention is relied upon by the unspecified-bool-type conversion.

typedef OObject operator_bool_base_type

Public Functions

OObject()

The default constructor creates an empty OObject function set. ...

template <class OBJECT_PTR>
OObject(OBJECT_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

This templated, explicit function creates a new object writer. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to an ObjectWriterPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, to specify MetaData, and that’s it.

template <class OBJECT_PTR>
OObject(OBJECT_PTR iPtr, WrapExistingFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

This attaches an OObject wrapper around an existing ObjectWriterPtr, with an optional error handling policy. Arguments can be used to set error handling policy.

template <class ARCHIVE_PTR>
OObject(ARCHIVE_PTR iPtr, TopFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

This attaches an OObject wrapper around the top object in an archive. Arguments can be used to set error handling policy.

virtual ~OObject()

Default copy constructor used Default assignment operator used. Destructor ...

const AbcA::ObjectHeader &getHeader() const

Return the object’s header. ...

const std::string &getName() const

This function returns the object’s local name ...

const std::string &getFullName() const

This function returns the object’s full (unique with the archive) name

const AbcA::MetaData &getMetaData() const

This function returns the object’s metadata. ...

OArchive getArchive()

This function returns the object’s archive, handily wrapped in an OArchive wrapper.

OObject getParent()

This function returns the object’s parent, handily wrapped in an OObject wrapper. If the object is the top level object, the OObject returned will be NULL.

size_t getNumChildren()

This function returns the number of child objects that this object has. This may change as new children are created for writing.

const AbcA::ObjectHeader &getChildHeader(size_t i)

This function returns the headers of each of the child objects created so far.

const AbcA::ObjectHeader *getChildHeader(const std::string &iName)

This function returns the header of a named object if it has been created - even if the object no longer exists.

OCompoundProperty getProperties()

This returns the single top-level OCompoundProperty that exists automatically as part of the object.

OObject getChild(size_t iChildIndex)

This function returns an OObject wrapped around a pointer to an already created child. This is distinct from creating a new OObject as a child. If the writer associated with this child no longer exists, this function will return an empty OObject.

OObject getChild(const std::string &iChildName)

This function returns an OObject wrapped around a pointer to an already created child. This is distinct from creating a new OObject as a child. If the writer associated with this child no longer exists, this function will return an empty OObject.

bool addChildInstance(OObject iTarget, const std::string &iName)

-************************************************************************

AbcA::ObjectWriterPtr getPtr()

getPtr, as usual, returns a shared ptr to the underlying AbcCoreAbstract object, in this case the ObjectWriterPtr.

void reset()

Reset returns this function set to an empty, default state.

bool valid() const

Valid returns whether this function set is valid.

ALEMBIC_OPERATOR_BOOL(valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Protected Attributes

AbcA::ObjectWriterPtr m_object

Private Functions

void init(AbcA::ObjectWriterPtr iParentObject, const std::string &iName, ErrorHandler::Policy iParentPolicy, const Argument &iArg0, const Argument &iArg1, const Argument &iARg2)
class OScalarProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::OBasePropertyT< AbcA::ScalarPropertyWriterPtr >

Subclassed by Alembic::Abc::ALEMBIC_VERSION_NS::OTypedScalarProperty< TRAITS >

Public Types

typedef OScalarProperty this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

OScalarProperty()

The default constructor creates an empty OScalarProperty function set. ...

template <class OBJECT_PTR>
OScalarProperty(OBJECT_PTR iParentObject, const std::string &iName, const AbcA::DataType &iDataType, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

This templated, explicit function creates a new scalar property writer. The first argument is any Abc (or AbcCoreAbstract) object which can intrusively be converted to a CompoundPropertyWriterPtr to use as a parent, from which the error handler policy for inheritance is also derived. The remaining optional arguments can be used to override the ErrorHandlerPolicy, to specify MetaData, and to specify time sampling or time sampling index.

OScalarProperty(AbcA::ScalarPropertyWriterPtr iPtr, WrapExistingFlag iWrapFlag, ErrorHandler::Policy iPolicy = ErrorHandler::kThrowPolicy)

Parameters
  • iPtr -

    The pointer ...

  • iWrapFlag -

    The flag indicating that wrapping is intended. Even though it’s nonambiguous here, we use it anyway for readability

  • iPolicy -

    Error Handling Policy ..

This attaches an OScalarProperty wrapper around an existing ScalarPropertyWriterPtr, arguments are there to specify ErrorHandling policy,

~OScalarProperty()

Default copy constructor used Default assignment operator used. Destructor ...

size_t getNumSamples() const

Return the number of samples contained in the property. This can be any number, including zero. This returns the number of samples that were written, independently of whether or not they were constant. It make change over time as more samples are written.

void set(const void *iSample)

Set a sample from the address of a datum. ...

void setFromPrevious()

Set a sample from the previous sample. ...

void setTimeSampling(uint32_t iIndex)

Changes the TimeSampling used by this property. If the TimeSampling is changed to Acyclic and the number of samples currently set is more than the number of times provided in the Acyclic TimeSampling, an exception will be thrown.

void setTimeSampling(AbcA::TimeSamplingPtr iTime)

Changes the TimeSampling used by this property. If the TimeSampling is changed to Acyclic and the number of samples currently set is more than the number of times provided in the Acyclic TimeSampling, an exception will be thrown.

OCompoundProperty getParent() const

Return the parent compound property, handily wrapped in a OCompoundProperty wrapper.

template <class CPROP_PTR>
OScalarProperty(CPROP_PTR iParentProp, const std::string &iName, const AbcA::DataType &iDataType, const Argument &iArg0, const Argument &iArg1, const Argument &iArg2)

Private Functions

void init(AbcA::CompoundPropertyWriterPtr iParentObject, const std::string &iName, const AbcA::DataType &iDataType, ErrorHandler::Policy iParentPolicy, const Argument &iArg0, const Argument &iArg1, const Argument &iArg2)
template <class INFO>
class OSchema
#include <OSchema.h>

Usually used as a base class, but could also theoretically be used as a standalone

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::OCompoundProperty

Public Types

typedef INFO info_type
typedef OSchema<INFO> this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

Public Functions

OSchema()

The default constructor creates an empty OSchema function set.

template <class CPROP_PTR>
OSchema(CPROP_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

Creates a new Compound Property Writer with the schema information added to the metadata.

template <class CPROP_PTR>
OSchema(CPROP_PTR iParentObject, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

Creates a new Compound Property Writer with the schema information and also the default name.

virtual ~OSchema()

Public Static Functions

static const char *getSchemaTitle()

Return the schema title expected of this property. An empty title matches everything

static const char *getSchemaBaseType()

Return the schema base type expected of this property. An empty base type means it’s the root type.

static const char *getDefaultSchemaName()

Return the default name for instances of this schema. Often something like ”.geom”

static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this schema object

static bool matches(const AbcA::PropertyHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an object header) strictly matches the interpretation of this schema object, as well as the data type.

Private Functions

template <class CPROP_PTR>
void init(CPROP_PTR iParentObject, const std::string &iName, const Argument &iArg0, const Argument &iArg1, const Argument &iArg2)

Default copy constructor used Default assignment operator used.

template <class SCHEMA>
class OSchemaObject
#include <OSchemaObject.h>

An OSchemaObject is an object with a single schema. This is just a convenience class, really, but it also deals with setting up and validating metadata

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::OObject

Public Types

typedef SCHEMA schema_type
typedef OSchemaObject<SCHEMA> this_type

By convention, we always define “this_type” in every Abc class. This convention is relied upon by the unspecified-bool-type conversion.

Public Functions

OSchemaObject()

The default constructor creates an empty OSchemaObject function set. ...

template <class OBJECT_PTR>
OSchemaObject(OBJECT_PTR iParentObject, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

The primary constructor creates an OSchemaObject as a child of the first argument, which is any Abc or AbcCoreAbstract (or other) object which can be intrusively cast to an ObjectWriterPtr.

SCHEMA &getSchema()

Schemas are not necessarily cheap to copy, so we return by reference rather than by value.

const SCHEMA &getSchema() const
void reset()

Reset returns this function set to an empty, default state.

bool valid() const

Valid returns whether this function set is valid.

ALEMBIC_OVERRIDE_OPERATOR_BOOL(this_type::valid())

The unspecified-bool-type operator casts the object to “true” if it is valid, and “false” otherwise.

Public Static Functions

static std::string getSchemaObjTitle()

Our schema title contains the schema title of the underlying compound property, along with the default name of that compound property. So, for example - most AbcGeom types put their data in ”.geom”, so, “AbcGeom_PolyMesh_v1:.geom” Sometimes schema titles from underlying schemas are “”, but ours never are.

static const char *getSchemaTitle()
static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this schema object

static bool matches(const AbcA::ObjectHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an object header) strictly matches the interpretation of this schema object, as well as the data type.

Protected Attributes

SCHEMA m_schema
template <class TRAITS>
class OTypedArrayProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::OArrayProperty

Public Types

typedef TRAITS traits_type
typedef OTypedArrayProperty<TRAITS> this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

typedef TRAITS::value_type value_type
typedef TypedArraySample<TRAITS> sample_type

Public Functions

OTypedArrayProperty()

Create a default (empty) TypedArrayProperty ...

template <class COMPOUND_PTR>
OTypedArrayProperty(COMPOUND_PTR iParent, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

Create a new TypedArrayProperty as a child of the passed COMPOUND_PTR Arguments can specify metadata, timesampling, and error handling.

OTypedArrayProperty(AbcA::ArrayPropertyWriterPtr iProp, WrapExistingFlag iWrapFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Wrap an existing property. This will check to make sure it can wrap.

void set(const sample_type &iVal)

Set a sample using a reference to a typed array sample-type, instead of a void* ArraySample

Public Static Functions

static const char *getInterpretation()

Return the interpretation expected of this property. An empty interpretation matches everything

static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this typed property

static bool matches(const AbcA::PropertyHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an property header) strictly matches the interpretation of this typed property, as well as the data type.

template <class TRAITS>
class OTypedScalarProperty

Inherits from Alembic::Abc::ALEMBIC_VERSION_NS::OScalarProperty

Public Types

typedef TRAITS traits_type
typedef OTypedScalarProperty<TRAITS> this_type

By convention we always define this_type in Abc classes Used by unspecified-bool-type conversion below

typedef TRAITS::value_type value_type

Public Functions

OTypedScalarProperty()

Create a default (empty) TypedScalarProperty ...

template <class COMPOUND_PTR>
OTypedScalarProperty(COMPOUND_PTR iParent, const std::string &iName, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

Create a new TypedScalarProperty as a child of the passed COMPOUND_PTR Arguments can specify metadata, timesampling, and error handling.

OTypedScalarProperty(AbcA::ScalarPropertyWriterPtr iProp, WrapExistingFlag iWrapFlag, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Wrap an existing scalar property, checking to make sure it matches data type and also (if requested) interpretation.

void set(const value_type &iVal)

Set a sample using a reference to a value-type, instead of a void*

Public Static Functions

static const char *getInterpretation()

Return the interpretation expected of this property. An empty interpretation matches everything

static bool matches(const AbcA::MetaData &iMetaData, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given entity (as represented by a metadata) strictly matches the interpretation of this schema object

static bool matches(const AbcA::PropertyHeader &iHeader, SchemaInterpMatching iMatching = kStrictMatching)

This will check whether or not a given object (as represented by an object header) strictly matches the interpretation of this schema object, as well as the data type.

template <class TRAITS>
class TypedArraySample

Public Types

typedef TRAITS traits_type
typedef TypedArraySample<TRAITS> this_type
typedef TRAITS::value_type value_type
typedef std::vector<value_type> value_vector

Public Functions

TypedArraySample()
TypedArraySample(const value_type *iValues, size_t iNumVals)
TypedArraySample(const value_type *iValues, const Dimensions &iDims)
TypedArraySample(const value_vector &iVec)
TypedArraySample(const value_vector &iVec, const Dimensions &iDims)
TypedArraySample(const AbcA::ArraySample &iCopy)
TypedArraySample<TRAITS> operator=(const AbcA::ArraySample &iCopy)
const value_type *get() const
const value_type *operator->() const
const value_type &operator[](const size_t i) const
size_t size() const
ALEMBIC_OPERATOR_BOOL(ArraySample::valid())

Public Static Functions

static TypedArraySample<TRAITS> emptySample()
namespace AbcA
namespace Alembic
namespace Abc
namespace ALEMBIC_VERSION_NS

Typedefs

typedef ITypedArrayProperty<BooleanTPTraits> IBoolArrayProperty
typedef ITypedArrayProperty<Uint8TPTraits> IUcharArrayProperty
typedef ITypedArrayProperty<Int8TPTraits> ICharArrayProperty
typedef ITypedArrayProperty<Uint16TPTraits> IUInt16ArrayProperty
typedef ITypedArrayProperty<Int16TPTraits> IInt16ArrayProperty
typedef ITypedArrayProperty<Uint32TPTraits> IUInt32ArrayProperty
typedef ITypedArrayProperty<Int32TPTraits> IInt32ArrayProperty
typedef ITypedArrayProperty<Uint64TPTraits> IUInt64ArrayProperty
typedef ITypedArrayProperty<Int64TPTraits> IInt64ArrayProperty
typedef ITypedArrayProperty<Float16TPTraits> IHalfArrayProperty
typedef ITypedArrayProperty<Float32TPTraits> IFloatArrayProperty
typedef ITypedArrayProperty<Float64TPTraits> IDoubleArrayProperty
typedef ITypedArrayProperty<StringTPTraits> IStringArrayProperty
typedef ITypedArrayProperty<WstringTPTraits> IWstringArrayProperty
typedef ITypedArrayProperty<V2sTPTraits> IV2sArrayProperty
typedef ITypedArrayProperty<V2iTPTraits> IV2iArrayProperty
typedef ITypedArrayProperty<V2fTPTraits> IV2fArrayProperty
typedef ITypedArrayProperty<V2dTPTraits> IV2dArrayProperty
typedef ITypedArrayProperty<V3sTPTraits> IV3sArrayProperty
typedef ITypedArrayProperty<V3iTPTraits> IV3iArrayProperty
typedef ITypedArrayProperty<V3fTPTraits> IV3fArrayProperty
typedef ITypedArrayProperty<V3dTPTraits> IV3dArrayProperty
typedef ITypedArrayProperty<P2sTPTraits> IP2sArrayProperty
typedef ITypedArrayProperty<P2iTPTraits> IP2iArrayProperty
typedef ITypedArrayProperty<P2fTPTraits> IP2fArrayProperty
typedef ITypedArrayProperty<P2dTPTraits> IP2dArrayProperty
typedef ITypedArrayProperty<P3sTPTraits> IP3sArrayProperty
typedef ITypedArrayProperty<P3iTPTraits> IP3iArrayProperty
typedef ITypedArrayProperty<P3fTPTraits> IP3fArrayProperty
typedef ITypedArrayProperty<P3dTPTraits> IP3dArrayProperty
typedef ITypedArrayProperty<Box2sTPTraits> IBox2sArrayProperty
typedef ITypedArrayProperty<Box2iTPTraits> IBox2iArrayProperty
typedef ITypedArrayProperty<Box2fTPTraits> IBox2fArrayProperty
typedef ITypedArrayProperty<Box2dTPTraits> IBox2dArrayProperty
typedef ITypedArrayProperty<Box3sTPTraits> IBox3sArrayProperty
typedef ITypedArrayProperty<Box3iTPTraits> IBox3iArrayProperty
typedef ITypedArrayProperty<Box3fTPTraits> IBox3fArrayProperty
typedef ITypedArrayProperty<Box3dTPTraits> IBox3dArrayProperty
typedef ITypedArrayProperty<M33fTPTraits> IM33fArrayProperty
typedef ITypedArrayProperty<M33dTPTraits> IM33dArrayProperty
typedef ITypedArrayProperty<M44fTPTraits> IM44fArrayProperty
typedef ITypedArrayProperty<M44dTPTraits> IM44dArrayProperty
typedef ITypedArrayProperty<QuatfTPTraits> IQuatfArrayProperty
typedef ITypedArrayProperty<QuatdTPTraits> IQuatdArrayProperty
typedef ITypedArrayProperty<C3hTPTraits> IC3hArrayProperty
typedef ITypedArrayProperty<C3fTPTraits> IC3fArrayProperty
typedef ITypedArrayProperty<C3cTPTraits> IC3cArrayProperty
typedef ITypedArrayProperty<C4hTPTraits> IC4hArrayProperty
typedef ITypedArrayProperty<C4fTPTraits> IC4fArrayProperty
typedef ITypedArrayProperty<C4cTPTraits> IC4cArrayProperty
typedef ITypedArrayProperty<N2fTPTraits> IN2fArrayProperty
typedef ITypedArrayProperty<N2dTPTraits> IN2dArrayProperty
typedef ITypedArrayProperty<N3fTPTraits> IN3fArrayProperty
typedef ITypedArrayProperty<N3dTPTraits> IN3dArrayProperty
typedef OTypedArrayProperty<BooleanTPTraits> OBoolArrayProperty
typedef OTypedArrayProperty<Uint8TPTraits> OUcharArrayProperty
typedef OTypedArrayProperty<Int8TPTraits> OCharArrayProperty
typedef OTypedArrayProperty<Uint16TPTraits> OUInt16ArrayProperty
typedef OTypedArrayProperty<Int16TPTraits> OInt16ArrayProperty
typedef OTypedArrayProperty<Uint32TPTraits> OUInt32ArrayProperty
typedef OTypedArrayProperty<Int32TPTraits> OInt32ArrayProperty
typedef OTypedArrayProperty<Uint64TPTraits> OUInt64ArrayProperty
typedef OTypedArrayProperty<Int64TPTraits> OInt64ArrayProperty
typedef OTypedArrayProperty<Float16TPTraits> OHalfArrayProperty
typedef OTypedArrayProperty<Float32TPTraits> OFloatArrayProperty
typedef OTypedArrayProperty<Float64TPTraits> ODoubleArrayProperty
typedef OTypedArrayProperty<StringTPTraits> OStringArrayProperty
typedef OTypedArrayProperty<WstringTPTraits> OWstringArrayProperty
typedef OTypedArrayProperty<V2sTPTraits> OV2sArrayProperty
typedef OTypedArrayProperty<V2iTPTraits> OV2iArrayProperty
typedef OTypedArrayProperty<V2fTPTraits> OV2fArrayProperty
typedef OTypedArrayProperty<V2dTPTraits> OV2dArrayProperty
typedef OTypedArrayProperty<V3sTPTraits> OV3sArrayProperty
typedef OTypedArrayProperty<V3iTPTraits> OV3iArrayProperty
typedef OTypedArrayProperty<V3fTPTraits> OV3fArrayProperty
typedef OTypedArrayProperty<V3dTPTraits> OV3dArrayProperty
typedef OTypedArrayProperty<P2sTPTraits> OP2sArrayProperty
typedef OTypedArrayProperty<P2iTPTraits> OP2iArrayProperty
typedef OTypedArrayProperty<P2fTPTraits> OP2fArrayProperty
typedef OTypedArrayProperty<P2dTPTraits> OP2dArrayProperty
typedef OTypedArrayProperty<P3sTPTraits> OP3sArrayProperty
typedef OTypedArrayProperty<P3iTPTraits> OP3iArrayProperty
typedef OTypedArrayProperty<P3fTPTraits> OP3fArrayProperty
typedef OTypedArrayProperty<P3dTPTraits> OP3dArrayProperty
typedef OTypedArrayProperty<Box2sTPTraits> OBox2sArrayProperty
typedef OTypedArrayProperty<Box2iTPTraits> OBox2iArrayProperty
typedef OTypedArrayProperty<Box2fTPTraits> OBox2fArrayProperty
typedef OTypedArrayProperty<Box2dTPTraits> OBox2dArrayProperty
typedef OTypedArrayProperty<Box3sTPTraits> OBox3sArrayProperty
typedef OTypedArrayProperty<Box3iTPTraits> OBox3iArrayProperty
typedef OTypedArrayProperty<Box3fTPTraits> OBox3fArrayProperty
typedef OTypedArrayProperty<Box3dTPTraits> OBox3dArrayProperty
typedef OTypedArrayProperty<M33fTPTraits> OM33fArrayProperty
typedef OTypedArrayProperty<M33dTPTraits> OM33dArrayProperty
typedef OTypedArrayProperty<M44fTPTraits> OM44fArrayProperty
typedef OTypedArrayProperty<M44dTPTraits> OM44dArrayProperty
typedef OTypedArrayProperty<QuatfTPTraits> OQuatfArrayProperty
typedef OTypedArrayProperty<QuatdTPTraits> OQuatdArrayProperty
typedef OTypedArrayProperty<C3hTPTraits> OC3hArrayProperty
typedef OTypedArrayProperty<C3fTPTraits> OC3fArrayProperty
typedef OTypedArrayProperty<C3cTPTraits> OC3cArrayProperty
typedef OTypedArrayProperty<C4hTPTraits> OC4hArrayProperty
typedef OTypedArrayProperty<C4fTPTraits> OC4fArrayProperty
typedef OTypedArrayProperty<C4cTPTraits> OC4cArrayProperty
typedef OTypedArrayProperty<N2fTPTraits> ON2fArrayProperty
typedef OTypedArrayProperty<N2dTPTraits> ON2dArrayProperty
typedef OTypedArrayProperty<N3fTPTraits> ON3fArrayProperty
typedef OTypedArrayProperty<N3dTPTraits> ON3dArrayProperty
typedef Alembic::Util::shared_ptr<IObject> IObjectPtr
typedef ITypedScalarProperty<BooleanTPTraits> IBoolProperty
typedef ITypedScalarProperty<Uint8TPTraits> IUcharProperty
typedef ITypedScalarProperty<Int8TPTraits> ICharProperty
typedef ITypedScalarProperty<Uint16TPTraits> IUInt16Property
typedef ITypedScalarProperty<Int16TPTraits> IInt16Property
typedef ITypedScalarProperty<Uint32TPTraits> IUInt32Property
typedef ITypedScalarProperty<Int32TPTraits> IInt32Property
typedef ITypedScalarProperty<Uint64TPTraits> IUInt64Property
typedef ITypedScalarProperty<Int64TPTraits> IInt64Property
typedef ITypedScalarProperty<Float16TPTraits> IHalfProperty
typedef ITypedScalarProperty<Float32TPTraits> IFloatProperty
typedef ITypedScalarProperty<Float64TPTraits> IDoubleProperty
typedef ITypedScalarProperty<StringTPTraits> IStringProperty
typedef ITypedScalarProperty<WstringTPTraits> IWstringProperty
typedef ITypedScalarProperty<V2sTPTraits> IV2sProperty
typedef ITypedScalarProperty<V2iTPTraits> IV2iProperty
typedef ITypedScalarProperty<V2fTPTraits> IV2fProperty
typedef ITypedScalarProperty<V2dTPTraits> IV2dProperty
typedef ITypedScalarProperty<V3sTPTraits> IV3sProperty
typedef ITypedScalarProperty<V3iTPTraits> IV3iProperty
typedef ITypedScalarProperty<V3fTPTraits> IV3fProperty
typedef ITypedScalarProperty<V3dTPTraits> IV3dProperty
typedef ITypedScalarProperty<P2sTPTraits> IP2sProperty
typedef ITypedScalarProperty<P2iTPTraits> IP2iProperty
typedef ITypedScalarProperty<P2fTPTraits> IP2fProperty
typedef ITypedScalarProperty<P2dTPTraits> IP2dProperty
typedef ITypedScalarProperty<P3sTPTraits> IP3sProperty
typedef ITypedScalarProperty<P3iTPTraits> IP3iProperty
typedef ITypedScalarProperty<P3fTPTraits> IP3fProperty
typedef ITypedScalarProperty<P3dTPTraits> IP3dProperty
typedef ITypedScalarProperty<Box2sTPTraits> IBox2sProperty
typedef ITypedScalarProperty<Box2iTPTraits> IBox2iProperty
typedef ITypedScalarProperty<Box2fTPTraits> IBox2fProperty
typedef ITypedScalarProperty<Box2dTPTraits> IBox2dProperty
typedef ITypedScalarProperty<Box3sTPTraits> IBox3sProperty
typedef ITypedScalarProperty<Box3iTPTraits> IBox3iProperty
typedef ITypedScalarProperty<Box3fTPTraits> IBox3fProperty
typedef ITypedScalarProperty<Box3dTPTraits> IBox3dProperty
typedef ITypedScalarProperty<M33fTPTraits> IM33fProperty
typedef ITypedScalarProperty<M33dTPTraits> IM33dProperty
typedef ITypedScalarProperty<M44fTPTraits> IM44fProperty
typedef ITypedScalarProperty<M44dTPTraits> IM44dProperty
typedef ITypedScalarProperty<QuatfTPTraits> IQuatfProperty
typedef ITypedScalarProperty<QuatdTPTraits> IQuatdProperty
typedef ITypedScalarProperty<C3hTPTraits> IC3hProperty
typedef ITypedScalarProperty<C3fTPTraits> IC3fProperty
typedef ITypedScalarProperty<C3cTPTraits> IC3cProperty
typedef ITypedScalarProperty<C4hTPTraits> IC4hProperty
typedef ITypedScalarProperty<C4fTPTraits> IC4fProperty
typedef ITypedScalarProperty<C4cTPTraits> IC4cProperty
typedef ITypedScalarProperty<N2fTPTraits> IN2fProperty
typedef ITypedScalarProperty<N2dTPTraits> IN2dProperty
typedef ITypedScalarProperty<N3fTPTraits> IN3fProperty
typedef ITypedScalarProperty<N3dTPTraits> IN3dProperty
typedef OBasePropertyT<AbcA::BasePropertyWriterPtr> OBaseProperty
typedef TypedArraySample<BooleanTPTraits> BoolArraySample
typedef TypedArraySample<Uint8TPTraits> UcharArraySample
typedef TypedArraySample<Int8TPTraits> CharArraySample
typedef TypedArraySample<Uint16TPTraits> UInt16ArraySample
typedef TypedArraySample<Int16TPTraits> Int16ArraySample
typedef TypedArraySample<Uint32TPTraits> UInt32ArraySample
typedef TypedArraySample<Int32TPTraits> Int32ArraySample
typedef TypedArraySample<Uint64TPTraits> UInt64ArraySample
typedef TypedArraySample<Int64TPTraits> Int64ArraySample
typedef TypedArraySample<Float16TPTraits> HalfArraySample
typedef TypedArraySample<Float32TPTraits> FloatArraySample
typedef TypedArraySample<Float64TPTraits> DoubleArraySample
typedef TypedArraySample<StringTPTraits> StringArraySample
typedef TypedArraySample<WstringTPTraits> WstringArraySample
typedef TypedArraySample<V2sTPTraits> V2sArraySample
typedef TypedArraySample<V2iTPTraits> V2iArraySample
typedef TypedArraySample<V2fTPTraits> V2fArraySample
typedef TypedArraySample<V2dTPTraits> V2dArraySample
typedef TypedArraySample<V3sTPTraits> V3sArraySample
typedef TypedArraySample<V3iTPTraits> V3iArraySample
typedef TypedArraySample<V3fTPTraits> V3fArraySample
typedef TypedArraySample<V3dTPTraits> V3dArraySample
typedef TypedArraySample<P2sTPTraits> P2sArraySample
typedef TypedArraySample<P2iTPTraits> P2iArraySample
typedef TypedArraySample<P2fTPTraits> P2fArraySample
typedef TypedArraySample<P2dTPTraits> P2dArraySample
typedef TypedArraySample<P3sTPTraits> P3sArraySample
typedef TypedArraySample<P3iTPTraits> P3iArraySample
typedef TypedArraySample<P3fTPTraits> P3fArraySample
typedef TypedArraySample<P3dTPTraits> P3dArraySample
typedef TypedArraySample<Box2sTPTraits> Box2sArraySample
typedef TypedArraySample<Box2iTPTraits> Box2iArraySample
typedef TypedArraySample<Box2fTPTraits> Box2fArraySample
typedef TypedArraySample<Box2dTPTraits> Box2dArraySample
typedef TypedArraySample<Box3sTPTraits> Box3sArraySample
typedef TypedArraySample<Box3iTPTraits> Box3iArraySample
typedef TypedArraySample<Box3fTPTraits> Box3fArraySample
typedef TypedArraySample<Box3dTPTraits> Box3dArraySample
typedef TypedArraySample<M33fTPTraits> M33fArraySample
typedef TypedArraySample<M33dTPTraits> M33dArraySample
typedef TypedArraySample<M44fTPTraits> M44fArraySample
typedef TypedArraySample<M44dTPTraits> M44dArraySample
typedef TypedArraySample<QuatfTPTraits> QuatfArraySample
typedef TypedArraySample<QuatdTPTraits> QuatdArraySample
typedef TypedArraySample<C3hTPTraits> C3hArraySample
typedef TypedArraySample<C3fTPTraits> C3fArraySample
typedef TypedArraySample<C3cTPTraits> C3cArraySample
typedef TypedArraySample<C4hTPTraits> C4hArraySample
typedef TypedArraySample<C4fTPTraits> C4fArraySample
typedef TypedArraySample<C4cTPTraits> C4cArraySample
typedef TypedArraySample<N2fTPTraits> N2fArraySample
typedef TypedArraySample<N2dTPTraits> N2dArraySample
typedef TypedArraySample<N3fTPTraits> N3fArraySample
typedef TypedArraySample<N3dTPTraits> N3dArraySample
typedef Alembic::Util::shared_ptr<BoolArraySample> BoolArraySamplePtr
typedef Alembic::Util::shared_ptr<UcharArraySample> UcharArraySamplePtr
typedef Alembic::Util::shared_ptr<CharArraySample> CharArraySamplePtr
typedef Alembic::Util::shared_ptr<UInt16ArraySample> UInt16ArraySamplePtr
typedef Alembic::Util::shared_ptr<Int16ArraySample> Int16ArraySamplePtr
typedef Alembic::Util::shared_ptr<UInt32ArraySample> UInt32ArraySamplePtr
typedef Alembic::Util::shared_ptr<Int32ArraySample> Int32ArraySamplePtr
typedef Alembic::Util::shared_ptr<UInt64ArraySample> UInt64ArraySamplePtr
typedef Alembic::Util::shared_ptr<Int64ArraySample> Int64ArraySamplePtr
typedef Alembic::Util::shared_ptr<HalfArraySample> HalfArraySamplePtr
typedef Alembic::Util::shared_ptr<FloatArraySample> FloatArraySamplePtr
typedef Alembic::Util::shared_ptr<DoubleArraySample> DoubleArraySamplePtr
typedef Alembic::Util::shared_ptr<StringArraySample> StringArraySamplePtr
typedef Alembic::Util::shared_ptr<WstringArraySample> WstringArraySamplePtr
typedef Alembic::Util::shared_ptr<V2sArraySample> V2sArraySamplePtr
typedef Alembic::Util::shared_ptr<V2iArraySample> V2iArraySamplePtr
typedef Alembic::Util::shared_ptr<V2fArraySample> V2fArraySamplePtr
typedef Alembic::Util::shared_ptr<V2dArraySample> V2dArraySamplePtr
typedef Alembic::Util::shared_ptr<V3sArraySample> V3sArraySamplePtr
typedef Alembic::Util::shared_ptr<V3iArraySample> V3iArraySamplePtr
typedef Alembic::Util::shared_ptr<V3fArraySample> V3fArraySamplePtr
typedef Alembic::Util::shared_ptr<V3dArraySample> V3dArraySamplePtr
typedef Alembic::Util::shared_ptr<P2sArraySample> P2sArraySamplePtr
typedef Alembic::Util::shared_ptr<P2iArraySample> P2iArraySamplePtr
typedef Alembic::Util::shared_ptr<P2fArraySample> P2fArraySamplePtr
typedef Alembic::Util::shared_ptr<P2dArraySample> P2dArraySamplePtr
typedef Alembic::Util::shared_ptr<P3sArraySample> P3sArraySamplePtr
typedef Alembic::Util::shared_ptr<P3iArraySample> P3iArraySamplePtr
typedef Alembic::Util::shared_ptr<P3fArraySample> P3fArraySamplePtr
typedef Alembic::Util::shared_ptr<P3dArraySample> P3dArraySamplePtr
typedef Alembic::Util::shared_ptr<Box2sArraySample> Box2sArraySamplePtr
typedef Alembic::Util::shared_ptr<Box2iArraySample> Box2iArraySamplePtr
typedef Alembic::Util::shared_ptr<Box2fArraySample> Box2fArraySamplePtr
typedef Alembic::Util::shared_ptr<Box2dArraySample> Box2dArraySamplePtr
typedef Alembic::Util::shared_ptr<Box3sArraySample> Box3sArraySamplePtr
typedef Alembic::Util::shared_ptr<Box3iArraySample> Box3iArraySamplePtr
typedef Alembic::Util::shared_ptr<Box3fArraySample> Box3fArraySamplePtr
typedef Alembic::Util::shared_ptr<Box3dArraySample> Box3dArraySamplePtr
typedef Alembic::Util::shared_ptr<M33fArraySample> M33fArraySamplePtr
typedef Alembic::Util::shared_ptr<M33dArraySample> M33dArraySamplePtr
typedef Alembic::Util::shared_ptr<M44fArraySample> M44fArraySamplePtr
typedef Alembic::Util::shared_ptr<M44dArraySample> M44dArraySamplePtr
typedef Alembic::Util::shared_ptr<QuatfArraySample> QuatfArraySamplePtr
typedef Alembic::Util::shared_ptr<QuatdArraySample> QuatdArraySamplePtr
typedef Alembic::Util::shared_ptr<C3hArraySample> C3hArraySamplePtr
typedef Alembic::Util::shared_ptr<C3fArraySample> C3fArraySamplePtr
typedef Alembic::Util::shared_ptr<C3cArraySample> C3cArraySamplePtr
typedef Alembic::Util::shared_ptr<C4hArraySample> C4hArraySamplePtr
typedef Alembic::Util::shared_ptr<C4fArraySample> C4fArraySamplePtr
typedef Alembic::Util::shared_ptr<C4cArraySample> C4cArraySamplePtr
typedef Alembic::Util::shared_ptr<N2fArraySample> N2fArraySamplePtr
typedef Alembic::Util::shared_ptr<N2dArraySample> N2dArraySamplePtr
typedef Alembic::Util::shared_ptr<N3fArraySample> N3fArraySamplePtr
typedef Alembic::Util::shared_ptr<N3dArraySample> N3dArraySamplePtr
typedef OTypedScalarProperty<BooleanTPTraits> OBoolProperty
typedef OTypedScalarProperty<Uint8TPTraits> OUcharProperty
typedef OTypedScalarProperty<Int8TPTraits> OCharProperty
typedef OTypedScalarProperty<Uint16TPTraits> OUInt16Property
typedef OTypedScalarProperty<Int16TPTraits> OInt16Property
typedef OTypedScalarProperty<Uint32TPTraits> OUInt32Property
typedef OTypedScalarProperty<Int32TPTraits> OInt32Property
typedef OTypedScalarProperty<Uint64TPTraits> OUInt64Property
typedef OTypedScalarProperty<Int64TPTraits> OInt64Property
typedef OTypedScalarProperty<Float16TPTraits> OHalfProperty
typedef OTypedScalarProperty<Float32TPTraits> OFloatProperty
typedef OTypedScalarProperty<Float64TPTraits> ODoubleProperty
typedef OTypedScalarProperty<StringTPTraits> OStringProperty
typedef OTypedScalarProperty<WstringTPTraits> OWstringProperty
typedef OTypedScalarProperty<V2sTPTraits> OV2sProperty
typedef OTypedScalarProperty<V2iTPTraits> OV2iProperty
typedef OTypedScalarProperty<V2fTPTraits> OV2fProperty
typedef OTypedScalarProperty<V2dTPTraits> OV2dProperty
typedef OTypedScalarProperty<V3sTPTraits> OV3sProperty
typedef OTypedScalarProperty<V3iTPTraits> OV3iProperty
typedef OTypedScalarProperty<V3fTPTraits> OV3fProperty
typedef OTypedScalarProperty<V3dTPTraits> OV3dProperty
typedef OTypedScalarProperty<P2sTPTraits> OP2sProperty
typedef OTypedScalarProperty<P2iTPTraits> OP2iProperty
typedef OTypedScalarProperty<P2fTPTraits> OP2fProperty
typedef OTypedScalarProperty<P2dTPTraits> OP2dProperty
typedef OTypedScalarProperty<P3sTPTraits> OP3sProperty
typedef OTypedScalarProperty<P3iTPTraits> OP3iProperty
typedef OTypedScalarProperty<P3fTPTraits> OP3fProperty
typedef OTypedScalarProperty<P3dTPTraits> OP3dProperty
typedef OTypedScalarProperty<Box2sTPTraits> OBox2sProperty
typedef OTypedScalarProperty<Box2iTPTraits> OBox2iProperty
typedef OTypedScalarProperty<Box2fTPTraits> OBox2fProperty
typedef OTypedScalarProperty<Box2dTPTraits> OBox2dProperty
typedef OTypedScalarProperty<Box3sTPTraits> OBox3sProperty
typedef OTypedScalarProperty<Box3iTPTraits> OBox3iProperty
typedef OTypedScalarProperty<Box3fTPTraits> OBox3fProperty
typedef OTypedScalarProperty<Box3dTPTraits> OBox3dProperty
typedef OTypedScalarProperty<M33fTPTraits> OM33fProperty
typedef OTypedScalarProperty<M33dTPTraits> OM33dProperty
typedef OTypedScalarProperty<M44fTPTraits> OM44fProperty
typedef OTypedScalarProperty<M44dTPTraits> OM44dProperty
typedef OTypedScalarProperty<QuatfTPTraits> OQuatfProperty
typedef OTypedScalarProperty<QuatdTPTraits> OQuatdProperty
typedef OTypedScalarProperty<C3hTPTraits> OC3hProperty
typedef OTypedScalarProperty<C3fTPTraits> OC3fProperty
typedef OTypedScalarProperty<C3cTPTraits> OC3cProperty
typedef OTypedScalarProperty<C4hTPTraits> OC4hProperty
typedef OTypedScalarProperty<C4fTPTraits> OC4fProperty
typedef OTypedScalarProperty<C4cTPTraits> OC4cProperty
typedef OTypedScalarProperty<N2fTPTraits> ON2fProperty
typedef OTypedScalarProperty<N2dTPTraits> ON2dProperty
typedef OTypedScalarProperty<N3fTPTraits> ON3fProperty
typedef OTypedScalarProperty<N3dTPTraits> ON3dProperty
typedef V3f N3f
typedef V3d N3d

Enums

enum SchemaInterpMatching

Flag for specifying whether to match interpretations or schemas When we create objects that have certain expected properties, data formats or layouts, we use things called “SchemaTitles” and “Interpretations”, both of which are just strings, for providing a hint as to the meaning of CompoundProperties and SimpleProperties, respectively. This flag is used by the wrapper classes to indicate how they will assert a match of schemaTitle or interpretation.

Values:

kStrictMatching
kNoMatching
kSchemaTitleMatching
enum WrapExistingFlag

We want to be able to use our wrapper classes to wrap existing writer and reader objects from AbcCoreAbstract. However, the constructors for these wrapper classes have trouble distinguishing between the user request to wrap an existing writer, vs the request to create a new writer. While for some of the properties herein this is actually not ambiguous, we insist on the use of this flag because it makes code and intention more readable.

Values:

kWrapExisting
enum TopFlag

This flag exists to indicate that the “top” object or compound property is desired - when getting the top object from the Archive or getting the top compound property from the Object.

Values:

kTop

Functions

AbcA::ArchiveWriterPtr GetArchiveWriterPtr(OArchive &iArch)
AbcA::CompoundPropertyReaderPtr GetCompoundPropertyReaderPtr(ICompoundProperty &iPrp)
ErrorHandler::Policy GetErrorHandlerPolicy(const Argument &iArg0, const Argument &iArg1)
ErrorHandler::Policy GetErrorHandlerPolicy(const Base &iClass)
AbcA::ArchiveReaderPtr GetArchiveReaderPtr(IArchive &iPrp)

This function is used by the intrusive templated constructors for IObjects.

AbcA::ObjectReaderPtr GetObjectReaderPtr(IObject &iPrp)
template <class OBJ>
ErrorHandler::Policy GetErrorHandlerPolicy(OBJ iObj, ErrorHandler::Policy iPcy)
DECLARE_POD_TRAITS(bool_t, BooleanTPTraits)
DECLARE_POD_TRAITS(uint8_t, Uint8TPTraits)
DECLARE_POD_TRAITS(int8_t, Int8TPTraits)
DECLARE_POD_TRAITS(uint16_t, Uint16TPTraits)
DECLARE_POD_TRAITS(int16_t, Int16TPTraits)
DECLARE_POD_TRAITS(uint32_t, Uint32TPTraits)
DECLARE_POD_TRAITS(int32_t, Int32TPTraits)
DECLARE_POD_TRAITS(uint64_t, Uint64TPTraits)
DECLARE_POD_TRAITS(int64_t, Int64TPTraits)
DECLARE_POD_TRAITS(float16_t, Float16TPTraits)
DECLARE_POD_TRAITS(float32_t, Float32TPTraits)
DECLARE_POD_TRAITS(float64_t, Float64TPTraits)
DECLARE_POD_TRAITS(string, StringTPTraits)
DECLARE_POD_TRAITS(wstring, WstringTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2s, kInt16POD, 2, "vector", V2sTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2i, kInt32POD, 2, "vector", V2iTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2f, kFloat32POD, 2, "vector", V2fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2d, kFloat64POD, 2, "vector", V2dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3s, kInt16POD, 3, "vector", V3sTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3i, kInt32POD, 3, "vector", V3iTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3f, kFloat32POD, 3, "vector", V3fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3d, kFloat64POD, 3, "vector", V3dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2s, kInt16POD, 2, "point", P2sTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2i, kInt32POD, 2, "point", P2iTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2f, kFloat32POD, 2, "point", P2fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2d, kFloat64POD, 2, "point", P2dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3s, kInt16POD, 3, "point", P3sTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3i, kInt32POD, 3, "point", P3iTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3f, kFloat32POD, 3, "point", P3fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V3d, kFloat64POD, 3, "point", P3dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box2s, kInt16POD, 4, "box", Box2sTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box2i, kInt32POD, 4, "box", Box2iTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box2f, kFloat32POD, 4, "box", Box2fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box2d, kFloat64POD, 4, "box", Box2dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box3s, kInt16POD, 6, "box", Box3sTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box3i, kInt32POD, 6, "box", Box3iTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box3f, kFloat32POD, 6, "box", Box3fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Box3d, kFloat64POD, 6, "box", Box3dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(M33f, kFloat32POD, 9, "matrix", M33fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(M33d, kFloat64POD, 9, "matrix", M33dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(M44f, kFloat32POD, 16, "matrix", M44fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(M44d, kFloat64POD, 16, "matrix", M44dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Quatf, kFloat32POD, 4, "quat", QuatfTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(Quatd, kFloat64POD, 4, "quat", QuatdTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(C3h, kFloat16POD, 3, "rgb", C3hTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(C3f, kFloat32POD, 3, "rgb", C3fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(C3c, kUint8POD, 3, "rgb", C3cTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(C4h, kFloat16POD, 4, "rgba", C4hTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(C4f, kFloat32POD, 4, "rgba", C4fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(C4c, kUint8POD, 4, "rgba", C4cTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2f, kFloat32POD, 2, "normal", N2fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(V2d, kFloat64POD, 2, "normal", N2dTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(N3f, kFloat32POD, 3, "normal", N3fTPTraits)
Alembic::Abc::ALEMBIC_VERSION_NS::ALEMBIC_ABC_DECLARE_TYPE_TRAITS(N3d, kFloat64POD, 3, "normal", N3dTPTraits)
AbcA::CompoundPropertyWriterPtr GetCompoundPropertyWriterPtr(OCompoundProperty iPrp)
ALEMBIC_EXPORT void Alembic::Abc::ALEMBIC_VERSION_NS::SetReference(AbcA::MetaData & ioMetaData)
ALEMBIC_EXPORT bool Alembic::Abc::ALEMBIC_VERSION_NS::isReference(const AbcA::PropertyHeader & iHeader)
ALEMBIC_EXPORT void Alembic::Abc::ALEMBIC_VERSION_NS::SetSourceName(AbcA::MetaData & ioMetaData, const std::string & iName)
ALEMBIC_EXPORT std::string Alembic::Abc::ALEMBIC_VERSION_NS::GetSourceName(const AbcA::MetaData & iMetaData)
AbcA::ObjectWriterPtr GetObjectWriterPtr(OObject &iPrp)
template <class ARCHIVE_CTOR>
OArchive CreateArchiveWithInfo(ARCHIVE_CTOR iCtor, const std::string &iFileName, const std::string &iApplicationWriter, const std::string &iUserDescription, const Argument &iArg0 = Argument (), const Argument &iArg1 = Argument ())

Parameters
  • iCtor -

    We need to pass in a constructor which provides an explicit link to the concrete implementation of AbcCoreAbstract that we’re using.

  • iFileName -

    File name

  • iApplicationWriter -

    Application specific information about what is writing the file

  • iUserDescription -

    Extra information, could be arguments to the tool that is writing the file.

  • iArg0 -

    Optional meta data or error handling policy

  • iArg1 -

    Optional meta data or error handling policy

ALEMBIC_EXPORT void Alembic::Abc::ALEMBIC_VERSION_NS::GetArchiveInfo(IArchive & iArchive, std::string & oApplicationWriter, std::string & oAlembicVersion, Util::uint32_t & oAlembicApiVersion, std::string & oDateWritten, std::string & oUserDescription)

Parameters
  • iArchive -

    The Archive whose meta data will be inspected

  • oApplicationWriter -

    Application specific information about what wrote the file

  • oAlembicVersion -

    What version of Alembic wrote the file (and when it was built)

  • oAlembicApiVersion -

    Numeric version of the Alembic API that wrote the file

  • oDateWritten -

    The data that the file was originally written

  • oUserDescription -

    Extra information, could be arguments to the tool that wrote the file.

ALEMBIC_EXPORT void Alembic::Abc::ALEMBIC_VERSION_NS::GetArchiveStartAndEndTime(IArchive & iArchive, double & oStartTime, double & oEndTime)

Parameters
  • iArchive -

    The Archive to be inspected

  • oStartTime -

    The start time for the archive in seconds

  • oEndTime -

    The end time for the archive in seconds

Convenience function which gets a start and end time for the archive using only IArchive::getMaxNumSamplesForTimeSamplingIndex. The hierarchy is NOT walked. If the archive was written prior to 1.1.3 or no samples were written for any of the properties DBL_MAX will be set for oStartTime and -DBL_MAX will be set for oEndTime.

template <class SOMETHING>
ErrorHandler::Policy GetErrorHandlerPolicy(SOMETHING iSomething, const Argument &iArg0, const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())

This is for when you need to get the error handler policy out inside a constructor header.

ErrorHandler::Policy GetErrorHandlerPolicyFromArgs(const Argument &iArg0, const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())
AbcA::MetaData GetMetaData(const Argument &iArg0, const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())
AbcA::TimeSamplingPtr GetTimeSampling(const Argument &iArg0, const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())
uint32_t GetTimeSamplingIndex(const Argument &iArg0, const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())
SchemaInterpMatching GetSchemaInterpMatching(const Argument &iArg0, const Argument &iArg1 = Argument (), const Argument &iArg2 = Argument ())
AbcA::CompoundPropertyWriterPtr GetCompoundPropertyWriterPtr(AbcA::CompoundPropertyWriterPtr iPtr)
AbcA::CompoundPropertyReaderPtr GetCompoundPropertyReaderPtr(AbcA::CompoundPropertyReaderPtr iPtr)
AbcA::ObjectWriterPtr GetObjectWriterPtr(AbcA::ObjectWriterPtr iPtr)
AbcA::ObjectReaderPtr GetObjectReaderPtr(AbcA::ObjectReaderPtr iPtr)
AbcA::ArchiveWriterPtr GetArchiveWriterPtr(AbcA::ArchiveWriterPtr iPtr)
AbcA::ArchiveReaderPtr GetArchiveReaderPtr(AbcA::ArchiveReaderPtr iPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ArchiveWriterPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ObjectWriterPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::CompoundPropertyWriterPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ScalarPropertyWriterPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ArrayPropertyWriterPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ArchiveReaderPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ObjectReaderPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::CompoundPropertyReaderPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ScalarPropertyReaderPtr)
ErrorHandler::Policy GetErrorHandlerPolicy(AbcA::ArrayPropertyReaderPtr)

Variables

ALEMBIC_EXPORT_CONST char* Alembic::Abc::ALEMBIC_VERSION_NS::kApplicationNameKey
ALEMBIC_EXPORT_CONST char* Alembic::Abc::ALEMBIC_VERSION_NS::kDateWrittenKey
ALEMBIC_EXPORT_CONST char* Alembic::Abc::ALEMBIC_VERSION_NS::kUserDescriptionKey
namespace
file All.h
#include <Alembic/Abc/Base.h>#include <Alembic/Abc/ErrorHandler.h>#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/ArchiveInfo.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/IArchive.h>#include <Alembic/Abc/IArrayProperty.h>#include <Alembic/Abc/IBaseProperty.h>#include <Alembic/Abc/ICompoundProperty.h>#include <Alembic/Abc/IObject.h>#include <Alembic/Abc/ISampleSelector.h>#include <Alembic/Abc/IScalarProperty.h>#include <Alembic/Abc/ISchema.h>#include <Alembic/Abc/ISchemaObject.h>#include <Alembic/Abc/ITypedArrayProperty.h>#include <Alembic/Abc/ITypedScalarProperty.h>#include <Alembic/Abc/OArchive.h>#include <Alembic/Abc/OArrayProperty.h>#include <Alembic/Abc/OBaseProperty.h>#include <Alembic/Abc/OCompoundProperty.h>#include <Alembic/Abc/OObject.h>#include <Alembic/Abc/OScalarProperty.h>#include <Alembic/Abc/OSchema.h>#include <Alembic/Abc/OSchemaObject.h>#include <Alembic/Abc/OTypedArrayProperty.h>#include <Alembic/Abc/OTypedScalarProperty.h>#include <Alembic/Abc/Reference.h>#include <Alembic/Abc/SourceName.h>#include <Alembic/Abc/TypedArraySample.h>#include <Alembic/Abc/TypedPropertyTraits.h>
file ArchiveInfo.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/IArchive.h>#include <Alembic/Abc/OArchive.h>#include <time.h>
file Argument.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/ErrorHandler.h>
file Base.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/ErrorHandler.h>
file ErrorHandler.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>

Defines

ALEMBIC_ABC_SAFE_CALL_BEGIN(CONTEXT)
ALEMBIC_ABC_SAFE_CALL_END_RESET
ALEMBIC_ABC_SAFE_CALL_END
file Foundation.h
#include <Alembic/AbcCoreAbstract/All.h>#include <Alembic/Util/All.h>#include <ImathVec.h>#include <ImathBox.h>#include <ImathMatrix.h>#include <ImathQuat.h>#include <ImathColor.h>#include <iostream>#include <string>#include <exception>#include <stdlib.h>#include <stdio.h>#include <string.h>#include <assert.h>
file IArchive.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>
file IArrayProperty.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/ISampleSelector.h>#include <Alembic/Abc/IBaseProperty.h>#include <Alembic/Abc/ICompoundProperty.h>
file IBaseProperty.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/IObject.h>#include <Alembic/Abc/IArchive.h>
file ICompoundProperty.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/IBaseProperty.h>
file IObject.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>
file ISampleSelector.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>
file IScalarProperty.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/ISampleSelector.h>#include <Alembic/Abc/IBaseProperty.h>#include <Alembic/Abc/ICompoundProperty.h>
file ISchema.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/OSchema.h>#include <Alembic/Abc/ICompoundProperty.h>
file ISchemaObject.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/IObject.h>#include <Alembic/Abc/ISchema.h>#include <Alembic/Abc/Base.h>
file ITypedArrayProperty.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/IArrayProperty.h>#include <Alembic/Abc/TypedPropertyTraits.h>#include <Alembic/Abc/TypedArraySample.h>
file ITypedScalarProperty.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/IScalarProperty.h>#include <Alembic/Abc/TypedPropertyTraits.h>
file OArchive.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>
file OArrayProperty.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/OBaseProperty.h>#include <Alembic/Abc/OCompoundProperty.h>
file OBaseProperty.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/OObject.h>#include <Alembic/Abc/OArchive.h>
file OCompoundProperty.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/OBaseProperty.h>
file OObject.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>
file OScalarProperty.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/Base.h>#include <Alembic/Abc/Argument.h>#include <Alembic/Abc/OBaseProperty.h>#include <Alembic/Abc/OCompoundProperty.h>
file OSchema.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/OCompoundProperty.h>

Defines

ALEMBIC_ABC_DECLARE_SCHEMA_INFO(STITLE, SBTYP, SDFLT, STDEF)

With properties, specific flavors of properties are expressed via the TypedScalarProperty and the TypedArrayProperty. Compound Properties are more complex, and the specific flavors require a more complex treatment - That’s what Schemas are. The CompoundProperty equivalent of a TypedArrayProperty or a TypedScalarProperty.

A Schema is a collection of grouped properties which implement some complex object, such as a poly mesh. In the simpelest, standard case, there will be a compound property at the top with a certain name, and inside the compound property will be some number of additional properties that implement the object. In the case of a poly mesh, these properties would include a list of vertices (a V3fArray), a list of indices (an Int32Array), and a list of “per-face counts” (also an Int32Array).

In somewhat more complex cases, such as a TransformStack, the set of properties that are added may vary based on configuration information provided by the user.

Because a Schema is to a CompoundProperty what a TypedArrayProperty or TypedScalarProperty is to a regular property, it is directly derived from CompoundProperty. However... Whereas TypedProperties can be instanced as typedefs, Schemas will invariably require additional functionality, and thus the StdCompoundSchema is intended for use as a base class. Here is a macro for declaring SCHEMA_INFO It takes three arguments

  • the SchemaTitle( a string ),
  • the SchemaBaseType( a string ),
  • the DefaultSchemaName( a string )
  • the name of the SchemaTrait Type to be declared.
  • for example: ALEMBIC_ABC_DECLARE_SCHEMA_INFO( “AbcGeom_PolyMesh_v1”, ”.geom”, PolyMeshSchemaInfo );

file OSchemaObject.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/OObject.h>#include <Alembic/Abc/OSchema.h>
file OTypedArrayProperty.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/OArrayProperty.h>#include <Alembic/Abc/TypedPropertyTraits.h>#include <Alembic/Abc/TypedArraySample.h>
file OTypedScalarProperty.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/OScalarProperty.h>#include <Alembic/Abc/TypedPropertyTraits.h>
file Reference.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>
file SourceName.h
#include <Alembic/Util/Export.h>#include <Alembic/Abc/Foundation.h>
file TypedArraySample.h
#include <Alembic/Abc/Foundation.h>#include <Alembic/Abc/TypedPropertyTraits.h>
file TypedPropertyTraits.h
#include <Alembic/Abc/Foundation.h>

Defines

ALEMBIC_ABC_DECLARE_TYPE_TRAITS(VAL, POD, EXTENT, INTERP, PTDEF)
DECLARE_POD_TRAITS(POD_TYPE, PTDEF)