301 lines
10 KiB
C++
301 lines
10 KiB
C++
//-*****************************************************************************
|
|
//
|
|
// Copyright (c) 2009-2012,
|
|
// Sony Pictures Imageworks Inc. and
|
|
// Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Sony Pictures Imageworks, nor
|
|
// Industrial Light & Magic, nor the names of their contributors may be used
|
|
// to endorse or promote products derived from this software without specific
|
|
// prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
//-*****************************************************************************
|
|
|
|
#include <Foundation.h>
|
|
|
|
using namespace boost::python;
|
|
|
|
//-*****************************************************************************
|
|
class ChildIterator
|
|
{
|
|
public:
|
|
ChildIterator( Abc::IObject &p )
|
|
: _p( p ) , _iter( 0 ), _end( p.getNumChildren() ) {}
|
|
|
|
Abc::IObject next()
|
|
{
|
|
if ( _iter >= _end )
|
|
boost::python::objects::stop_iteration_error();
|
|
|
|
return _p.getChild( _iter++ );
|
|
}
|
|
private:
|
|
Abc::IObject _p;
|
|
size_t _iter;
|
|
size_t _end;
|
|
};
|
|
|
|
//-*****************************************************************************
|
|
class ChildList
|
|
{
|
|
public:
|
|
ChildList( Abc::IObject &p )
|
|
: _p( p ) {}
|
|
|
|
Py_ssize_t len()
|
|
{
|
|
return (Py_ssize_t)_p.getNumChildren();
|
|
}
|
|
|
|
Abc::IObject getItem( Py_ssize_t index )
|
|
{
|
|
return _p.getChild( ( AbcA::index_t )index );
|
|
}
|
|
|
|
ChildIterator* getIterator()
|
|
{
|
|
return new ChildIterator( _p );
|
|
}
|
|
private:
|
|
Abc::IObject _p;
|
|
};
|
|
|
|
//-*****************************************************************************
|
|
static ChildList getChildList( Abc::IObject& p)
|
|
{
|
|
return ChildList(p);
|
|
}
|
|
|
|
//-*****************************************************************************
|
|
static Abc::IObject getChildByIndex( Abc::IObject &o, size_t i )
|
|
{
|
|
if ( i >= o.getNumChildren() )
|
|
{
|
|
std::stringstream stream;
|
|
stream << i;
|
|
throwPythonIndexException( stream.str().c_str() );
|
|
}
|
|
const Abc::IObject& c = o.getChild( i );
|
|
if ( !c.valid() )
|
|
{
|
|
return Abc::IObject();
|
|
}
|
|
return c;
|
|
}
|
|
|
|
//-*****************************************************************************
|
|
static Abc::IObject getChildByName( Abc::IObject &o, const std::string& name )
|
|
{
|
|
const Abc::IObject& c = o.getChild( name );
|
|
if ( c.valid() )
|
|
{
|
|
return c;
|
|
}
|
|
|
|
std::stringstream stream;
|
|
stream << name;
|
|
throwPythonKeyException( stream.str().c_str() );
|
|
return Abc::IObject();
|
|
}
|
|
|
|
//-*****************************************************************************
|
|
static bool isChildInstanceByIndex( Abc::IObject &o, size_t i )
|
|
{
|
|
if ( i >= o.getNumChildren() )
|
|
{
|
|
std::stringstream stream;
|
|
stream << i;
|
|
throwPythonIndexException( stream.str().c_str() );
|
|
}
|
|
const Abc::IObject& c = o.getChild( i );
|
|
if ( !c.valid() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return c.isInstanceDescendant();
|
|
}
|
|
|
|
//-*****************************************************************************
|
|
static bool isChildInstanceByName( Abc::IObject &o, const std::string& name )
|
|
{
|
|
const Abc::IObject& c = o.getChild( name );
|
|
if ( c.valid() )
|
|
{
|
|
return c.isInstanceDescendant();
|
|
}
|
|
|
|
std::stringstream stream;
|
|
stream << name;
|
|
throwPythonKeyException( stream.str().c_str() );
|
|
return false;
|
|
}
|
|
|
|
//-*****************************************************************************
|
|
static std::string getPropertiesHash( Abc::IObject &o )
|
|
{
|
|
Alembic::Util::Digest pHash;
|
|
if ( !o.getPropertiesHash( pHash ) )
|
|
return "";
|
|
|
|
return pHash.str();
|
|
}
|
|
|
|
//-*****************************************************************************
|
|
static std::string getChildrenHash( Abc::IObject &o )
|
|
{
|
|
Alembic::Util::Digest cHash;
|
|
if ( !o.getChildrenHash( cHash ) )
|
|
return "";
|
|
|
|
return cHash.str();
|
|
}
|
|
|
|
//-*****************************************************************************
|
|
void register_iobject()
|
|
{
|
|
// overloads
|
|
//
|
|
const AbcA::ObjectHeader&
|
|
( Abc::IObject::*getChildHeaderByIndex )( size_t ) const = \
|
|
&Abc::IObject::getChildHeader;
|
|
|
|
const AbcA::ObjectHeader*
|
|
( Abc::IObject::*getChildHeaderByName )( const std::string & ) const = \
|
|
&Abc::IObject::getChildHeader;
|
|
|
|
// IObject
|
|
//
|
|
class_<Abc::IObject>(
|
|
"IObject",
|
|
"The IObject class as an object reader",
|
|
init<Abc::IObject, const std::string&>(
|
|
( arg( "parent" ), arg( "name" ) ),
|
|
"Create an IObject with the given parent IObject and name" ) )
|
|
.def( init<>( "Create an empty IObject" ) )
|
|
.def( "getHeader",
|
|
&Abc::IObject::getHeader,
|
|
"Return the header which contains all the MetaData that was "
|
|
"specified upon their creation",
|
|
return_internal_reference<1>() )
|
|
.def( "getName",
|
|
&Abc::IObject::getName,
|
|
"Return the name of this object. The name is unique amongst "
|
|
"their siblings",
|
|
return_value_policy<copy_const_reference>() )
|
|
.def( "getFullName",
|
|
&Abc::IObject::getFullName,
|
|
"Return the full name of this object. The full name is unique "
|
|
"within the entire archive",
|
|
return_value_policy<copy_const_reference>() )
|
|
.def( "getNumChildren",
|
|
&Abc::IObject::getNumChildren,
|
|
"Return the number of child IObjects that this object has" )
|
|
.def( "getChildHeader",
|
|
getChildHeaderByIndex,
|
|
( arg( "index" ) ),
|
|
"Return the header of a child IObject with the given index",
|
|
return_internal_reference<1>() )
|
|
.def( "getChildHeader",
|
|
getChildHeaderByName,
|
|
( arg( "name" ) ),
|
|
"Return the header of a child IObject with the given name",
|
|
return_value_policy<reference_existing_object>() )
|
|
.def( "getProperties",
|
|
&Abc::IObject::getProperties,
|
|
"Return the single top-level ICompoundProperty",
|
|
with_custodian_and_ward_postcall<0,1>() )
|
|
.def( "getChild",
|
|
&getChildByIndex,
|
|
( arg( "index" ) ),
|
|
"Return a child IObject with the given index",
|
|
with_custodian_and_ward_postcall<0,1>() )
|
|
.def( "getChild",
|
|
&getChildByName,
|
|
( arg( "name" ) ),
|
|
"Return a child IObject with the given name",
|
|
with_custodian_and_ward_postcall<0,1>() )
|
|
.def( "getArchive",
|
|
&Abc::IObject::getArchive,
|
|
"Return this object's archive",
|
|
with_custodian_and_ward_postcall<0,1>() )
|
|
.def( "getParent",
|
|
&Abc::IObject::getParent,
|
|
"Return this object's parent\n"
|
|
"If the object is the top level object, the IObject returned "
|
|
"will be an empty Object",
|
|
with_custodian_and_ward_postcall<0,1>() )
|
|
.def( "getMetaData",
|
|
&Abc::IObject::getMetaData,
|
|
"Return the MetaData of this object",
|
|
return_internal_reference<1>() )
|
|
.def( "isInstanceRoot",
|
|
&Abc::IObject::isInstanceRoot,
|
|
"Return true if this IObject is an instance root" )
|
|
.def( "isInstanceDescendant",
|
|
&Abc::IObject::isInstanceDescendant,
|
|
"Return true if this IObject is an instanceRoot, or an ancestor of one" )
|
|
.def( "instanceSourcePath",
|
|
&Abc::IObject::instanceSourcePath,
|
|
"Return the instance source path that the instance points at. Empty string if not found." )
|
|
.def( "isChildInstance",
|
|
&isChildInstanceByIndex,
|
|
( arg( "index" ) ),
|
|
"Return true if the child by index is an instance root object" )
|
|
.def( "isChildInstance",
|
|
&isChildInstanceByName,
|
|
( arg( "name" ) ),
|
|
"Return true if the named child is an instance root object" )
|
|
.def( "getPropertiesHash",
|
|
&getPropertiesHash,
|
|
"Return a string representation of the properties hash for this object. Empty string if not found." )
|
|
.def( "getChildrenHash",
|
|
&getChildrenHash,
|
|
"Return a string representation of the children hash for this object. Empty string if not found." )
|
|
.def( "valid", &Abc::IObject::valid )
|
|
.def( "reset", &Abc::IObject::reset )
|
|
.def( "__str__", &Abc::IObject::getFullName,
|
|
return_value_policy<copy_const_reference>() )
|
|
.def( ALEMBIC_PYTHON_BOOL_NAME, &Abc::IObject::valid )
|
|
.add_property( "children", &getChildList )
|
|
;
|
|
|
|
// List and Iterator for child IObjects
|
|
//
|
|
class_<ChildList>
|
|
( "ChildList", no_init )
|
|
.def( "__len__", &ChildList::len )
|
|
.def( "__getitem__", &ChildList::getItem )
|
|
.def( "__iter__", &ChildList::getIterator,
|
|
return_value_policy<manage_new_object>() )
|
|
;
|
|
|
|
class_<ChildIterator>
|
|
( "ChildIterator", no_init )
|
|
.def( ALEMBIC_PYTHON_NEXT_NAME, &ChildIterator::next )
|
|
;
|
|
}
|