如何在gSOAP中绑定多态类型
How to bind polymorphic types in gSOAP
我正在尝试做什么，利用gSOAP:
- 在XML模式中定义数据结构
- 使用wsdl2h和soapcp2生成表示这些结构的C++类
- 用C语言在XML中读写这些结构++
请注意，我现在没有使用Web服务，我只是对XML数据绑定感兴趣。
如果我的课程看起来像：
类基础{。。。}
类Der1：公共基础{。。}
类Der2：公共基础{。。。}
然后我可以使用序列化Base对象(它实际上可能是派生类型之一)
std::ofstream myFile;
myFile.open("output.out");
ctx.os = &myFile;
Der1 obj; // or Der2 obj...
// ... populate obj
if (soap_write_Base(ctx, dynamic_cast<Base*>(&obj)) == SOAP_OK)
{
std::cout << "message serialized" << std::endl;
} else
{
soap_print_fault(ctx, stderr);
}
并使用进行反序列化
std::ifstream myFile;
myFile.open("output.out");
ctx.is = &myFile;
Der1 obj;
if (soap_read_Der1(ctx, &obj) == SOAP_OK)
{
std::cout << "message deserialized" << std::endl;
printMessage(msg); //debug
} else
{
soap_print_fault(ctx, stderr);
}
其中ctx是指向soap上下文的指针，声明为：
soap* ctx = soap_new2(SOAP_XML_STRICT, SOAP_XML_INDENT);
代码中的其他部分。
有人能告诉我如何更改上面的反序列化代码，使其能够在不预先知道对象是Der1、Der2还是Base对象的情况下读取对象吗？
谢谢！
您需要做几件事。
首先，构建C++对象，使它们从xsd__anyType(wsdl2h上的-p选项)派生
编译代码时，定义WITH_NO_IO和WITH_NO_HTTP，这样就不会得到默认的gSoap HTTP和IO调用。
然后，创建一个Serializer类，类似于(请原谅对XML的咆哮)：
#pragma once
#include <memory>
namespace MyLib
{
class SerializerImpl;
class xsd__anyType;
class Serializer
{
std::shared_ptr<SerializerImpl> ser;
public:
Serializer();
Serializer(Serializer const &) = default;
Serializer(Serializer &&o) : ser(std::forward<Serializer>(o).ser) { }
~Serializer() = default;
Serializer &operator=(Serializer const& rhs) = default;
Serializer &operator=(Serializer && rhs)
{
ser = std::forward<Serializer>(rhs).ser;
return *this;
}
// Serialize 'value' into 'out'.
void Serialize(xsd__anyType const &value, std::ostream &out);
// Returns a shared pointer to the xsd_anyType that comes in 'in'.
// The shared_ptr returned contains a custom deleter because gSoap ties
// allocated values to the gSoap context used to deserialize it in the
// first place. I think that was an attempt at adding some kind of
// garbage collection so one didn't have to worry about deleting it except,
// of course, that fails if you get rid of the context prior to the
// end of the life of the deserialized value. Nobody does XML C++ bindings
// right. XML sucks and C++ doesn't and it is hard to translate suck to
// non-suck.
std::shared_ptr<xsd__anyType> Deserialize(std::istream &in);
};
}
实现看起来像：
#include "MyLibH.h"
#include "stdsoap2.h"
#include "Serializer.h"
namespace MyLib
{
static int fsend(struct soap* ctx, char const *buf, size_t len)
{
if (!ctx->os)
{
throw std::logic_error("soap.fsend the struct soap 'os' member must be set.");
}
ctx->os->write(buf, len);
return SOAP_OK;
}
static size_t frecv(struct soap* ctx, char* buf, size_t len)
{
if (!ctx->is)
{
throw std::logic_error("soap.fsend the struct soap 'is' member must be set.");
}
ctx->is->read(buf, len);
return ctx->is->gcount();
}
static SOAP_SOCKET fopen(struct soap*, const char*, const char*, int)
{
throw std::logic_error("soap.fopen not implemented for Serializer.");
}
static int fclose(struct soap *ctx)
{
return SOAP_OK;
}
static int fclosesocket(struct soap*, SOAP_SOCKET)
{
throw std::logic_error("soap.fclosesocket not implemented for Serializer.");
}
static int fshutdownsocket(struct soap*, SOAP_SOCKET, int)
{
throw std::logic_error("soap.fshutdownsocket not implemented for Serializer.");
}
static SOAP_SOCKET faccept(struct soap*, SOAP_SOCKET, struct sockaddr*, int *n)
{
throw std::logic_error("soap.faccept not implemented for Serializer.");
}
class SerializerImpl
{
struct soap mutable soap;
public:
SerializerImpl();
~SerializerImpl();
struct soap *ctx() const { return &soap; }
};
SerializerImpl::SerializerImpl()
{
soap_init(&soap);
// compiled with WITH_NOIO so set these function pointers
soap.fsend = fsend;
soap.frecv = frecv;
soap.fopen = fopen;
soap.fclose = fclose;
soap.fclosesocket = fclosesocket;
soap.fshutdownsocket = fshutdownsocket;
soap.fpoll = nullptr;
soap.faccept = faccept;
// Set input/output mode
soap_imode(&soap, SOAP_ENC_XML);
soap_set_omode(&soap, SOAP_XML_INDENT);
}
SerializerImpl::~SerializerImpl()
{
// remove deserialized class instances (C++ objects)
soap_destroy(&soap);
// clean up and remove deserialized data
soap_end(&soap);
// detach context (last use and no longer in scope)
soap_done(&soap);
}
Serializer::Serializer() : ser(std::make_shared<SerializerImpl>())
{
}
void Serializer::Serialize(xsd__anyType const& value, std::ostream &out)
{
soap_begin(ser->ctx());
ser->ctx()->is = ∈
soap_free_temp(ser->ctx());
int type;
int err;
char errbuf[200];
if ((err = soap_begin_recv(ser->ctx())) != SOAP_OK)
{
_snprintf_s(
errbuf,
sizeof(errbuf),
_TRUNCATE,
"Serializer::Deserialize failed soap_begin_recv: %d",
err);
errbuf[sizeof(errbuf) - 1] = 0;
throw std::exception(errbuf);
}
// Create a deleter for the element returned from 'soap_getelement()'
auto serializerImpl = this->ser;
auto deleteElement = [serializerImpl](void *toDelete)
{
soap_dealloc(serializerImpl->ctx(), toDelete);
};
// parse the XML into an element
std::unique_ptr<void, decltype(deleteElement)>
res(soap_getelement(ser->ctx(), &type), deleteElement);
if (!res)
{
// populate ser->ctx()->msgbuf with more detailed information
soap_set_fault(ser->ctx());
if (ser->ctx()->msgbuf)
{
_snprintf_s(
errbuf,
sizeof(errbuf),
_TRUNCATE,
"Serializer::Deserialize failed soap_getelement: %s",
ser->ctx()->msgbuf);
}
else
{
_snprintf_s(
errbuf,
sizeof(errbuf),
_TRUNCATE,
"Serializer::Deserialize failed soap_getelement: %d",
ser->ctx()->error);
}
errbuf[sizeof(errbuf) - 1] = 0;
throw std::exception(errbuf);
}
if ((err = soap_end_recv(ser->ctx())) != SOAP_OK)
{
_snprintf_s(
errbuf,
sizeof(errbuf),
_TRUNCATE,
"Serializer::Deserialize failed soap_end_recv: %d",
err);
errbuf[sizeof(errbuf) - 1] = 0;
throw std::exception(errbuf);
}
// anything that can be cast as an xml_Any gets cast here
switch (type)
{
case SOAP_TYPE_MyLib_ns1__FooType:
case SOAP_TYPE_MyLib_ns1__BarType:
case SOAP_TYPE_MyLib_ns1__BazType:
// In theory, res is a subclass of xsd_anyType, so cast
// it here as if it was
auto anyType = static_cast<xsd__anyType *>(res.release());
// build a shared pointer with the custom deleter that keeps serializerImpl
auto ret = std::shared_ptr<xsd__anyType>(anyType, deleteElement);
return ret;
}
_snprintf_s(
errbuf,
sizeof(errbuf),
_TRUNCATE,
"Serializer::Deserialize failed - "
"unsupported cast of type %d to xsd__anyType",
type);
errbuf[sizeof(errbuf) - 1] = 0;
throw std::exception(errbuf);
}
}
使用这个类，您可以创建一个Serializer ser;，然后执行ser.Serialize(myEntity, myOutputStream);或auto myEntity = ser.Deserialize(myInputStream);。
您可以在Deserialize()方法中看到多态反序列化的秘密，在该方法中，它调用soap_getelement()，为它可以反序列化的任何类型返回一个void指针。然后，如果该类型是已知基于xsd__anyType的类型，那么它将被强制转换为具有自定义删除方法的shared_ptr<xsd__anyType>，该方法保留struct soap上下文，以便它可以以适当的gSoap方式进行删除。转换为xsd__anyType的能力是我们告诉wsdl2h使用-p选项从该类型派生所有类型的原因。
请注意，为了让它为我工作，我必须创建一些其他函数。定义了I用wsdl2h和soapcpp2、WITH_NOGLOBAL构建源的方法。这导致了一些未定义的函数。我以以下方式进行了定义：
#include "MyLib3.nsmap"
SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
{
static char const *ret;
ret = nullptr;
return &ret;
}
SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
{
static char const *ret;
ret = nullptr;
return &ret;
}
SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
{
static char const *ret;
ret = nullptr;
return &ret;
}
SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
{
static char const *ret;
ret = nullptr;
return &ret;
}
SOAP_FMAC3 const char * SOAP_FMAC4 soap_check_faultsubcode(struct soap *soap)
{
return nullptr;
}
SOAP_FMAC3 const char * SOAP_FMAC4 soap_check_faultdetail(struct soap *soap)
{
return nullptr;
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
{
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
{
}
SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
{
return SOAP_OK;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
{
return SOAP_OK;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
{
return SOAP_OK;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
{
return SOAP_OK;
}
相关文章：
- 在 openGL 中多次绑定缓冲区
- sqlite3绑定多个语句值
- 结构化绑定语法是否可以在多态 lambda 中使用
- C 使用多个lambdas/绑定以引用相同的功能
- 将多个纹理 OpenGL 绑定到不同的四边形
- 多态变体，并将一种类型的引用绑定到另一种类型的引用
- 前向迭代器与多个绑定相结合的迭代速度太快
- 如何在gSOAP中绑定多态类型
- 如何在多个接口上绑定到同一 UDP 端口
- (DirectX 11）单个顶点缓冲区是否可以一次绑定到多个 IA 输入槽
- boost::asio::deadline_timer绑定到多态套接字类指针
- vtable(动态绑定）的C++思想中的多态性
- C++多变量模板未绑定到函数参数
- 如何将C++函数绑定到lua，该函数使用luabind返回多个值
- 在C++中绑定了多个引用的临时的生存期
- 具有静态绑定成员函数指针的可变模板的多个专业化
- Qt5绑定多宿主网络TCP套接字
- 如何在OpenGL中从一个VBO绑定多个ibo
- 一个VBO可以绑定多个vao
- c++多态性:为什么即使类型很明显，静态绑定也是不可能的
