//---------------------------------------------------------------------------
void tTVPSusieArchivePlugin::GetFileList(std::wstring localname,
std::vector<tTVPSusieFileRecord> &dest)
{
// retrieve file list
TVPAddLog( TVPFormatMessage(TVPInfoListingFiles, ttstr(localname.c_str()) ) );
HLOCAL infohandle = NULL;
int errorcode = 0xff&GetArchiveInfo(const_cast<LPSTR>(ttstr(localname).AsNarrowStdString().c_str()), 0, 0x00, &infohandle);
if(infohandle == NULL)
{
TVPThrowExceptionMessage(TVPSusiePluginError,
ttstr(TJS_W("tTVPSusieArchivePlugin::GetArchiveInfo failed, errorcode = ")) +
ttstr((tjs_int)errorcode));
}
else
{
if(errorcode != 0)
{
TVPAddLog(TJS_W("Warning : invalid errorcode ") + ttstr((tjs_int)errorcode) +
TJS_W(" was returned from tTVPSusieArchivePlugin::GetArchiveInfo, ")
TJS_W("continuing anyway."));
}
}
const tTVPSusieFileInfo *info = (const tTVPSusieFileInfo*)LocalLock(infohandle);
if(info == NULL)
{
TVPThrowExceptionMessage(TVPSusiePluginError,
ttstr(TJS_W("tTVPSusieArchivePlugin::GetArchiveInfo failed : invalid memory block.")));
}
try
{
while(info->method[0])
{
if(info->filename[0])
{
char buf[401];
TJS_nstrcpy(buf, info->path);
TJS_nstrcat(buf, "/");
TJS_nstrcat(buf, info->filename);
tTVPSusieFileRecord record;
record.Name = buf;
tTVPArchive::NormalizeInArchiveStorageName(record.Name);
record.Position = info->position;
record.Size = info->filesize;
dest.push_back(record);
}
info++;
}
// sort item vector by its name (required for tTVPArchive specification)
std::stable_sort(dest.begin(), dest.end());
}
catch(...)
{
LocalUnlock(infohandle);
LocalFree(infohandle);
throw;
}
LocalUnlock(infohandle);
LocalFree(infohandle);
TVPAddLog(TJS_W("(info) ") + ttstr((tjs_int)dest.size()) + TJS_W(" files found."));
}
//-*****************************************************************************
int main( int argc, char *argv[] )
{
bool opt_all = false;
bool opt_meta = false;
std::string desc( "abctree [OPTION] FILE[/NAME]\n"
" -a include properties listings\n"
" -h, --help prints this help message\n"
" -m print metadata\n"
);
// check for min args
if ( argc < 2 ) {
std::cout << desc << std::endl;
return 0;
};
// parse args
std::vector<std::string> arguments(argv, argv + argc);
std::vector<std::string> options;
std::vector<std::string> files;
// separate file args from option args
for ( std::size_t i = 1; i < arguments.size(); i++ ) {
if ( arguments[ i ].substr( 0, 1 ) == "-" )
options.push_back( arguments[ i ] );
else
files.push_back( arguments[ i ] );
}
// help
if ( argc < 2 ||
optionExists( options, "h" ) ||
optionExists( options, "help" )
) {
std::cout << desc << std::endl;
return 0;
};
// set some flags
opt_all = optionExists( options, "a");
opt_meta = optionExists( options, "m");
// open each file
size_t count = 0;
for ( std::size_t i = 0; i < files.size(); i++ ) {
if ( files.size() > 1 )
std::cout << BOLD << files[i] << ':' << RESETCOLOR << std::endl;
std::stringstream ss( files[i] );
std::stringstream fp;
std::string segment;
std::vector<std::string> seglist;
/*
* separate file and object paths, e.g.
*
* ../dir1/foo.abc/bar/baz
* \_____________/\______/
* file obj
*/
int j = 0;
while ( std::getline( ss, segment, '/' ) ) {
if ( !isFile ( fp.str() ) ) {
if ( j != 0 )
fp << "/";
fp << segment;
} else {
seglist.push_back( segment );
}
++j;
}
// open the iarchive
Abc::IArchive archive;
AbcF::IFactory factory;
factory.setPolicy(Abc::ErrorHandler::kQuietNoopPolicy);
AbcF::IFactory::CoreType coreType;
archive = factory.getArchive(std::string( fp.str() ), coreType);
// display file metadata
if ( opt_meta ) {
std::cout << "Using "
<< Alembic::AbcCoreAbstract::GetLibraryVersion ()
<< std::endl;;
std::string appName;
std::string libraryVersionString;
Alembic::Util::uint32_t libraryVersion;
std::string whenWritten;
std::string userDescription;
std::string coreName;
GetArchiveInfo (archive,
appName,
libraryVersionString,
libraryVersion,
whenWritten,
userDescription);
if ( coreType == AbcF::IFactory::kOgawa ) {
coreName = "Ogawa";
} else if ( coreType == AbcF::IFactory::kHDF5 ) {
coreName = "HDF5";
} else {
coreName = "Unknown";
};
if ( appName != "" ) {
std::cout << " file written by: " << appName << std::endl;
std::cout << " using Alembic : " << libraryVersionString << std::endl;
std::cout << " written on : " << whenWritten << std::endl;
std::cout << " user description : " << userDescription << std::endl;
} else {
std::cout << " (file doesn't have any ArchiveInfo)"
<< std::endl;
}
std::cout << " core type : " << coreName << std::endl;
};
// walk object hierarchy and find valid objects
AbcG::IObject test = archive.getTop();
AbcG::IObject iObj = test;
while ( test.valid() && seglist.size() > 0 ) {
test = test.getChild( seglist.front() );
if ( test.valid() ) {
iObj = test;
seglist.erase( seglist.begin() );
}
}
// walk property hierarchy for most recent valid object
Abc::ICompoundProperty props = iObj.getProperties();
const Abc::PropertyHeader* header;
bool found = false;
for ( std::size_t i = 0; i < seglist.size(); ++i ) {
header = props.getPropertyHeader( seglist[i] );
if ( header && header->isCompound() ) {
Abc::ICompoundProperty ptest( props, header->getName() );
if ( ptest.valid() ) {
props = ptest;
found = true;
}
} else if ( header && header->isSimple() ) {
found = true;
} else {
std::cout << seglist[i]
<< ": Invalid object or property"
<< std::endl;
return 1;
}
}
// walk the archive tree
if ( found )
if ( header->isCompound() )
tree( props );
else
tree( Abc::IScalarProperty( props, header->getName() ) );
else
tree( iObj, opt_all );
++count;
}
return 0;
}
