CObjectOStream* CObjectOStream::Open(ESerialDataFormat format, CNcbiOstream& outStream, EOwnership edeleteStream, TSerial_Format_Flags formatFlags) { CObjectOStream* os = NULL; bool deleteStream = edeleteStream == eTakeOwnership; switch ( format ) { case eSerial_AsnText: os = OpenObjectOStreamAsn(outStream, deleteStream); break; case eSerial_AsnBinary: os = OpenObjectOStreamAsnBinary(outStream, deleteStream); break; case eSerial_Xml: os = OpenObjectOStreamXml(outStream, deleteStream); break; case eSerial_Json: os = OpenObjectOStreamJson(outStream, deleteStream); break; default: break; } if (os != NULL) { os->SetFormattingFlags(formatFlags); return os; } NCBI_THROW(CSerialException,eNotImplemented, "CObjectOStream::Open: unsupported format"); }
void CChoiceTypeInfoFunctions::WriteChoiceDefault(CObjectOStream& out, TTypeInfo objectType, TConstObjectPtr objectPtr) { const CChoiceTypeInfo* choiceType = CTypeConverter<CChoiceTypeInfo>::SafeCast(objectType); BEGIN_OBJECT_FRAME_OF3(out, eFrameChoice, choiceType, objectPtr); out.BeginChoice(choiceType); TMemberIndex index = choiceType->GetVariants().FirstIndex(); const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index); if (variantInfo->GetId().IsAttlist()) { const CMemberInfo* memberInfo = dynamic_cast<const CMemberInfo*>( choiceType->GetVariants().GetItemInfo(index)); memberInfo->WriteMember(out,objectPtr); } index = choiceType->GetIndex(objectPtr); if ( index == kInvalidMember ) out.ThrowError(out.fInvalidData, "cannot write empty choice"); variantInfo = choiceType->GetVariantInfo(index); BEGIN_OBJECT_FRAME_OF2(out, eFrameChoiceVariant, variantInfo->GetId()); out.BeginChoiceVariant(choiceType, variantInfo->GetId()); variantInfo->WriteVariant(out, objectPtr); out.EndChoiceVariant(); END_OBJECT_FRAME_OF(out); out.EndChoice(); END_OBJECT_FRAME_OF(out); }
static void Write(CObjectOStream& out, TTypeInfo , TConstObjectPtr objectPtr) { if ( objectPtr != 0 ) { out.ThrowError(out.fInvalidData, "non-null value when writing NULL member"); } out.WriteNull(); }
CRef< CTaxon3_reply > CTaxon3::SendRequest(const CTaxon3_request& request) { SetLastError(NULL); unsigned reconnect_attempts = 0; while (reconnect_attempts < m_nReconnectAttempts) { try { auto_ptr<CObjectOStream> pOut; auto_ptr<CObjectIStream> pIn; auto_ptr<CConn_ServiceStream> pServer( new CConn_ServiceStream(m_sService, fSERV_Any, 0, 0, m_timeout) ); pOut.reset( CObjectOStream::Open(m_eDataFormat, *pServer) ); pIn.reset( CObjectIStream::Open(m_eDataFormat, *pServer) ); CObjectIStream* ppIn = pIn.release(); CObjectOStream* ppOut = pOut.release(); try { *ppOut << request; ppOut->Flush(); ppOut->Close(); try { CRef< CTaxon3_reply > response(new CTaxon3_reply); *ppIn >> *response; delete ppIn; delete ppOut; return response; } catch (exception& e) { SetLastError( e.what() ); } } catch (exception& e) { SetLastError( e.what() ); } } catch( exception& e ) { SetLastError( e.what() ); } reconnect_attempts++; } // return NULL CRef<CTaxon3_reply> reply; return reply; }
void CAliasTypeInfoFunctions::WriteAliasDefault(CObjectOStream& out, TTypeInfo objectType, TConstObjectPtr objectPtr) { const CAliasTypeInfo* aliasType = CTypeConverter<CAliasTypeInfo>::SafeCast(objectType); out.WriteAlias(aliasType, objectPtr); }
void CContainerTypeInfo::WriteContainer(CObjectOStream& out, TTypeInfo objectType, TConstObjectPtr objectPtr) { const CContainerTypeInfo* containerType = CTypeConverter<CContainerTypeInfo>::SafeCast(objectType); out.WriteContainer(containerType, objectPtr); }
void CPointerTypeInfo::WritePointer(CObjectOStream& out, TTypeInfo objectType, TConstObjectPtr objectPtr) { const CPointerTypeInfo* pointerType = CTypeConverter<CPointerTypeInfo>::SafeCast(objectType); out.WritePointer(pointerType->GetObjectPointer(objectPtr), pointerType->GetPointedType()); }
void Write(CObjectOStream& out, TConstObjectPtr object, TTypeInfo type) { out.Write(object, type); }
void Write(CObjectOStream& out, TConstObjectPtr object, const CTypeRef& type) { out.Write(object, type.Get()); }
void CSoapMessage::Write(CObjectOStream& out) const { CObjectOStreamXml* os = 0; bool schema = false, loc = false; string ns_default; ESerialDataFormat fmt = out.GetDataFormat(); if (fmt == eSerial_Xml) { os = dynamic_cast<CObjectOStreamXml*>(&out); if (os) { schema = os->GetReferenceSchema(); os->SetReferenceSchema(); loc = os->GetUseSchemaLocation(); os->SetUseSchemaLocation(false); ns_default = os->GetDefaultSchemaNamespace(); os->SetDefaultSchemaNamespace(GetSoapNamespace()); } } CSoapEnvelope env; if (!m_Header.empty()) { // This is to make the stream think the Header was not empty. // Since Header is optional, we do not have to make it *always* CRef<CAnyContentObject> h(new CAnyContentObject); env.SetHeader().SetAnyContent().push_back(h); } // This is to make the stream think the Body was not empty. // Body is mandatory CRef<CAnyContentObject> h(new CAnyContentObject); env.SetBody().SetAnyContent().push_back(h); CSoapFault* flt = 0; if (!m_FaultDetail.empty()) { // This is to make the stream think the Detail was not empty. // Since Detail is optional, we do not have to make it *always* flt = dynamic_cast<CSoapFault*>(const_cast<CSerialObject*>( GetSerialObject("Fault", eMsgBody).GetPointer())); if (!flt) { // throw exception here (?) } else { CRef<CAnyContentObject> h2(new CAnyContentObject); flt->SetDetail().SetAnyContent().push_back(h2); } } CObjectTypeInfo typeH = CType<CSoapHeader>(); typeH.SetLocalWriteHook(out, new CSoapWriteHook(m_Header)); CObjectTypeInfo typeB = CType<CSoapBody>(); typeB.SetLocalWriteHook(out, new CSoapWriteHook(m_Body)); CObjectTypeInfo typeF = CType<CSoapFault::C_Detail>(); typeF.SetLocalWriteHook(out, new CSoapWriteHook(m_FaultDetail)); x_VerifyFaultObj(true); out << env; x_VerifyFaultObj(false); if (flt) { flt->SetDetail().SetAnyContent().clear(); } if (os) { os->SetReferenceSchema(schema); os->SetUseSchemaLocation(loc); os->SetDefaultSchemaNamespace(ns_default); } }
void CWriteChoiceVariantHook::CustomWrite(CObjectOStream& out, const CConstObjectInfoCV& variant, const CConstObjectInfo& custom_object) { out.WriteExternalObject(custom_object.GetObjectPtr(), variant.GetVariantInfo()->GetTypeInfo()); }
void CWriteChoiceVariantHook::DefaultWrite(CObjectOStream& out, const CConstObjectInfoCV& variant) { out.WriteChoiceVariant(variant); }
void CWriteClassMemberHook::CustomWrite(CObjectOStream& out, const CConstObjectInfoMI& member, const CConstObjectInfo& custom_object) { const CMemberInfo* memberInfo = member.GetMemberInfo(); out.WriteClassMember(memberInfo->GetId(), memberInfo->GetTypeInfo(), custom_object.GetObjectPtr()); }
void CWriteClassMemberHook::DefaultWrite(CObjectOStream& out, const CConstObjectInfoMI& member) { out.WriteClassMember(member); }