CSeq_entry_Handle
CBioseq_Handle::GetComplexityLevel(CBioseq_set::EClass cls) const
{
const CBioseq_set_Handle::TComplexityTable& ctab =
CBioseq_set_Handle::sx_GetComplexityTable();
if (cls == CBioseq_set::eClass_other) {
// adjust 255 to the correct value
cls = CBioseq_set::EClass(sizeof(ctab) - 1);
}
CSeq_entry_Handle last = GetParentEntry();
_ASSERT(last && last.IsSeq());
CSeq_entry_Handle e = last.GetParentEntry();
while ( e ) {
_ASSERT(e.IsSet());
// Found good level
if ( last.IsSet() &&
ctab[last.GetSet().GetClass()] == ctab[cls] )
break;
// Gone too high
if ( ctab[e.GetSet().GetClass()] > ctab[cls] ) {
break;
}
// Go up one level
last = e;
e = e.GetParentEntry();
}
return last;
}
CSeq_entry_Handle
CBioseq_Handle::GetExactComplexityLevel(CBioseq_set::EClass cls) const
{
CSeq_entry_Handle ret = GetComplexityLevel(cls);
if ( ret &&
(!ret.IsSet() || !ret.GetSet().IsSetClass() ||
ret.GetSet().GetClass() != cls) ) {
ret.Reset();
}
return ret;
}
CSeq_entry_EditHandle::CSeq_entry_EditHandle(const CSeq_entry_Handle& h)
: CSeq_entry_Handle(h)
{
if ( !h.GetTSE_Handle().CanBeEdited() ) {
NCBI_THROW(CObjMgrException, eInvalidHandle,
"object is not in editing mode");
}
}
CSeq_entry_CI::CSeq_entry_CI(const CSeq_entry_Handle& entry,
TFlags flags,
CSeq_entry::E_Choice type_filter )
: m_Flags(flags),
m_Filter(type_filter)
{
if ( m_Flags & fIncludeGivenEntry ) {
m_Current = entry;
while ((*this) && !x_ValidType()) {
x_Next();
}
} else {
if ( entry.IsSet() ) {
x_Initialize( entry.GetSet() );
}
}
}
// ----------------------------------------------------------------------------
void
CStartItem::x_SetDate(
CSeq_entry_Handle seh )
// ----------------------------------------------------------------------------
{
if ( ! seh.IsSetDescr() ) {
m_Date = CurrentTime().AsString("Y-M-D");
return;
}
const list< CRef< CSeqdesc > > lsd = seh.GetDescr().Get();
if ( lsd.empty() ) {
m_Date = CurrentTime().AsString("Y-M-D");
return;
}
for ( list< CRef< CSeqdesc > >::const_iterator cit = lsd.begin();
cit != lsd.end(); ++cit )
{
const CSeqdesc& sd = **cit;
switch( sd.Which() ) {
default:
break;
case CSeqdesc::e_Create_date:
sd.GetCreate_date().GetDate( &m_Date, "%Y-%2M-%2D" );
break;
case CSeqdesc::e_Update_date:
sd.GetUpdate_date().GetDate( &m_Date, "%Y-%2M-%2D" );
return;
}
}
if ( m_Date.empty() ) {
m_Date = CurrentTime().AsString("Y-M-D");
}
}
int CTestApplication::Run()
//---------------------------------------------------------------------------
{
int error = 0;
string name1("DL_1"), name2("DL_2");
NcbiCout << "1.1.1 Creating CScope ==============================" << NcbiEndl;
{
{
CRef< CObjectManager> pOm = CObjectManager::GetInstance();
{
CTestDataLoader::RegisterInObjectManager
(*pOm, name1, CObjectManager::eNonDefault);
CTestDataLoader::RegisterInObjectManager
(*pOm, name2, CObjectManager::eDefault);
// scope in CRef container
CRef< CScope> pScope1(new CScope(*pOm));
pScope1->AddDefaults(); // loader 2 added
pScope1->AddDataLoader(name1);
// scope on the stack
CScope scope2(*pOm);
scope2.AddDefaults(); // loader 2 added
// scope on the heap
CScope* pScope3 = new CScope(*pOm);
pScope3->AddDefaults(); // loader 2 added
delete pScope3; // loader 2 alive
}
// scopes deleted, all dataloaders alive
pOm->RevokeDataLoader(name1);
pOm->RevokeDataLoader(name2);
}
// objmgr deleted, all dataloaders deleted
}
NcbiCout << "1.1.2 Adding Seq_entry to the scope=================" << NcbiEndl;
{
{
CRef< CObjectManager> pOm = CObjectManager::GetInstance();
{
// 3 scopes
CRef< CScope> pScope1(new CScope(*pOm));
CScope scope2(*pOm);
CRef<CScope> pScope3(new CScope(*pOm));
CRef< CSeq_entry> pEntry = CreateTestEntry();
// add entry to all scopes
pScope1->AddTopLevelSeqEntry( *pEntry);
scope2.AddTopLevelSeqEntry( *pEntry);
CSeq_entry_Handle eh = pScope3->AddTopLevelSeqEntry( *pEntry);
pScope1.Reset();
pScope3.Reset();
eh.Reset();
//delete pScope3; // data source and seq_entry alive
}
// scopes deleted, seq_entry and data source deleted
}
// objmgr deleted
}
NcbiCout << "1.1.3 Handling Data loader==========================" << NcbiEndl;
{
{
CRef< CObjectManager> pOm = CObjectManager::GetInstance();
{
CScope* pScope1 = new CScope(*pOm);
pScope1->AddDefaults(); // nothing added
// must throw an exception: dataloader1 not found
NcbiCout << "Expecting exception:" << NcbiEndl;
try {
pScope1->AddDataLoader( name1);
NcbiCout << "ERROR: AddDataLoader has succeeded" << NcbiEndl;
error += 1;
}
catch (exception& e) {
NcbiCout << "Expected exception: " << e.what() << NcbiEndl;
}
CTestDataLoader::RegisterInObjectManager(*pOm, name1);
pScope1->AddDefaults(); // nothing added
pScope1->AddDataLoader( name1); // ok
// must fail - dataloader1 is in use
NcbiCout << "Expecting error:" << NcbiEndl;
if (pOm->RevokeDataLoader( name1))
{
NcbiCout << "ERROR: RevokeDataLoader has succeeded" << NcbiEndl;
error += 2;
}
delete pScope1; // loader1 alive
// delete dataloader1
pOm->RevokeDataLoader( name1); // ok
// must throw an exception - dataloader1 not registered
NcbiCout << "Expecting exception:" << NcbiEndl;
try {
pOm->RevokeDataLoader( name1);
NcbiCout << "ERROR: RevokeDataLoader has succeeded" << NcbiEndl;
error += 4;
}
catch (exception& e) {
NcbiCout << "Expected exception: " << e.what() << NcbiEndl;
}
}
}
}
{
SAnnotSelector sel;
map<string, set<int> > nav;
vector<string> aa;
for ( int i = 0; i < 100; ++i ) {
string acc = "NA"+NStr::IntToString(rand()%1000);
if ( nav.count(acc) ) continue;
aa.push_back(acc);
set<int>& vv = nav[acc];
int nv = rand()%4;
for ( int j = 0; j < nv; ++j ) {
int v = rand()%10;
vv.insert(v);
string accv = acc+"."+NStr::IntToString(v);
sel.IncludeNamedAnnotAccession(accv);
//NcbiCout << "IncludeNamedAnnotAccession("<<accv<<")"<<NcbiEndl;
}
if ( nv == 0 ) {
sel.IncludeNamedAnnotAccession(acc);
//NcbiCout << "IncludeNamedAnnotAccession("<<acc<<")"<<NcbiEndl;
}
}
for ( size_t t = 0; t < aa.size(); ++t ) {
string acc = aa[t];
acc[acc.size()-1]--;
for ( int t1 = 0; t1 < 2; ++t1, acc[acc.size()-1]++ ) {
const set<int>* vv = nav.count(acc)? &nav[acc]: 0;
//NcbiCout << "IsIncludedNamedAnnotAccession("<<acc<<") "<< (vv?vv->size():0) <<NcbiEndl;
if ( !vv || !vv->empty() ) {
assert(!sel.IsIncludedNamedAnnotAccession(acc));
}
else {
assert(sel.IsIncludedNamedAnnotAccession(acc));
}
for ( int s = 0; s < 100; ++s ) {
int v = rand()%10;
string accv = acc+"."+NStr::IntToString(v);
//NcbiCout<<"IsIncludedNamedAnnotAccession("<<accv<<")"<<NcbiEndl;
if ( !vv || (!vv->empty() && !vv->count(v)) ) {
assert(!sel.IsIncludedNamedAnnotAccession(accv));
}
else {
assert(sel.IsIncludedNamedAnnotAccession(accv));
}
}
}
}
}
if ( error > 0 ) {
NcbiCout << "==================================================" << NcbiEndl;
NcbiCout << "ERROR " << error << ": Some tests failed." << NcbiEndl;
}
else {
NcbiCout << "==================================================" << NcbiEndl;
NcbiCout << "Test completed successfully" << NcbiEndl;
}
return error;
}
