void CEnemyMeleeAttack::process(const std::shared_ptr<Logic::IMessage> &message)
{
if(message->getType() == "CONTROLLER_TOUCHED")
{
CEntity* other = dynamic_cast<CONTROLLER_TOUCHED*>(message.get())->getEntidad();
if(other->getEntityID() == _targetID && _entity->getTag() == "enemy" && canDoDamage())
{
ApplyDamage(other);
}
}
else if (message->getType() == "CHANGE_TARGET")
{
// Si no encuentra la palabra "Minion" en el tipo de entidad, entonces puede canibalizar
if (_entity->getType().find("Minion") == std::string::npos)
{
_target = dynamic_cast<CHANGE_TARGET*>(message.get())->getLogicEntity();
if (_target)
_targetID = _target->getEntityID();
}
}
} // process
bool UILogic::handle(const gearsbox::ViewEventParam & param, const std::shared_ptr<gearsbox::ViewGen> & view){
if (nullptr == view){
G_LOG_FC(LOG_ERROR, "handle event viewgen null");
return false;
}
//G_LOG_FC(LOG_INFO, "handle event view:%s event:%d text:%s", view->getId().c_str(), param.type, param.text.c_str());
if (ViewType::LABEL == view->getType()){
if (m_input->getText().size() != 0)
updateValueLabel(view->getId(), false);
PlatformUtilityGen::instance()->getExcutor()->endEniting(true);
}
else if (ViewType::BASE == view->getType()){
PlatformUtilityGen::instance()->getExcutor()->endEniting(true);
}
else if (ViewType::INPUT == view->getType()){
if (view == m_input && param.text.size()>0){
view->getText();
m_value = atof(param.text.c_str());
//UsnitGen::instance()->setInput(value);
updateValueLabel("", true);
}
}
return true;
}
void models::Property::setValue(std::shared_ptr<libConfig::ConfigValue> newVal)
{
if(!value)
{
switch(newVal->getType())
{
case libConfig::ConfigValue::ARRAY:
value.reset(new libConfig::ArrayConfigValue());
break;
case libConfig::ConfigValue::COMPLEX:
value.reset(new libConfig::ComplexConfigValue());
break;
case libConfig::ConfigValue::SIMPLE:
value.reset(new libConfig::SimpleConfigValue(""));
break;
}
value->setName(getName());
}
if(value->getType() != newVal->getType())
throw std::runtime_error("Error, configuration values may not change !");
value = newVal;
}
std::vector<uint8_t>
JSZCluster::addArgument(v8::Local<v8::Value> value, const std::shared_ptr<ClusterCmdParamsBase> &cmdParam) {
if (value->IsUint32()) {
return cmdParam->getType().getRaw(value->ToUint32()->Value());
}
if (value->IsInt32()) {
return cmdParam->getType().getRaw(value->ToInt32()->Value());
}
if (value->IsString()) {
String::Utf8Value utf8Value(value);
return cmdParam->getType().getRaw(*utf8Value);
}
if (value->IsArray()) {
Local<Array> array = value.As<Array>();
std::vector<std::string> strArray;
for (uint32_t index = 0; index < array->Length(); index++) {
String::Utf8Value utf8Value(array->Get(index));
strArray.push_back(*utf8Value);
}
return cmdParam->getType().getRaw(strArray);
}
stringstream stream;
stream << "To " << EXECUTE_CMD_BY_ID << " it is passed an invalid argument instead of type "
<< cmdParam->getZCLDataType();
throw JSException(stream.str());
}
bool CShieldSpecialController::accept(const std::shared_ptr<Logic::IMessage> &message)
{
return message->getType() == "FALLING" ||
message->getType() == "UP_COLLISION" ||
message->getType() == "SIDE_COLLISION" ||
message->getType() == "TOUCHED";
} // accept
bool CIADodge::accept(const std::shared_ptr<Logic::IMessage> &message)
{
return message->getType() == "DAMAGED" ||
message->getType() == "FALLING" ||
message->getType() == "CHANGE_TARGET" ||
message->getType() == "CAN_IA";
}
std::string PubSubErrorSerializer::serializePayload(std::shared_ptr<PubSubError> payload) const {
if (payload->getType() == PubSubError::UnknownType) {
return "";
}
XMLElement element(serializeType(payload->getType()), "http://jabber.org/protocol/pubsub#errors");
if (payload->getType() == PubSubError::Unsupported) {
if (payload->getUnsupportedFeatureType() != PubSubError::UnknownUnsupportedFeatureType) {
element.setAttribute("feature", serializeUnsupportedFeatureType(payload->getUnsupportedFeatureType()));
}
}
return element.serialize();
}
static void _toArray(const YAML::Node& node, std::shared_ptr<Array>& a) {
NTA_CHECK(node.Type() == YAML::NodeType::Sequence);
a->allocateBuffer(node.size());
void *buffer = a->getBuffer();
for (size_t i = 0; i < node.size(); i++) {
const YAML::Node &item = node[i];
NTA_CHECK(item.Type() == YAML::NodeType::Scalar);
switch (a->getType()) {
case NTA_BasicType_Byte:
// We should have already detected this and gone down the string path
NTA_THROW << "Internal error: attempting to convert YAML string to array "
"of type Byte";
break;
case NTA_BasicType_UInt16:
((UInt16*)buffer)[i] = item.as<UInt16>();
break;
case NTA_BasicType_Int16:
((Int16*)buffer)[i] = item.as<Int16>();
break;
case NTA_BasicType_UInt32:
((UInt32*)buffer)[i] = item.as<UInt32>();
break;
case NTA_BasicType_Int32:
((Int32*)buffer)[i] = item.as<Int32>();
break;
case NTA_BasicType_UInt64:
((UInt64*)buffer)[i] = item.as<UInt64>();
break;
case NTA_BasicType_Int64:
((Int64*)buffer)[i] = item.as<Int64>();
break;
case NTA_BasicType_Real32:
((Real32*)buffer)[i] = item.as<Real32>();
break;
case NTA_BasicType_Real64:
((Real64*)buffer)[i] = item.as<Real64>();
break;
case NTA_BasicType_Bool:
((bool*)buffer)[i] = item.as<bool>();
break;
default:
// should not happen
NTA_THROW << "Unknown data type " << a->getType();
}
}
}
void CLife::process(const std::shared_ptr<Logic::IMessage> &message)
{
if (message->getType() == "INVINCIBLE")
{
_invincible = dynamic_cast<INVINCIBLE*>(message.get())->getBool();
}
} // process
void PubSubOwnerAffiliationConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubOwnerAffiliation> payload) {
lua_createtable(L, 0, 0);
lua_pushstring(L, payload->getJID().toString().c_str());
lua_setfield(L, -2, "jid");
switch (payload->getType()) {
case PubSubOwnerAffiliation::None:
lua_pushstring(L, "none");
break;
case PubSubOwnerAffiliation::Member:
lua_pushstring(L, "member");
break;
case PubSubOwnerAffiliation::Outcast:
lua_pushstring(L, "outcast");
break;
case PubSubOwnerAffiliation::Owner:
lua_pushstring(L, "owner");
break;
case PubSubOwnerAffiliation::Publisher:
lua_pushstring(L, "publisher");
break;
case PubSubOwnerAffiliation::PublishOnly:
lua_pushstring(L, "publish_only");
break;
}
lua_setfield(L, -2, "type");
}
void CAltStatesController::process(const std::shared_ptr<Logic::IMessage> &message)
{
if(message->getType().compare("SET_ALTSTATE") == 0)
{
std::string state = dynamic_cast<SET_ALTSTATE*>(message.get())->getString();
// Buscamos a ver si ya ha contraido el estado alterado, y de ser así no hacemos nada
bool found = false;
for (int i = 0; i < _vecAltStates.size(); ++i)
{
if (_vecAltStates.at(i).name == state)
found = true;
}
// Si no lo tenia ya el enemigo, se lo aplicamos
if (!found)
{
AltState altState = {state, false, true, 0};
_vecAltStates.push_back(altState);
}
}
}
void CSwordSlashController::process(const std::shared_ptr<Logic::IMessage> &message)
{
if((message->getType().compare("TOUCHED") == 0))
{
Logic::CEntity *otherEntity = dynamic_cast<TOUCHED*>(message.get())->getEntidad();
if(otherEntity)
{
if (otherEntity->getTag() == "enemy")
{
if(_damage>0)
{
std::shared_ptr<DAMAGED> m(new DAMAGED());
m->setFloat(_damage);
m->setString(_entity->getType());
otherEntity->emitMessage(m);
std::shared_ptr<PUSH> pushMessage(new PUSH());
pushMessage->setDirection(_direction);
pushMessage->setSpeed(0.5f);
otherEntity->emitMessage(pushMessage, this);
//BaseSubsystems::Log::Debug("ÑAPA: " + std::to_string(_damage));
}
Logic::CEntityFactory::getSingletonPtr()->createEntityByType("ChispaDanhoEnemy",
otherEntity->getCenterPosition(),
_entity->getMap());
}
}
}
} // process
std::shared_ptr<BaseType> buildJavaNode(JNIEnv *jvEnv, std::shared_ptr<Node> node,
std::list<std::shared_ptr<BaseType> > stack)
{
std::shared_ptr<BaseType> obj;
switch (node->getType()) {
case Node::kDictionary:
obj.reset(new DictionaryType(jvEnv));
break;
case Node::kCollection:
obj.reset(new CollectionType(jvEnv));
break;
case Node::kInt8: case Node::kInt32: case Node::kInt64:
case Node::kUInt8: case Node::kUInt32: case Node::kUInt64:
obj.reset(new IntegerType(jvEnv));
break;
case Node::kFloat: case Node::kDouble:
obj.reset(new DoubleType(jvEnv));
break;
case Node::kString:
obj.reset(new StringType(jvEnv));
break;
default:
obj.reset(new UnknownType(jvEnv));
break;
}
if (stack.size() > 0) {
std::shared_ptr<BaseType> parent = stack.back();
parent->append(node->getName(), obj);
}
return obj;
}
std::unique_ptr<SatelliteServer>
SatelliteServer::Create(std::shared_ptr<SatelliteServerInfo> info) {
std::unique_ptr<SatelliteServer> satellite;
if (info->getPort()) {
switch (info->getType()) {
case Type::KindOfInternalPageServer:
satellite.reset(new InternalPageServer(info));
break;
case Type::KindOfDanglingPageServer:
satellite.reset(new DanglingPageServer(info));
break;
case Type::KindOfRPCServer:
satellite.reset(new RPCServer(info));
break;
case Type::KindOfXboxServer:
satellite.reset(new RPCServer(info));
break;
default:
assert(false);
}
if (satellite) {
satellite->setName(info->getName());
}
}
return satellite;
}
bool ComplexConfigValue::merge(std::shared_ptr<ConfigValue> other)
{
if(other->getType() != COMPLEX)
return false;
if(name != other->getName())
{
throw std::runtime_error("Internal Error, merge between mismatching value");
}
const ComplexConfigValue *cother = dynamic_cast<const ComplexConfigValue *>(other.get());
for(const auto &it : cother->values)
{
std::map<std::string, std::shared_ptr<ConfigValue> >::iterator entry = values.find(it.first);
if(entry != values.end())
{
if(!entry->second->merge(it.second))
return false;
}
else
{
values.insert(it);
}
}
return true;
}
void GameState::onNotify(std::shared_ptr<baseEvent> e){
switch(e->getType()){
case EventType::LEVEL_COMPLETE:{
if(currentLevel<(totalLevels-1)){
++currentLevel;
eventQueue = level->getEventQueue(currentLevel);
gameEventDispatcher = level->getGameEventDispatcher(currentLevel);
gameEventDispatcher->LevelComplete.addObserver(this);
gameEventDispatcher->LevelFailed.addObserver(this);
gameEventDispatcher->UpdateScore.addObserver(this);
}else if(currentLevel == (totalLevels-1)){
requestStackPush(AppStates::GameSucceed);
}
}
break;
case EventType::LEVEL_FAILED:{
requestStackPush(AppStates::GameFailed);
}
break;
case EventType::UPDATE_SCORE:{
score += std::get<0>(e->getAttributes<EventsAlias::update_score>());
textScore.setString(Utils::toString(score));
}
break;
default:
break;
}
}
void
StatBucketOperation::onReceive(DistributorMessageSender& sender, const std::shared_ptr<api::StorageReply> & msg)
{
assert(msg->getType() == api::MessageType::STATBUCKET_REPLY);
api::StatBucketReply& myreply(dynamic_cast<api::StatBucketReply&>(*msg));
std::map<uint64_t, uint16_t>::iterator found = _sent.find(msg->getMsgId());
if (found != _sent.end()) {
std::ostringstream ost;
if (myreply.getResult().getResult() == api::ReturnCode::OK) {
ost << "\tBucket information from node " << found->second << ":\n" << myreply.getResults() << "\n\n";
} else {
ost << "\tBucket information retrieval failed on node " << found->second << ": " << myreply.getResult() << "\n\n";
}
_results[found->second] = ost.str();
_sent.erase(found);
}
if (_sent.empty()) {
std::ostringstream ost;
for (std::map<uint16_t, std::string>::iterator iter = _results.begin();
iter != _results.end();
iter++) {
ost << iter->second;
}
api::StatBucketReply::SP reply(new api::StatBucketReply(*_command, ost.str()));
sender.sendReply(reply);
}
}
bool ArrayConfigValue::merge(std::shared_ptr< ConfigValue > other)
{
if(other->getType() != ARRAY)
return false;
if(name != other->getName())
{
throw std::runtime_error("Internal Error, merge between mismatching value");
}
const ArrayConfigValue *aother = dynamic_cast<const ArrayConfigValue *>(other.get());
//we only support direct overwrite by index
for(size_t i = 0; i < aother->values.size(); i++)
{
if(i < values.size())
{
values[i] = aother->values[i];
}
else
{
values.push_back(aother->values[i]);
}
}
return true;
}
void CIARunAway::process(const std::shared_ptr<Logic::IMessage> &message)
{
if (message->getType() == "CHANGE_TARGET")
{
CEntity* ent = dynamic_cast<CHANGE_TARGET*>(message.get())->getLogicEntity();
if(ent != NULL)
{
if(!ent->getIsDead())
{
_target = ent;
if (_target->getCenterPosition().x > _entity->getCenterPosition().x)
{
_direction = -1;
}
else
{
_direction = 1;
}
std::shared_ptr<Logic::TURN> m(new Logic::TURN());
m->setInt(_direction);
_entity->emitMessage(m);
}
}
}
} // process
bool checkSolidTileIntersection(std::shared_ptr<Tile>& tile, HitboxMovementController& object) {
if(!object.getHitbox()) {
return false;
}
TileType type = tile->getType();
sf::FloatRect tileBoundingBox = tile->getBoundingBox();
sf::FloatRect objBoundingBox = object.getHitbox()->getActiveHitboxWorldSpace();
switch(type) {
case TileType::SOLID: {
return tileBoundingBox.intersects(objBoundingBox);
}
default:
return false;
}
return false;
}
WarningShapeNode::WarningShapeNode(std::shared_ptr<dart::dynamics::Shape> shape,
ShapeFrameNode* parent)
: ShapeNode(shape, parent, this)
{
dtwarn << "Shape type (" << shape->getType()
<< ") found in Entity '" << parent->getName()
<< "' is not currently supported by dart::gui::osg, "
<< "and will not be rendered\n";
}
void CGraphics::process(const std::shared_ptr<Logic::IMessage> &message)
{
if(message->getType().compare("SET_MATERIAL") == 0)
{
std::string nameMat = dynamic_cast<SET_MATERIAL*>(message.get())->getString();
_graphicsEntity->setMaterial(nameMat);
}
} // process
Vector3d RandomPointGenerator::pointOnShape(std::shared_ptr<SurgSim::Math::Shape> shape)
{
SURGSIM_ASSERT(shape != nullptr) << "Empty shape passed in.";
auto shapeType = shape->getType();
SURGSIM_ASSERT(SurgSim::Math::SHAPE_TYPE_NONE < shapeType && shapeType < SurgSim::Math::SHAPE_TYPE_COUNT) <<
"Unknown shape type passed in.";
return m_pointGenerators[shapeType]->pointOnShape(shape);
}
static void _toScalar(const YAML::Node &node, std::shared_ptr<Scalar> &s) {
NTA_CHECK(node.Type() == YAML::NodeType::Scalar);
switch (s->getType()) {
case NTA_BasicType_Byte:
// We should have already detected this and gone down the string path
NTA_THROW << "Internal error: attempting to convert YAML string to scalar of type Byte";
break;
case NTA_BasicType_UInt16:
s->value.uint16 = node.as<UInt16>();
break;
case NTA_BasicType_Int16:
s->value.int16 = node.as<Int16>();
break;
case NTA_BasicType_UInt32:
s->value.uint32 = node.as<UInt32>();
break;
case NTA_BasicType_Int32:
s->value.int32 = node.as<Int32>();
break;
case NTA_BasicType_UInt64:
s->value.uint64 = node.as<UInt64>();
break;
case NTA_BasicType_Int64:
s->value.int64 = node.as<Int64>();
break;
case NTA_BasicType_Real32:
s->value.real32 = node.as<Real32>();
break;
case NTA_BasicType_Real64:
s->value.real64 = node.as<Real64>();
break;
case NTA_BasicType_Bool:
s->value.boolean = node.as<bool>();
break;
case NTA_BasicType_Handle:
NTA_THROW << "Attempt to specify a YAML value for a scalar of type Handle";
break;
default:
// should not happen
const std::string val = node.as<std::string>();
NTA_THROW << "Unknown data type " << s->getType() << " for yaml node '" << val << "'";
}
}
std::shared_ptr<XMLElement> FormSerializer::fieldToXML(std::shared_ptr<FormField> field, bool withTypeAttribute) const {
std::shared_ptr<XMLElement> fieldElement(new XMLElement("field"));
if (!field->getName().empty()) {
fieldElement->setAttribute("var", field->getName());
}
if (!field->getLabel().empty()) {
fieldElement->setAttribute("label", field->getLabel());
}
if (field->getRequired()) {
fieldElement->addNode(std::make_shared<XMLElement>("required"));
}
if (!field->getDescription().empty()) {
std::shared_ptr<XMLElement> descriptionElement(new XMLElement("desc"));
descriptionElement->addNode(std::make_shared<XMLTextNode>(field->getDescription()));
fieldElement->addNode(descriptionElement);
}
// Set the value and type
std::string fieldType;
switch (field->getType()) {
case FormField::UnknownType: fieldType = ""; break;
case FormField::BooleanType: fieldType = "boolean"; break;
case FormField::FixedType: fieldType = "fixed"; break;
case FormField::HiddenType: fieldType = "hidden"; break;
case FormField::ListSingleType: fieldType = "list-single"; break;
case FormField::TextMultiType: fieldType = "text-multi"; break;
case FormField::TextPrivateType: fieldType = "text-private"; break;
case FormField::TextSingleType: fieldType = "text-single"; break;
case FormField::JIDSingleType: fieldType = "jid-single"; break;
case FormField::JIDMultiType: fieldType = "jid-multi"; break;
case FormField::ListMultiType: fieldType = "list-multi"; break;
}
if (!fieldType.empty() && withTypeAttribute) {
fieldElement->setAttribute("type", fieldType);
}
for (const auto& value : field->getValues()) {
std::shared_ptr<XMLElement> valueElement = std::make_shared<XMLElement>("value");
valueElement->addNode(std::make_shared<XMLTextNode>(value));
fieldElement->addNode(valueElement);
}
for (const auto& option : field->getOptions()) {
std::shared_ptr<XMLElement> optionElement(new XMLElement("option"));
if (!option.label.empty()) {
optionElement->setAttribute("label", option.label);
}
std::shared_ptr<XMLElement> valueElement(new XMLElement("value"));
valueElement->addNode(XMLTextNode::create(option.value));
optionElement->addNode(valueElement);
fieldElement->addNode(optionElement);
}
return fieldElement;
}
RippleState::pointer
RippleState::makeItem (
AccountID const& accountID,
std::shared_ptr<SLE const> sle)
{
// VFALCO Does this ever happen in practice?
if (! sle || sle->getType () != ltRIPPLE_STATE)
return {};
return std::make_shared<RippleState>(
std::move(sle), accountID);
}
bool ExpDotWriter::postVisit(const std::shared_ptr<TypedExp> &exp)
{
*m_os << "e_" << HostAddress(exp.get()) << " [shape=record,label=\"{";
*m_os << "opTypedExp\\n" << HostAddress(exp.get()) << " | ";
// Just display the C type for now
*m_os << exp->getType()->getCtype() << " | <p1>";
*m_os << " }\"];\n";
*m_os << "e_" << HostAddress(exp.get()) << ":p1->e_" << HostAddress(exp->getSubExp1().get())
<< ";\n";
return true;
}
std::shared_ptr<Format> TwicAccessControlCardService::readFormat(std::shared_ptr<Format> format, std::shared_ptr<Location> location, std::shared_ptr<AccessInfo> /*aiToUse*/)
{
bool ret = false;
std::shared_ptr<Format> formatret;
if (format)
{
formatret = Format::getByFormatType(format->getType());
formatret->unSerialize(format->serialize(), "");
}
else
{
formatret.reset(new FASCN200BitFormat());
}
std::shared_ptr<TwicLocation> pLocation;
if (location)
{
pLocation = std::dynamic_pointer_cast<TwicLocation>(location);
}
else
{
if (std::dynamic_pointer_cast<FASCN200BitFormat>(formatret))
{
pLocation.reset(new TwicLocation());
pLocation->dataObject = 0x5FC104;
pLocation->tag = 0x30;
}
}
if (pLocation)
{
size_t length = (formatret->getDataLength() + 7) / 8;
std::vector<unsigned char> formatBuf;
std::shared_ptr<StorageCardService> storage = std::dynamic_pointer_cast<StorageCardService>(getTwicChip()->getService(CST_STORAGE));
if (storage)
{
formatBuf = storage->readData(pLocation, std::shared_ptr<AccessInfo>(), length, CB_DEFAULT);
formatret->setLinearData(&formatBuf[0], formatBuf.size());
ret = true;
}
}
if (!ret)
{
formatret.reset();
}
return formatret;
}
void ConstraintElement::flattenAndFilter(const std::shared_ptr<OSSIA::StateElement>& element)
{
if (!element)
return;
switch (element->getType())
{
case OSSIA::StateElement::Type::MESSAGE :
{
std::shared_ptr<OSSIA::Message> messageToAppend = std::dynamic_pointer_cast<OSSIA::Message>(element);
// find message with the same address to replace it
bool found = false;
for (auto it = m_state_on_play->stateElements().begin();
it != m_state_on_play->stateElements().end();
it++)
{
std::shared_ptr<OSSIA::Message> messageToCheck = std::dynamic_pointer_cast<OSSIA::Message>(*it);
// replace if addresses are the same
if (messageToCheck->getAddress() == messageToAppend->getAddress())
{
*it = element;
found = true;
break;
}
}
// if not found append it
if (!found)
m_state_on_play->stateElements().push_back(element);
break;
}
case OSSIA::StateElement::Type::STATE :
{
std::shared_ptr<OSSIA::State> stateToFlatAndFilter = std::dynamic_pointer_cast<OSSIA::State>(element);
for (const auto& e : stateToFlatAndFilter->stateElements())
{
flattenAndFilter(e);
}
break;
}
default:
{
m_state_on_play->stateElements().push_back(element);
break;
}
}
}
std::string FormSerializer::serializePayload(std::shared_ptr<Form> form) const {
if (!form) {
return "";
}
std::shared_ptr<XMLElement> formElement(new XMLElement("x", "jabber:x:data"));
std::string type;
switch (form->getType()) {
case Form::FormType: type = "form"; break;
case Form::SubmitType: type = "submit"; break;
case Form::CancelType: type = "cancel"; break;
case Form::ResultType: type = "result"; break;
}
formElement->setAttribute("type", type);
if (!form->getTitle().empty()) {
multiLineify(form->getTitle(), "title", formElement);
}
if (!form->getInstructions().empty()) {
multiLineify(form->getInstructions(), "instructions", formElement);
}
for (const auto& page : form->getPages()) {
formElement->addNode(pageToXML(page));
}
for (const auto& field : form->getFields()) {
formElement->addNode(fieldToXML(field, true));
}
if (!form->getReportedFields().empty()) {
std::shared_ptr<XMLElement> reportedElement(new XMLElement("reported"));
for (const auto& field : form->getReportedFields()) {
reportedElement->addNode(fieldToXML(field, true));
}
formElement->addNode(reportedElement);
}
for (const auto& item : form->getItems()) {
std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));
for (const auto& field : item) {
itemElement->addNode(fieldToXML(field, false));
}
formElement->addNode(itemElement);
}
for (const auto& text : form->getTextElements()) {
formElement->addNode(textToXML(text));
}
for (const auto& field : fields_) {
formElement->addNode(fieldToXML(field,true));
}
return formElement->serialize();
}
