C++ ArchiveReaderPtr::getTop方法代码示例

void readArchive( const ABCA::ArchiveReaderPtr& iArchiveReader)
{
    std::vector< ABCA::ObjectReaderPtr > objs;
    objs.push_back( iArchiveReader->getTop() );
    TESTING_ASSERT( objs[0]->getNumChildren() == 2 );
    objs.push_back( objs[0]->getChild(0) );
    objs.push_back( objs[0]->getChild(1) );

    std::size_t numObjs = objs.size();
    for (std::size_t i = 1; i < numObjs; ++i)
    {
        TESTING_ASSERT( objs[i]->getNumChildren() == 3 );
        for (std::size_t j = 0; j < numObjs; ++j)
        {
            objs.push_back( objs[i]->getChild(j) );
        }
    }

    for (std::size_t i = 0; i < objs.size(); ++i)
    {
        TESTING_ASSERT( objs[i]->getProperties()->getNumProperties() == 3 );

        ABCA::CompoundPropertyReaderPtr cpr = objs[i]->getProperties();
        ABCA::ArrayPropertyReaderPtr apr = cpr->getArrayProperty("a");

        TESTING_ASSERT( 0 ==
            objs[i]->getProperties()->getArrayProperty("a")->getNumSamples() );
        TESTING_ASSERT( 1 ==
            objs[i]->getProperties()->getArrayProperty("b")->getNumSamples() );
        TESTING_ASSERT( 2 ==
            objs[i]->getProperties()->getArrayProperty("c")->getNumSamples() );
    }

    TESTING_ASSERT( iArchiveReader->getMaxNumSamplesForTimeSamplingIndex(0) == 2 );
}

void testReadWriteEmptyArchive()
{
    std::string archiveName = "emptyArchive.abc";

    {
        AO::WriteArchive w;
        ABCA::MetaData m;
        m.set("Bleep", "bloop");
        m.set("eep", "");
        m.set("potato", "salad");
        m.set("geoScope", "tasty");

        ABCA::ArchiveWriterPtr a = w(archiveName, m);
        ABCA::ObjectWriterPtr archive = a->getTop();

        TESTING_ASSERT(archive->getFullName() == "/");

        Alembic::AbcCoreOgawa::ReadArchive r;

        // can't read an already open archive (for now)
        TESTING_ASSERT_THROW(r( archiveName ), Alembic::Util::Exception);

    }

    {
        AO::ReadArchive r;
        ABCA::ArchiveReaderPtr a = r( archiveName );
        ABCA::ObjectReaderPtr archive = a->getTop();
        ABCA::MetaData m = archive->getHeader().getMetaData();
        TESTING_ASSERT(m.get("Bleep") == "bloop");
        TESTING_ASSERT(m.get("eep") == "");
        TESTING_ASSERT(m.get("potato") == "salad");
        TESTING_ASSERT(m.get("geoScope") == "tasty");
        TESTING_ASSERT(archive->getName() == "ABC");
        TESTING_ASSERT(archive->getFullName() == "/");
        TESTING_ASSERT(archive->getParent() == NULL);
        TESTING_ASSERT(archive->getNumChildren() == 0);

        // even though we didn't write anything make sure we intrincially have
        // the default sampling
        TESTING_ASSERT(a->getNumTimeSamplings() == 1);
        TESTING_ASSERT(*(a->getTimeSampling(0)) == ABCA::TimeSampling());
        TESTING_ASSERT(a->getMaxNumSamplesForTimeSamplingIndex(0) == 0);

        ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
        TESTING_ASSERT(parent->getNumProperties() == 0);

        // get it again to make sure we clean ourselves up properly
        AO::ReadArchive r2;
        ABCA::ArchiveReaderPtr a2 = r2( archiveName );
        ABCA::ObjectReaderPtr archive2 = a2->getTop();
        ABCA::CompoundPropertyReaderPtr p2 = archive2->getProperties();
        TESTING_ASSERT(p2->getNumProperties() == 0);
    }
}

void readArchive( const std::string & iName, std::istream * iStream )
{
    std::vector< std::istream * > streamVec;
    if (iStream)
    {
        streamVec.push_back(iStream);
    }
    Alembic::AbcCoreOgawa::ReadArchive r(streamVec);
    ABCA::ArchiveReaderPtr a = r( iName );
    std::vector< ABCA::ObjectReaderPtr > objs;
    objs.push_back( a->getTop() );
    TESTING_ASSERT( objs[0]->getNumChildren() == 2 );
    objs.push_back( objs[0]->getChild(0) );
    objs.push_back( objs[0]->getChild(1) );

    std::size_t numObjs = objs.size();
    for (std::size_t i = 1; i < numObjs; ++i)
    {
        TESTING_ASSERT( objs[i]->getNumChildren() == 3 );
        for (std::size_t j = 0; j < numObjs; ++j)
        {
            objs.push_back( objs[i]->getChild(j) );
        }
    }

    for (std::size_t i = 0; i < objs.size(); ++i)
    {
        TESTING_ASSERT( objs[i]->getProperties()->getNumProperties() == 3 );

        ABCA::CompoundPropertyReaderPtr cpr = objs[i]->getProperties();
        ABCA::ArrayPropertyReaderPtr apr = cpr->getArrayProperty("a");

        TESTING_ASSERT( 0 ==
            objs[i]->getProperties()->getArrayProperty("a")->getNumSamples() );
        TESTING_ASSERT( 1 ==
            objs[i]->getProperties()->getArrayProperty("b")->getNumSamples() );
        TESTING_ASSERT( 2 ==
            objs[i]->getProperties()->getArrayProperty("c")->getNumSamples() );
    }

    TESTING_ASSERT( a->getMaxNumSamplesForTimeSamplingIndex(0) == 2 );
}

void testReadWriteEmptyArchive()
{
    std::string archiveName = "emptyArchive.abc";

    {
        A5::WriteArchive w;
        ABCA::MetaData m;
        m.set("Bleep", "bloop");
        m.set("eep", "");
        m.set("potato", "salad");
        m.set("geoScope", "tasty");

        ABCA::ArchiveWriterPtr a = w(archiveName, m);
        ABCA::ObjectWriterPtr archive = a->getTop();

        TESTING_ASSERT(archive->getFullName() == "/");

        // use this to get current reporting mechanism, then supress it
        // since we expect to see H5F errors because we will be trying to open
        // a file that is already open for writing.
        H5E_auto_t func;
        void * client_data;
        H5Eget_auto2(H5E_DEFAULT, &func, &client_data);
        H5Eset_auto2(H5E_DEFAULT, NULL, NULL);

        // can't write an already open archive
        TESTING_ASSERT_THROW(w(archiveName, ABCA::MetaData()),
            Alembic::Util::Exception);

        Alembic::AbcCoreHDF5::ReadArchive r;

        // can't read an already open archive
        TESTING_ASSERT_THROW(r( archiveName ), Alembic::Util::Exception);

        // turn the error reporting back on for later tests
        H5Eset_auto2(H5E_DEFAULT, func, client_data);

    }

    {
        A5::ReadArchive r;
        ABCA::ArchiveReaderPtr a = r( archiveName );
        ABCA::ObjectReaderPtr archive = a->getTop();
        ABCA::MetaData m = archive->getHeader().getMetaData();
        TESTING_ASSERT(m.get("Bleep") == "bloop");
        TESTING_ASSERT(m.get("eep") == "");
        TESTING_ASSERT(m.get("potato") == "salad");
        TESTING_ASSERT(m.get("geoScope") == "tasty");
        TESTING_ASSERT(archive->getName() == "ABC");
        TESTING_ASSERT(archive->getFullName() == "/");
        TESTING_ASSERT(archive->getParent() == NULL);
        TESTING_ASSERT(archive->getNumChildren() == 0);

        // even though we didn't write anything make sure we intrincially have
        // the default sampling
        TESTING_ASSERT(a->getNumTimeSamplings() == 1);
        TESTING_ASSERT(*(a->getTimeSampling(0)) == ABCA::TimeSampling());
        TESTING_ASSERT(a->getMaxNumSamplesForTimeSamplingIndex(0) == 0);

        ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
        TESTING_ASSERT(parent->getNumProperties() == 0);

        // get it again to make sure we clean ourselves up properly
        A5::ReadArchive r2;
        ABCA::ArchiveReaderPtr a2 = r2( archiveName );
        ABCA::ObjectReaderPtr archive2 = a2->getTop();
        ABCA::CompoundPropertyReaderPtr p2 = archive2->getProperties();
        TESTING_ASSERT(p2->getNumProperties() == 0);
    }
}

void readVeryEmptyArchive( const std::string & iName, bool iCache )
{
    Alembic::AbcCoreHDF5::ReadArchive r( iCache );
    ABCA::ArchiveReaderPtr a = r( iName );
    TESTING_ASSERT(a->getTop()->getNumChildren() == 0);
}

//-*****************************************************************************
void ReadTestArchive( const std::string &iArchiveName )
{
    // When opening an archive for reading, you can pass in a pointer to
    // an AbcA::ReadArraySampleCache, but if you don't, it will construct one
    // for you by default.  If you don't want to cache, just pass in NULL
    // as the second argument.
    Alembic::AbcCoreHDF5::ReadArchive ar;
    AbcA::ArchiveReaderPtr arkive = ar( iArchiveName );

    // Just stashing away a compound property reader pointer; we know the last
    // child object in our hierarchy has all the properties, because we created
    // it in the WriteTestArchive function.
    AbcA::CompoundPropertyReaderPtr fcProps;

    // Now do a depth-first traversal of our archive; this is a little ugly
    AbcA::ObjectReaderPtr tmpOrp1;
    AbcA::ObjectReaderPtr tmpOrp2 = arkive->getTop();
    while ( true )
    {
        tmpOrp1 = tmpOrp2;

        if ( tmpOrp1->getNumChildren() < 1 )
        {
            std::cout << "Found my last lonely child, named "
                      << tmpOrp1->getFullName() << std::endl;
            fcProps = tmpOrp1->getProperties();

            std::cout << "It has " << fcProps->getNumProperties()
                      << " sub-properties." << std::endl;
            break;
        }

        tmpOrp2 = tmpOrp1->getChild( 0 );
    }

    // OK, fcProps is a shared pointer to the compound property reader that
    // was in the last child object of the archive.  Let's get the simple
    // properties out of it.
    AbcA::ScalarPropertyReaderPtr sProp;
    AbcA::ArrayPropertyReaderPtr aProp0;
    AbcA::ArrayPropertyReaderPtr aProp1;
    for ( size_t i = 0 ; i < fcProps->getNumProperties() ; ++i )
    {
        AbcA::BasePropertyReaderPtr bp = fcProps->getProperty( i );
        std::cout << "Found " << bp->getName() << std::endl;
        if ( bp->isScalar() )
        {
            sProp = bp->asScalarPtr();
            std::cout << "sProp has " << sProp->getNumSamples()
                      << " samples." << std::endl;
        }
        if ( bp->isArray() && bp->getName() == "secondInt32ArrayProp" )
        {
            aProp1 = bp->asArrayPtr();
            std::cout << "aProp1 has " << aProp1->getNumSamples()
                      << " samples." << std::endl;
        }
        if ( bp->isArray() && bp->getName() == "firstInt32ArrayProp" )
        {
            aProp0 = bp->asArrayPtr();
            std::cout << "aProp0 has " << aProp0->getNumSamples()
                      << " samples." << std::endl;
        }
    }

    // OK, now we have pointers to the two properties, one scalar, the other
    // array.  Let's read the scalar one first.
    for ( size_t i = 0 ; i < sProp->getNumSamples() ; ++i )
    {
        float32_t sVal = 0;
        sProp->getSample( i, (void*)(&sVal) );

        TESTING_ASSERT( sVal == 42.0 );

        std::cout << sProp->getName() << " at sample " << i << " has the value "
                  << sVal << std::endl << std::endl;
    }

    // OK, now the first int array property.
    AbcA::ArraySamplePtr samp;

    std::cout << "FIRST INT ARRAY PROPERTY (Cyclic time sampling)"
              << std::endl;
    for ( size_t i = 0 ; i < aProp0->getNumSamples() ; ++i )
    {
        aProp0->getSample( i, samp );
        const AbcA::TimeSampling ts = aProp0->getTimeSampling();
        size_t numPoints = samp->getDimensions().numPoints();

        TESTING_ASSERT( (AbcA::chrono_t)i == ts.getSampleTime( i ) );

        std::cout << "At Sample " << i << ", " << aProp0->getName()
                  << " is at time " << ts.getSampleTime( i )
                  << " and has " << numPoints << " points, with the values: "
                  << std::endl;

        int32_t *vals = (int32_t*)(samp->getData());

        for ( size_t j = 0 ; j < numPoints ; ++j )
//.........这里部分代码省略.........

//-*****************************************************************************
void testWeirdStringScalar()
{
    std::string archiveName = "weirdStr.abc";

    Alembic::Util::string weirdStr = "Total failure";
    weirdStr[5] = '\0';

    Alembic::Util::wstring weirdWstr = L"Failure is always an option";
    weirdWstr[5] = L'\0';

    std::vector < Alembic::Util::string > weirdStrArray(3);
    weirdStrArray[0] = "watch";
    weirdStrArray[1] = "this";
    weirdStrArray[2] = "please";
    weirdStrArray[2][3] = '\0';

    Alembic::Util::string empty;
    Alembic::Util::wstring wempty;

    std::vector < Alembic::Util::string > allEmptyStr(3);

    std::vector < Alembic::Util::string > partEmptyStr(6);
    partEmptyStr[0] = "";
    partEmptyStr[1] = "";
    partEmptyStr[2] = "notEmpty!";
    partEmptyStr[3] = "";
    partEmptyStr[4] = "also not empty";
    partEmptyStr[5] = "";

    {
        A5::WriteArchive w;
        AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData());
        AbcA::ObjectWriterPtr archive = a->getTop();

        AbcA::CompoundPropertyWriterPtr props = archive->getProperties();

        {

            AbcA::ScalarPropertyWriterPtr emptyWrtPtr =
                props->createScalarProperty("empty", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kStringPOD, 1), 0);

            // this should fail because of the NULL char in the string
            TESTING_ASSERT_THROW(emptyWrtPtr->setSample(&weirdStr),
                Alembic::Util::Exception);

            emptyWrtPtr->setSample(&empty);

            AbcA::ScalarPropertyWriterPtr wemptyWrtPtr =
                props->createScalarProperty("wempty", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kWstringPOD, 1), 0);

            // this should fail because of the NULL char in the string
            TESTING_ASSERT_THROW(wemptyWrtPtr->setSample(&weirdWstr),
                                 Alembic::Util::Exception);

            wemptyWrtPtr->setSample(&wempty);


            AbcA::ScalarPropertyWriterPtr allEmptyWrtPtr =
                props->createScalarProperty("allEmpty", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kStringPOD, 3), 0);

            // one of the strings has a NULL char in it
            TESTING_ASSERT_THROW(
                allEmptyWrtPtr->setSample(&(weirdStrArray.front())),
                Alembic::Util::Exception);

            allEmptyWrtPtr->setSample(&(allEmptyStr.front()));

            AbcA::ScalarPropertyWriterPtr partEmptyStrPtr =
                props->createScalarProperty("partEmpty", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kStringPOD, 6), 0);

            partEmptyStrPtr->setSample(&(partEmptyStr.front()));
        }
    }

    {
        A5::ReadArchive r;
        AbcA::ArchiveReaderPtr a = r( archiveName );
        AbcA::ObjectReaderPtr archive = a->getTop();
        AbcA::CompoundPropertyReaderPtr parent = archive->getProperties();

        for (size_t i = 0; i < parent->getNumProperties(); ++i)
        {
            AbcA::BasePropertyReaderPtr bp = parent->getProperty( i );
            if (bp->getName() == "partEmpty")
            {
                std::vector < Alembic::Util::string > val (6);
                AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr();
                TESTING_ASSERT(sp->getDataType().getExtent() == 6);
                sp->getSample(0, &(val.front()));
                TESTING_ASSERT(val == partEmptyStr);
            }
            else if (bp->getName() == "allEmpty")
            {
                std::vector < Alembic::Util::string > val (3);
                AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr();
//.........这里部分代码省略.........

//-*****************************************************************************
void testRepeatedScalarData()
{
    std::string archiveName = "repeatScalarData.abc";

    {
        A5::WriteArchive w;
        AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData());
        AbcA::ObjectWriterPtr archive = a->getTop();

        AbcA::CompoundPropertyWriterPtr parent = archive->getProperties();

        AbcA::ScalarPropertyWriterPtr swp =
            parent->createScalarProperty("int32", AbcA::MetaData(),
                AbcA::DataType(Alembic::Util::kInt32POD, 3), 0);

        std::vector <Alembic::Util::uint32_t> ui(3);
        ui[0] = 0;
        ui[1] = 1;
        ui[2] = 2;

        std::vector <Alembic::Util::uint32_t> ui2(3);
        ui2[0] = 41;
        ui2[1] = 43;
        ui2[2] = 47;

        swp->setSample(&(ui.front()));
        swp->setSample(&(ui.front()));
        swp->setSample(&(ui2.front()));
        swp->setSample(&(ui.front()));
        swp->setSample(&(ui2.front()));
        swp->setSample(&(ui2.front()));
        swp->setSample(&(ui2.front()));
        swp->setSample(&(ui.front()));
        swp->setSample(&(ui.front()));
        swp->setSample(&(ui.front()));

        AbcA::ScalarPropertyWriterPtr swp2 =
            parent->createScalarProperty("float32", AbcA::MetaData(),
                AbcA::DataType(Alembic::Util::kFloat32POD, 1), 0);

        Alembic::Util::float32_t f = 42.0;
        Alembic::Util::float32_t f2 = -3.0;

        swp2->setSample(&f);
        swp2->setSample(&f);
        swp2->setSample(&f);
        swp2->setSample(&f2);
        swp2->setSample(&f2);
        swp2->setSample(&f2);

        AbcA::ScalarPropertyWriterPtr swp3 =
            parent->createScalarProperty("uint16", AbcA::MetaData(),
                AbcA::DataType(Alembic::Util::kUint16POD, 1), 0);

        Alembic::Util::uint16_t ui16 = 17;

        swp3->setSample(&ui16);
        swp3->setSample(&ui16);
        swp3->setSample(&ui16);
        swp3->setSample(&ui16);

        AbcA::ScalarPropertyWriterPtr swp4 =
            parent->createScalarProperty("str", AbcA::MetaData(),
                AbcA::DataType(Alembic::Util::kStringPOD, 3), 0);

        std::vector < Alembic::Util::string > strVec(3);
        strVec[0] = "Please";
        strVec[1] = "";
        strVec[2] = "work";

        std::vector < Alembic::Util::string > strVec2(3);
        strVec2[0] = "Whats";
        strVec2[1] = "going";
        strVec2[2] = "on?";

        swp4->setSample(&(strVec.front()));
        swp4->setSample(&(strVec.front()));
        swp4->setSample(&(strVec2.front()));
        swp4->setSample(&(strVec2.front()));
    }

    {
        A5::ReadArchive r;
        AbcA::ArchiveReaderPtr a = r( archiveName );
        AbcA::ObjectReaderPtr archive = a->getTop();

        AbcA::CompoundPropertyReaderPtr parent = archive->getProperties();
        TESTING_ASSERT(parent->getNumProperties() == 4);
        for (size_t i = 0; i < parent->getNumProperties(); ++i)
        {
            AbcA::BasePropertyReaderPtr bp = parent->getProperty( i );
            AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr();
            switch (sp->getDataType().getPod())
            {
                case Alembic::Util::kUint16POD:
                {
                    TESTING_ASSERT( sp->getNumSamples() == 4 );

                    const AbcA::TimeSamplingPtr t = sp->getTimeSampling();
//.........这里部分代码省略.........

//-*****************************************************************************
void testReadWriteScalars()
{

    std::string archiveName = "staticProperties.abc";

    {
        A5::WriteArchive w;
        AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData());
        AbcA::ObjectWriterPtr archive = a->getTop();

        AbcA::CompoundPropertyWriterPtr props = archive->getProperties();

        const AbcA::TimeSamplingType staticSampling;

        {
            AbcA::ScalarPropertyWriterPtr boolWrtPtr =
                props->createScalarProperty("bool",  AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kBooleanPOD, 1), 0);
            Alembic::Util::bool_t b = true;
            boolWrtPtr->setSample(&b);
        }


        {
            AbcA::ScalarPropertyWriterPtr ucharWrtPtr =
                props->createScalarProperty("uchar",  AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kUint8POD, 1), 0);

            Alembic::Util::uint8_t uc = 200;

            TESTING_ASSERT(ucharWrtPtr->getNumSamples() == 0);
            ucharWrtPtr->setSample(&uc);
            TESTING_ASSERT(ucharWrtPtr->getNumSamples() == 1);
        }

        {
            AbcA::ScalarPropertyWriterPtr charWrtPtr =
                props->createScalarProperty("char",  AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kInt8POD, 1), 0);

            Alembic::Util::int8_t c = -20;
            charWrtPtr->setSample(&c);
        }

        {
            AbcA::ScalarPropertyWriterPtr ushortWrtPtr =
                props->createScalarProperty("ushort", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kUint16POD, 1), 0);

            Alembic::Util::uint16_t us = 60000;
            ushortWrtPtr->setSample(&us);
        }

        {
            AbcA::ScalarPropertyWriterPtr shortWrtPtr =
                props->createScalarProperty("short", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kInt16POD, 1), 0);
            Alembic::Util::int16_t s = -20000;
            shortWrtPtr->setSample(&s);
        }

        {
            AbcA::ScalarPropertyWriterPtr uintWrtPtr =
                props->createScalarProperty("uint", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kUint32POD, 1), 0);
            Alembic::Util::uint32_t ui = 1000000;
            uintWrtPtr->setSample(&ui);
        }

        {
            AbcA::ScalarPropertyWriterPtr intWrtPtr =
                props->createScalarProperty("int", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kInt32POD, 1), 0);
            Alembic::Util::int32_t i = -1000000;
            intWrtPtr->setSample(&i);
        }

        {
            AbcA::ScalarPropertyWriterPtr ui64WrtPtr =
                props->createScalarProperty("uint64", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kUint64POD, 1), 0);
            Alembic::Util::uint64_t ui = 5000000000LL;
            ui64WrtPtr->setSample(&ui);
        }

        {
            AbcA::ScalarPropertyWriterPtr i64WrtPtr =
                props->createScalarProperty("i64", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kInt64POD, 1), 0);

            Alembic::Util::int64_t i = -5000000000LL;
            i64WrtPtr->setSample(&i);
        }

        {
            AbcA::ScalarPropertyWriterPtr halfWrtPtr =
                props->createScalarProperty("half", AbcA::MetaData(),
                    AbcA::DataType(Alembic::Util::kFloat16POD, 1), 0);

//.........这里部分代码省略.........

void testObjectHashes()
{
    std::string archiveName = "objectHashTest.abc";
    {
        AO::WriteArchive w;
        ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
        ABCA::ObjectWriterPtr archive = a->getTop();
        ABCA::ObjectWriterPtr child;

        // 2 objects without any children whatsoever
        archive->createChild(ABCA::ObjectHeader("emptyA", ABCA::MetaData()));
        archive->createChild(ABCA::ObjectHeader("emptyB", ABCA::MetaData()));

        // 2 objects with one child object
        child = archive->createChild(ABCA::ObjectHeader("1ChildA",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", ABCA::MetaData()));

        child = archive->createChild(ABCA::ObjectHeader("1ChildB",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", ABCA::MetaData()));

        // 2 objects with one child object with a different name
        child = archive->createChild(ABCA::ObjectHeader("1ChildAName",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("empty", ABCA::MetaData()));

        child = archive->createChild(ABCA::ObjectHeader("1ChildBName",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("empty", ABCA::MetaData()));

        // 2 objects with one child object with different MetaData
        ABCA::MetaData m;
        m.set("Bleep", "bloop");
        child = archive->createChild(ABCA::ObjectHeader("1ChildAMeta",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", m));

        child = archive->createChild(ABCA::ObjectHeader("1ChildBMeta",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", m));

        // 2 objects with one child object additional prop
        child = archive->createChild(ABCA::ObjectHeader("1ChildAProp",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", ABCA::MetaData())
            )->getProperties()->createCompoundProperty("child",
            ABCA::MetaData());

        child = archive->createChild(ABCA::ObjectHeader("1ChildBProp",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", ABCA::MetaData())
            )->getProperties()->createCompoundProperty("child",
            ABCA::MetaData());

        // 2 objects with one child object with additional grand child
        child = archive->createChild(ABCA::ObjectHeader("1ChildAChild",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", ABCA::MetaData())
            )->createChild(ABCA::ObjectHeader("grandchild", ABCA::MetaData()));

        child = archive->createChild(ABCA::ObjectHeader("1ChildBChild",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("child", ABCA::MetaData())
            )->createChild(ABCA::ObjectHeader("grandchild", ABCA::MetaData()));

        // 2 objects with two children objects
        child = archive->createChild(ABCA::ObjectHeader("2ChildA",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childA", ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childB", ABCA::MetaData()));

        child = archive->createChild(ABCA::ObjectHeader("2ChildB",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childA", ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childB", ABCA::MetaData()));

        // 2 objects with two children objects with swapped children
        child = archive->createChild(ABCA::ObjectHeader("2ChildASwap",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childB", ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childA", ABCA::MetaData()));

        child = archive->createChild(ABCA::ObjectHeader("2ChildBSwap",
            ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childB", ABCA::MetaData()));
        child->createChild(ABCA::ObjectHeader("childA", ABCA::MetaData()));
    }

    {
        AO::ReadArchive r;
        ABCA::ArchiveReaderPtr a = r( archiveName );
        ABCA::ObjectReaderPtr archive = a->getTop();

        TESTING_ASSERT(archive->getNumChildren() == 16);

        // every 2 hashes should be the same
        for (size_t i = 0; i < archive->getNumChildren(); i += 2)
        {
            Alembic::Util::Digest dA, dB;
//.........这里部分代码省略.........

void testArrayPropHashes()
{
    std::string archiveName = "arrayHashTest.abc";
    {
        AO::WriteArchive w;
        ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
        ABCA::ObjectWriterPtr archive = a->getTop();
        ABCA::ObjectWriterPtr child;

        // add a time sampling for later use
        std::vector < double > timeSamps(1,-4.0);
        ABCA::TimeSamplingType tst(3.0);
        ABCA::TimeSampling ts(tst, timeSamps);
        a->addTimeSampling(ts);

        // 2 objects without any properties whatsoever
        archive->createChild(ABCA::ObjectHeader("emptyA", ABCA::MetaData()));
        archive->createChild(ABCA::ObjectHeader("emptyB", ABCA::MetaData()));

        // 2 objects with with the same property with no samples
        child = archive->createChild(ABCA::ObjectHeader(
            "1propA", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propB", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        // 2 objects with with the same property with a differnt name from above
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAName", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("null",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBName", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("null",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        // 2 objects with with the same property with a differnt MetaData
        ABCA::MetaData m;
        m.set("Bleep", "bloop");
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAMeta", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty", m,
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBMeta", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty", m,
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        // 2 objects with with the same property with a different POD
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAPod", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kFloat32POD, 1), 0);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBPod", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kFloat32POD, 1), 0);

        // 2 objects with with the same property with a different extent
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAExtent", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 2), 0);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBExtent", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 2), 0);

        // 2 objects with with the same property with a differnt time sampling
        child = archive->createChild(ABCA::ObjectHeader(
            "1propATS", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 1);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBTS", ABCA::MetaData()));
        child->getProperties()->createArrayProperty("empty",  ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 1);

        // 2 objects with 1 sample
        ABCA::ArrayPropertyWriterPtr awp;
        std::vector <Alembic::Util::int32_t> vali(4, 0);
        Alembic::Util::Dimensions dims(4);
        ABCA::DataType i32d(Alembic::Util::kInt32POD, 1);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propA1Samp", ABCA::MetaData()));
        awp = child->getProperties()->createArrayProperty("int",
            ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
        awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));

        child = archive->createChild(ABCA::ObjectHeader(
//.........这里部分代码省略.........

void testCompoundPropHashes()
{
    std::string archiveName = "compoundHashTest.abc";
    {
        AO::WriteArchive w;
        ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
        ABCA::ObjectWriterPtr archive = a->getTop();
        ABCA::ObjectWriterPtr child;

        // 2 objects without any properties whatsoever
        archive->createChild(ABCA::ObjectHeader("emptyA", ABCA::MetaData()));
        archive->createChild(ABCA::ObjectHeader("emptyB", ABCA::MetaData()));

        // 2 objects with with the same property with no samples
        child = archive->createChild(ABCA::ObjectHeader(
            "1propA", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("empty",
            ABCA::MetaData());

        child = archive->createChild(ABCA::ObjectHeader(
            "1propB", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("empty",
            ABCA::MetaData());

        // 2 objects with with the same property with a differnt name from above
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAName", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("null",
            ABCA::MetaData());

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBName", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("null",
            ABCA::MetaData());

        // 2 objects with with the same property with a different MetaData
        ABCA::MetaData m;
        m.set("Bleep", "bloop");
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAMeta", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("empty", m);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBMeta", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("empty", m);

        // 2 objects with compound that has a child compound
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAChild", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("withChild",
            ABCA::MetaData())->createCompoundProperty("child",
            ABCA::MetaData());

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBChild", ABCA::MetaData()));
        child->getProperties()->createCompoundProperty("withChild",
            ABCA::MetaData())->createCompoundProperty("child",
            ABCA::MetaData());

        // 2 objects with compound that has various children
        ABCA::CompoundPropertyWriterPtr childProp;
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAProps", ABCA::MetaData()));
        childProp = child->getProperties()->createCompoundProperty("child",
            ABCA::MetaData());
        childProp->createCompoundProperty("child", ABCA::MetaData());
        childProp->createScalarProperty("empty", ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBProps", ABCA::MetaData()));
        childProp = child->getProperties()->createCompoundProperty("child",
            ABCA::MetaData());
        childProp->createCompoundProperty("child", ABCA::MetaData());
        childProp->createScalarProperty("empty", ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);

        // 2 objects with compound that has hierarchy
        ABCA::CompoundPropertyWriterPtr grandChildProp;
        child = archive->createChild(ABCA::ObjectHeader(
            "1propAHier", ABCA::MetaData()));
        childProp = child->getProperties()->createCompoundProperty("child",
            ABCA::MetaData());
        grandChildProp = childProp->createCompoundProperty("child",
            ABCA::MetaData());
        childProp->createScalarProperty("empty", ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
        grandChildProp->createScalarProperty("empty", ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
        grandChildProp->createCompoundProperty("child", ABCA::MetaData());

        child = archive->createChild(ABCA::ObjectHeader(
            "1propBHier", ABCA::MetaData()));
        childProp = child->getProperties()->createCompoundProperty("child",
            ABCA::MetaData());
        grandChildProp = childProp->createCompoundProperty("child",
            ABCA::MetaData());
        childProp->createScalarProperty("empty", ABCA::MetaData(),
            ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
        grandChildProp->createScalarProperty("empty", ABCA::MetaData(),
//.........这里部分代码省略.........

void testScalarSamples()
{
    std::string archiveName = "numScalarSamplesTest.abc";

    AbcA::DataType dtype(Alembic::Util::kFloat32POD);
    float samp = 0.0f;
    {
        AO::WriteArchive w;
        AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData());
        AbcA::ObjectWriterPtr archive = a->getTop();
        AbcA::ObjectWriterPtr obj = archive->createChild(
            AbcA::ObjectHeader("test", AbcA::MetaData()));

        AbcA::CompoundPropertyWriterPtr parent = obj->getProperties();
        AbcA::ScalarPropertyWriterPtr prop;

        AbcA::CompoundPropertyWriterPtr smallProp =
            parent->createCompoundProperty("small", AbcA::MetaData());
        smallProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0);
        prop = smallProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0);
        for (std::size_t i = 0; i < 10; ++i, ++samp)
        {
            prop->setSample(&samp);
        }
        smallProp->createArrayProperty("c", AbcA::MetaData(), dtype, 0);

        AbcA::CompoundPropertyWriterPtr mdProp =
            parent->createCompoundProperty("md", AbcA::MetaData());
        mdProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0);
        prop = mdProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0);
        for (std::size_t i = 0; i < 150; ++i, ++samp)
        {
            prop->setSample(&samp);
        }
        mdProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0);

        AbcA::CompoundPropertyWriterPtr mdlgProp =
            parent->createCompoundProperty("mdlg", AbcA::MetaData());
        mdlgProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0);
        prop = mdlgProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0);
        for (std::size_t i = 0; i < 300; ++i, ++samp)
        {
            prop->setSample(&samp);
        }
        mdlgProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0);

        AbcA::CompoundPropertyWriterPtr lgProp =
            parent->createCompoundProperty("lg", AbcA::MetaData());
        lgProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0);
        prop = lgProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0);
        for (std::size_t i = 0; i < 33000; ++i, ++samp)
        {
            prop->setSample(&samp);
        }
        lgProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0);

        AbcA::CompoundPropertyWriterPtr insaneProp =
            parent->createCompoundProperty("insane", AbcA::MetaData());
        insaneProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0);
        prop = insaneProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0);
        for (std::size_t i = 0; i < 66000; ++i, ++samp)
        {
            prop->setSample(&samp);
        }
        insaneProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0);
    }

    {
        AO::ReadArchive r;
        AbcA::ArchiveReaderPtr a = r( archiveName );
        AbcA::ObjectReaderPtr archive = a->getTop();
        AbcA::ObjectReaderPtr obj = archive->getChild(0);
        AbcA::CompoundPropertyReaderPtr parent = obj->getProperties();

        AbcA::CompoundPropertyReaderPtr smallProp =
            parent->getCompoundProperty("small");
        TESTING_ASSERT(smallProp->getNumProperties() == 3);
        TESTING_ASSERT(smallProp->getScalarProperty("b")->getNumSamples() == 10);

        AbcA::CompoundPropertyReaderPtr mdProp =
            parent->getCompoundProperty("md");
        TESTING_ASSERT(mdProp->getNumProperties() == 3);
        TESTING_ASSERT(mdProp->getScalarProperty("b")->getNumSamples() == 150);

        AbcA::CompoundPropertyReaderPtr mdlgProp =
            parent->getCompoundProperty("mdlg");
        TESTING_ASSERT(mdlgProp->getNumProperties() == 3);
        TESTING_ASSERT(mdlgProp->getScalarProperty("b")->getNumSamples() == 300);

        AbcA::CompoundPropertyReaderPtr lgProp =
            parent->getCompoundProperty("lg");
        TESTING_ASSERT(lgProp->getNumProperties() == 3);
        TESTING_ASSERT(lgProp->getScalarProperty("b")->getNumSamples()
                       == 33000);

        AbcA::CompoundPropertyReaderPtr insaneProp =
            parent->getCompoundProperty("insane");
        TESTING_ASSERT(insaneProp->getNumProperties() == 3);
        TESTING_ASSERT(insaneProp->getScalarProperty("b")->getNumSamples()
                       == 66000);
//.........这里部分代码省略.........

//-*****************************************************************************
void testObjects()
{
    std::string archiveName = "objectTest.abc";
    {
        A5::WriteArchive w;
        AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData());
        AbcA::ObjectWriterPtr archive = a->getTop();
        TESTING_ASSERT(archive->getName() == "ABC");
        TESTING_ASSERT(archive->getFullName() == "/");

        AbcA::ObjectWriterPtr child1 = archive->createChild(
            AbcA::ObjectHeader("wow", AbcA::MetaData()));
        TESTING_ASSERT(child1->getName() == "wow");
        TESTING_ASSERT(child1->getFullName() == "/wow");

        AbcA::ObjectWriterPtr child2 = archive->createChild(
            AbcA::ObjectHeader("bar", AbcA::MetaData()));
        TESTING_ASSERT(child2->getName() == "bar");
        TESTING_ASSERT(child2->getFullName() == "/bar");

        AbcA::ObjectWriterPtr child3 = archive->createChild(
            AbcA::ObjectHeader("foo", AbcA::MetaData()));
        TESTING_ASSERT(child3->getName() == "foo");
        TESTING_ASSERT(child3->getFullName() == "/foo");

        TESTING_ASSERT(archive->getNumChildren() == 3);

        TESTING_ASSERT(child1->getNumChildren() == 0);
        AbcA::ObjectWriterPtr gchild = child1->createChild(
            AbcA::ObjectHeader("food", AbcA::MetaData()));
        TESTING_ASSERT(child1->getNumChildren() == 1);
        TESTING_ASSERT(gchild->getNumChildren() == 0);
        TESTING_ASSERT(gchild->getName() == "food");
        TESTING_ASSERT(gchild->getFullName() == "/wow/food");

        gchild = child2->createChild(
            AbcA::ObjectHeader("hat", AbcA::MetaData()));
        TESTING_ASSERT(gchild->getNumChildren() == 0);
        TESTING_ASSERT(gchild->getName() == "hat");
        TESTING_ASSERT(gchild->getFullName() == "/bar/hat");
        TESTING_ASSERT_THROW(child2->createChild(
            AbcA::ObjectHeader("hat", AbcA::MetaData())),
            Alembic::Util::Exception);
        TESTING_ASSERT_THROW(child2->createChild(
            AbcA::ObjectHeader("slashy/", AbcA::MetaData())),
            Alembic::Util::Exception);
        TESTING_ASSERT_THROW(child2->createChild(
            AbcA::ObjectHeader("sla/shy", AbcA::MetaData())),
            Alembic::Util::Exception);
        TESTING_ASSERT_THROW(child2->createChild(
            AbcA::ObjectHeader("/slashy", AbcA::MetaData())),
            Alembic::Util::Exception);
        TESTING_ASSERT_THROW(child2->createChild(
            AbcA::ObjectHeader("", AbcA::MetaData())),
            Alembic::Util::Exception);
        gchild = child2->createChild(
            AbcA::ObjectHeader("bowling", AbcA::MetaData()));
        TESTING_ASSERT(gchild->getNumChildren() == 0);
        TESTING_ASSERT(gchild->getName() == "bowling");
        TESTING_ASSERT(gchild->getFullName() == "/bar/bowling");
        TESTING_ASSERT(child2->getNumChildren() == 2);

        gchild = child3->createChild(
            AbcA::ObjectHeader("hamburger", AbcA::MetaData()));
        TESTING_ASSERT(gchild->getNumChildren() == 0);
        TESTING_ASSERT(gchild->getName() == "hamburger");
        TESTING_ASSERT(gchild->getFullName() == "/foo/hamburger");

        gchild = child3->createChild(
            AbcA::ObjectHeader("burrito", AbcA::MetaData()));
        TESTING_ASSERT(gchild->getNumChildren() == 0);
        TESTING_ASSERT(gchild->getName() == "burrito");
        TESTING_ASSERT(gchild->getFullName() == "/foo/burrito");

        gchild = child3->createChild(
            AbcA::ObjectHeader("pizza", AbcA::MetaData()));
        TESTING_ASSERT(child3->getNumChildren() == 3);
        TESTING_ASSERT(gchild->getNumChildren() == 0);
        TESTING_ASSERT(gchild->getName() == "pizza");
        TESTING_ASSERT(gchild->getFullName() == "/foo/pizza");
    }

    {
        A5::ReadArchive r;
        AbcA::ArchiveReaderPtr a = r( archiveName );
        AbcA::ObjectReaderPtr archive = a->getTop();
        TESTING_ASSERT(archive->getNumChildren() == 3);
        TESTING_ASSERT(archive->getName() == "ABC");
        TESTING_ASSERT(archive->getFullName() == "/");

        AbcA::ObjectReaderPtr child = archive->getChild(0);
        TESTING_ASSERT(child->getName() == "wow");
        TESTING_ASSERT(child->getFullName() == "/wow");
        TESTING_ASSERT(child->getNumChildren() == 1);
        AbcA::ObjectReaderPtr gchild = child->getChild(0);
        TESTING_ASSERT(gchild->getNumChildren() == 0);
        TESTING_ASSERT(gchild->getName() == "food");
        TESTING_ASSERT(gchild->getFullName() == "/wow/food");

//.........这里部分代码省略.........