void COffsetReadHook::ReadObject(CObjectIStream &in, const CObjectInfo &object) { CCallStackGuard guard(m_Sniffer->m_CallStack, object); if (m_EventMode == CObjectsSniffer::eCallAlways) { // Clear the discard flag before calling sniffer's event reactors m_Sniffer->SetDiscardCurrObject(false); m_Sniffer->OnObjectFoundPre(object, in.GetStreamPos()); DefaultRead(in, object); m_Sniffer->OnObjectFoundPost(object); // Relay discard flag to the stream bool discard = m_Sniffer->GetDiscardCurrObject(); in.SetDiscardCurrObject(discard); } else { if (m_EventMode == CObjectsSniffer::eSkipObject) { DefaultSkip(in, object); } else { DefaultRead(in, object); } } }
bool Serial_FilterSkip(CObjectIStream& in, const CObjectTypeInfo& ctype) { if (!in.EndOfData()) { in.Skip(ctype); return true; } return false; }
static void Read(CObjectIStream& in, TTypeInfo , TObjectPtr objectPtr) { if ( objectPtr != 0 ) { in.ThrowError(in.fInvalidData, "non-null value when reading NULL member"); } in.ReadNull(); }
void CChoiceTypeInfoFunctions::SkipChoiceDefault(CObjectIStream& in, TTypeInfo objectType) { const CChoiceTypeInfo* choiceType = CTypeConverter<CChoiceTypeInfo>::SafeCast(objectType); BEGIN_OBJECT_FRAME_OF2(in, eFrameChoice, choiceType); in.BeginChoice(choiceType); BEGIN_OBJECT_FRAME_OF(in, eFrameChoiceVariant); TMemberIndex index = in.BeginChoiceVariant(choiceType); if ( index == kInvalidMember ) in.ThrowError(in.fFormatError,"choice variant id expected"); const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index); if (variantInfo->GetId().IsAttlist()) { const CMemberInfo* memberInfo = dynamic_cast<const CMemberInfo*>( choiceType->GetVariants().GetItemInfo(index)); memberInfo->SkipMember(in); in.EndChoiceVariant(); index = in.BeginChoiceVariant(choiceType); if ( index == kInvalidMember ) in.ThrowError(in.fFormatError,"choice variant id expected"); variantInfo = choiceType->GetVariantInfo(index); } in.SetTopMemberId(variantInfo->GetId()); variantInfo->SkipVariant(in); in.EndChoiceVariant(); END_OBJECT_FRAME_OF(in); in.EndChoice(); END_OBJECT_FRAME_OF(in); }
virtual void SkipClassMember(CObjectIStream& in, const CObjectTypeInfoMI& passed_info) { cout << in.GetStackPath() << endl; #if 1 DefaultSkip(in, passed_info); #else // get information about the member // typeinfo of the parent class (Bioseq) CObjectTypeInfo oti = passed_info.GetClassType(); // typeinfo of the member (SET OF Seq-annot) CObjectTypeInfo omti = passed_info.GetMemberType(); // index of the member in parent class (4) TMemberIndex mi = passed_info.GetMemberIndex(); // information about the member, including its name (annot) const CMemberInfo* minfo = passed_info.GetMemberInfo(); #if 1 // or read the whole SET OF Seq-annot at once CObjectInfo oi(passed_info); DefaultRead(in, oi); cout << MSerial_AsnText << oi << endl; #endif #if 0 // or read CSeq_annot objects one by one and write them into stdout unique_ptr<CObjectOStream> out(CObjectOStream::Open(eSerial_AsnText, "stdout", eSerial_StdWhenStd)); COStreamContainer o(*out, passed_info); for ( CIStreamContainerIterator i(in, passed_info); i; ++i ) { CSeq_annot annot; i >> annot; // NOTE: this does not produce well formed text ASN, because of missing typeinfo name // this would work though if we copied data into existing ASN stream // where typeinfo name ("file header") is not required o << annot; // if we needed well formed text ASN, we could write it like this: // cout << MSerial_AsnText << annot; } #endif #if 0 // or read the whole SET OF Seq-annot at once CBioseq::TAnnot annot; CObjectInfo oi(&annot, passed_info.GetMemberType().GetTypeInfo()); in.ReadObject(oi); // write them one by one for( const auto& e: annot) { cout << MSerial_AsnText << *e << endl; } // or write them all at once unique_ptr<CObjectOStream> out(CObjectOStream::Open(eSerial_AsnText, "stdout", eSerial_StdWhenStd)); out->WriteObject(oi); #endif #endif }
void CAliasTypeInfoFunctions::SkipAliasDefault(CObjectIStream& in, TTypeInfo objectType) { const CAliasTypeInfo* aliasType = CTypeConverter<CAliasTypeInfo>::SafeCast(objectType); in.SkipAlias(aliasType); }
TObjectPtr CType_Base::GetParentObjectPtr(CObjectIStream& in, TTypeInfo typeInfo, size_t max_depth, size_t min_depth) { return in.GetParentObjectPtr(typeInfo, max_depth, min_depth); }
void CTypeInfo::SetLocalSkipHook(CObjectIStream& stream, CSkipObjectHook* hook) { CMutexGuard guard(GetTypeInfoMutex()); m_SkipHookData.SetLocalHook(stream.m_ObjectSkipHookKey, hook); stream.AddMonitorType(this); }
void CChoiceTypeInfoFunctions::SkipChoiceSimple(CObjectIStream& in, TTypeInfo objectType) { const CChoiceTypeInfo* choiceType = CTypeConverter<CChoiceTypeInfo>::SafeCast(objectType); in.SkipChoiceSimple(choiceType); }
// -------------------------------------------------------------------------- CObjectIStream* CAsn2FastaApp::x_OpenIStream(const CArgs& args) // -------------------------------------------------------------------------- { // determine the file serialization format. // default for batch files is binary, otherwise text. ESerialDataFormat serial = args["batch"] ? eSerial_AsnBinary :eSerial_AsnText; if ( args["serial"] ) { const string& val = args["serial"].AsString(); if ( val == "text" ) { serial = eSerial_AsnText; } else if ( val == "binary" ) { serial = eSerial_AsnBinary; } else if ( val == "XML" ) { serial = eSerial_Xml; } } // make sure of the underlying input stream. If -i was given on the command line // then the input comes from a file. Otherwise, it comes from stdin: CNcbiIstream* pInputStream = &NcbiCin; bool bDeleteOnClose = false; if ( args["i"] ) { pInputStream = new CNcbiIfstream( args["i"].AsString().c_str(), ios::binary ); bDeleteOnClose = true; } // if -c was specified then wrap the input stream into a gzip decompressor before // turning it into an object stream: CObjectIStream* pI = 0; if ( args["c"] ) { CZipStreamDecompressor* pDecompressor = new CZipStreamDecompressor( 512, 512, kZlibDefaultWbits, CZipCompression::fCheckFileHeader ); CCompressionIStream* pUnzipStream = new CCompressionIStream( *pInputStream, pDecompressor, CCompressionIStream::fOwnProcessor ); pI = CObjectIStream::Open( serial, *pUnzipStream, eTakeOwnership ); } else { pI = CObjectIStream::Open( serial, *pInputStream, (bDeleteOnClose ? eTakeOwnership : eNoOwnership)); } if ( 0 != pI ) { pI->UseMemoryPool(); } return pI; }
void CPointerTypeInfo::SkipPointer(CObjectIStream& in, TTypeInfo objectType) { const CPointerTypeInfo* pointerType = CTypeConverter<CPointerTypeInfo>::SafeCast(objectType); in.SkipPointer(pointerType->GetPointedType()); }
void CAliasTypeInfoFunctions::ReadAliasDefault(CObjectIStream& in, TTypeInfo objectType, TObjectPtr objectPtr) { const CAliasTypeInfo* aliasType = CTypeConverter<CAliasTypeInfo>::SafeCast(objectType); in.ReadAlias(aliasType, objectPtr); }
void CChoiceTypeInfoFunctions::ReadChoiceSimple(CObjectIStream& in, TTypeInfo objectType, TObjectPtr objectPtr) { const CChoiceTypeInfo* choiceType = CTypeConverter<CChoiceTypeInfo>::SafeCast(objectType); in.ReadChoiceSimple(choiceType, objectPtr); }
void CContainerTypeInfo::SkipContainer(CObjectIStream& in, TTypeInfo objectType) { const CContainerTypeInfo* containerType = CTypeConverter<CContainerTypeInfo>::SafeCast(objectType); in.SkipContainer(containerType); }
void CPointerTypeInfo::ReadPointer(CObjectIStream& in, TTypeInfo objectType, TObjectPtr objectPtr) { const CPointerTypeInfo* pointerType = CTypeConverter<CPointerTypeInfo>::SafeCast(objectType); TTypeInfo pointedType = pointerType->GetPointedType(); TObjectPtr pointedPtr = pointerType->GetObjectPointer(objectPtr); if ( pointedPtr ) { //pointedType->SetDefault(pointedPtr); in.ReadObject(pointedPtr, pointedType); } else { pointerType->SetObjectPointer(objectPtr, in.ReadPointer(pointedType).first); } }
void CContainerTypeInfo::ReadContainer(CObjectIStream& in, TTypeInfo objectType, TObjectPtr objectPtr) { const CContainerTypeInfo* containerType = CTypeConverter<CContainerTypeInfo>::SafeCast(objectType); in.ReadContainer(containerType, objectPtr); }
void CObjectsSniffer::Probe(CObjectIStream& input) { _ASSERT(m_Candidates.size()); vector<CRef<COffsetReadHook> > hooks; // list of all hooks we set // // create hooks for all candidates // TCandidates::const_iterator it; for (it = m_Candidates.begin(); it < m_Candidates.end(); ++it) { CRef<COffsetReadHook> h(new COffsetReadHook(this, it->event_mode)); it->type_info.SetLocalReadHook(input, &(*h)); hooks.push_back(h); } // for m_TopLevelMap.clear(); if (input.GetDataFormat() == eSerial_AsnText || input.GetDataFormat() == eSerial_Xml) { ProbeText(input); } else { ProbeASN1_Bin(input); } // // Reset(clean) the hooks // _ASSERT(hooks.size() == m_Candidates.size()); for (it = m_Candidates.begin(); it < m_Candidates.end(); ++it) { it->type_info.ResetLocalReadHook(input); } // for }
// -------------------------------------------------------------------------- CSeq_entry_Handle CAsn2FastaApp::ObtainSeqEntryFromBioseqSet( CObjectIStream& is) // -------------------------------------------------------------------------- { try { CRef<CSeq_entry> entry(new CSeq_entry); is >> entry->SetSet(); return m_Scope->AddTopLevelSeqEntry(*entry); } catch (CException& e) { if (! (is.GetFailFlags() & is.eEOF)) { ERR_POST(Error << e); } } return CSeq_entry_Handle(); }
// ============================================================================ string CFormatGuessApp::guess_object_type(CObjectIStream & obj_istrm) // ============================================================================ { set<TTypeInfo> known_types = { CType<CSeq_entry>().GetTypeInfo(), CType<CSeq_submit>().GetTypeInfo(), CType<CBioseq_set>().GetTypeInfo(), CType<CBioseq>().GetTypeInfo() }; set<TTypeInfo> types = obj_istrm.GuessDataType(known_types); if ( types.size() != 1 ) { return "unknown"; } return (*types.begin())->GetName(); }
// -------------------------------------------------------------------------- CSeq_entry_Handle CAsn2FastaApp::ObtainSeqEntryFromBioseq( CObjectIStream& is) // -------------------------------------------------------------------------- { try { CRef<CBioseq> bs(new CBioseq); is >> *bs; CBioseq_Handle bsh = m_Scope->AddBioseq(*bs); return bsh.GetTopLevelEntry(); } catch (CException& e) { if (! (is.GetFailFlags() & is.eEOF)) { ERR_POST(Error << e); } } return CSeq_entry_Handle(); }
// -------------------------------------------------------------------------- CSeq_entry_Handle CAsn2FastaApp::ObtainSeqEntryFromSeqEntry( CObjectIStream& is) // -------------------------------------------------------------------------- { try { CRef<CSeq_entry> se(new CSeq_entry); is >> *se; if (se->Which() == CSeq_entry::e_not_set) { NCBI_THROW(CException, eUnknown, "provided Seq-entry is empty"); } return m_Scope->AddTopLevelSeqEntry(*se); } catch (CException& e) { if (! (is.GetFailFlags() & is.eEOF)) { ERR_POST(Error << e); } } return CSeq_entry_Handle(); }
void Serial_FilterSkip(CObjectIStream& in, CObjectTypeInfo& ctype) { in.Skip(ctype); }
void Read(CObjectIStream& in, TObjectPtr object, TTypeInfo type) { in.Read(object, type); }
void Read(CObjectIStream& in, TObjectPtr object, const CTypeRef& type) { //type.Get()->SetDefault(object); in.Read(object, type.Get()); }
void CObjectOStreamAsn::CopyEnum(const CEnumeratedTypeValues& values, CObjectIStream& in) { TEnumValueType value = in.ReadEnum(values); WriteEnum(values, value, values.FindName(value, values.IsInteger())); }
void CObjectOStream::CopyGi(CObjectIStream& in) { TGi obj; in.ReadGi(obj); WriteGi(obj); }
void CObjectsSniffer::ProbeASN1_Bin(CObjectIStream& input) { TCandidates::const_iterator last_cand = m_Candidates.end(); for ( ;; ) { m_StreamPos = input.GetStreamPos(); if ( last_cand != m_Candidates.end() ) { // Check the previously found candidate first // (performance optimization) try { TCandidates::const_iterator it = last_cand; CObjectInfo object_info(it->type_info.GetTypeInfo()); input.Read(object_info); m_TopLevelMap.push_back( SObjectDescription(it->type_info, m_StreamPos)); _TRACE("Same type ASN.1 binary top level object found:" << it->type_info.GetTypeInfo()->GetName()); continue; } catch ( CEofException& ) { // no more objects return; } catch ( exception& ) { Reset(); input.SetStreamPos(m_StreamPos); } } bool found = false; // Scan through all candidates ITERATE ( TCandidates, it, m_Candidates ) { if ( it == last_cand ) { // already tried continue; } try { CObjectInfo object_info(it->type_info.GetTypeInfo()); input.Read(object_info); found = true; last_cand = it; m_TopLevelMap.push_back( SObjectDescription(it->type_info, m_StreamPos)); LOG_POST_X(2, Info << "ASN.1 binary top level object found:" << it->type_info.GetTypeInfo()->GetName()); break; } catch ( CEofException& ) { // no more objects return; } catch ( exception& ) { Reset(); input.SetStreamPos(m_StreamPos); } } if ( !found ) { // no matching candidate break; } } // while }
static void Skip(CObjectIStream& in, TTypeInfo ) { in.SkipNull(); }
virtual void SkipChoiceVariant(CObjectIStream& in, const CObjectTypeInfoCV& passed_info) { cout << in.GetStackPath() << endl; #if 1 DefaultSkip(in, passed_info); #else // get information about the variant // typeinfo of the parent class (Seq-annot.data) CObjectTypeInfo oti = passed_info.GetChoiceType(); // typeinfo of the variant (SET OF Seq-feat) CObjectTypeInfo omti = passed_info.GetVariantType(); // index of the variant in parent class (1) TMemberIndex mi = passed_info.GetVariantIndex(); // information about the variant, including its name (ftable) const CVariantInfo* minfo = passed_info.GetVariantInfo(); #if 1 // or read the whole SET OF Seq-feat at once CObjectInfo oi(passed_info); DefaultRead(in, oi); cout << MSerial_AsnText << oi << endl; #endif #if 0 // or read CSeq_feat objects one by one for ( CIStreamContainerIterator i(in, passed_info.GetVariantType()); i; ++i ) { CSeq_feat feat; i >> feat; cout << MSerial_AsnText << feat << endl; } #endif #if 0 // or read CSeq_feat objects one by one and write them into stdout unique_ptr<CObjectOStream> out(CObjectOStream::Open(eSerial_AsnText, "stdout", eSerial_StdWhenStd)); COStreamContainer o(*out, passed_info.GetVariantType()); for ( CIStreamContainerIterator i(in, passed_info.GetVariantType()); i; ++i ) { CSeq_feat feat; i >> feat; // NOTE: this does not produce well formed text ASN, because of missing typeinfo name // this would work though if we copied data into existing ASN stream // where typeinfo name ("file header") is not required // o << feat; // if we needed well formed text ASN, we could write it like this: cout << MSerial_AsnText << feat; } #endif #if 0 // or read the whole SET OF Seq-feat at once CSeq_annot::TData::TFtable ft; CObjectInfo oi(&ft, passed_info.GetVariantType().GetTypeInfo()); // or, like this: // CObjectInfo oi(passed_info.GetVariantType()); in.ReadObject(oi); // write them one by one for( const auto& e: ft) { cout << MSerial_AsnText << *e << endl; } // or write them all at once unique_ptr<CObjectOStream> out(CObjectOStream::Open(eSerial_AsnText, "stdout", eSerial_StdWhenStd)); out->WriteObject(oi); #endif #endif }
void CChoiceTypeInfoFunctions::ReadChoiceDefault(CObjectIStream& in, TTypeInfo objectType, TObjectPtr objectPtr) { const CChoiceTypeInfo* choiceType = CTypeConverter<CChoiceTypeInfo>::SafeCast(objectType); BEGIN_OBJECT_FRAME_OF3(in, eFrameChoice, choiceType, objectPtr); in.BeginChoice(choiceType); BEGIN_OBJECT_FRAME_OF(in, eFrameChoiceVariant); TMemberIndex index = in.BeginChoiceVariant(choiceType); if ( index == kInvalidMember ) { if (in.CanSkipUnknownVariants()) { in.SkipAnyContentVariant(); } else { in.ThrowError(in.fFormatError, "choice variant id expected"); } } else { for (;;) { const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index); if (variantInfo->GetId().IsAttlist()) { const CMemberInfo* memberInfo = static_cast<const CMemberInfo*>( choiceType->GetVariants().GetItemInfo(index)); memberInfo->ReadMember(in,objectPtr); in.EndChoiceVariant(); index = in.BeginChoiceVariant(choiceType); if ( index == kInvalidMember ) { if (in.CanSkipUnknownVariants()) { in.SkipAnyContentVariant(); break; } else { in.ThrowError(in.fFormatError, "choice variant id expected"); } } variantInfo = choiceType->GetVariantInfo(index); } in.SetTopMemberId(variantInfo->GetId()); variantInfo->ReadVariant(in, objectPtr); in.EndChoiceVariant(); break; } } END_OBJECT_FRAME_OF(in); in.EndChoice(); END_OBJECT_FRAME_OF(in); }