Method directoryChild

src/IECore/StreamIndexedIO.cpp:1317–1373

}

DirectoryNode* StreamIndexedIO::Node::directoryChild( const IndexedIO::EntryID &name ) const
{
	Index::MutexLock lock;
	m_idx->lockDirectory( lock, m_node );

	DirectoryNode::ChildMap::iterator it = m_node->findChild( name );
	if ( it != m_node->children().end() )
	{
		if ( (*it)->nodeType() == NodeBase::Directory )
		{
			DirectoryNode *dir = static_cast< DirectoryNode *>( (*it) );

			if ( dir->subindex() == DirectoryNode::SavedSubIndex )
			{
				if ( m_node->subindexChildren() )
				{
					lock.release();		/// we will not change the children dictionary, so we release the lock!
				}

				// this can occur when the user flushed a directory and right after tries to access it.
				m_idx->readNodeFromSubIndex( dir );
			}
			return dir;
		}
		else if ( (*it)->nodeType() == NodeBase::SubIndex )
		{
			SubIndexNode *subIndex = static_cast< SubIndexNode *>( (*it) );

			// build a Directory that knows it's flushed to a subindex.
			DirectoryNode *newDir = new DirectoryNode( subIndex, m_node );

			lock.release();		/// we release the lock while loading data..

			m_idx->readNodeFromSubIndex( newDir );

			// now that we loaded the whole thing, lock our Index for writing
			m_idx->lockDirectory( lock, m_node, true );

			// there's a chance that someone else already replaced the pointer...
			if ( (*it)->nodeType() == NodeBase::Directory )
			{
				lock.release();		/// we release the lock because we won't change the children anyways..
				NodeBase::destroy( newDir );
				return static_cast< DirectoryNode *>(*it);
			}

			// replace SubIndex by Directory node.
			(*it) = newDir;

			// and now we are ok to delete the SubIndexNode..
			delete subIndex;

			return newDir;
		}
	}
	return nullptr;
}