C++ CObjectOStream类代码示例

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 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);
}