void PropertyOwner::deserialize(Deserializer& d) {
    // This is for finding renamed composites, and moving old properties to new composites.
    NodeVersionConverter tvc(this, &PropertyOwner::findPropsForComposites);
    d.convertVersion(&tvc);

    
    std::vector<std::string> ownedIdentifiers;
    d.deserialize("OwnedPropertyIdentifiers", ownedIdentifiers, "PropertyIdentifier");

    auto des = util::IdentifiedDeserializer<std::string, Property*>("Properties", "Property")
                   .setGetId([](Property* const& p) { return p->getIdentifier(); })
                   .setMakeNew([]() { return nullptr; })
                   .setNewFilter([&](const std::string& id, size_t ind) {
                       return util::contains(ownedIdentifiers, id);
                   })
                   .onNew([&](Property*& p) { addProperty(p, true); })
                   .onRemove([&](const std::string& id) {
                       if (util::contains_if(ownedProperties_, [&](std::unique_ptr<Property>& op) {
                               return op->getIdentifier() == id;
                           })) {
                           delete removeProperty(id);
                       }
                   });

    des(d, properties_);
}
Example #2
0
void LightingRaycaster::deserialize(Deserializer& d) {
    NodeVersionConverter tvc([](TxElement* node) {
        TxElement* p = util::xmlGetElement(
            node, "Properties/Property&type=OptionPropertyString&identifier=shadingMode");
        if (p) p->SetAttribute("type", "OptionPropertyInt");
        return true;
    });
    d.convertVersion(&tvc);
    Processor::deserialize(d);
}
Example #3
0
void util::renameProperty(Deserializer& d, std::initializer_list<std::pair<const Property*, std::string>> rules) {
    NodeVersionConverter vc([&rules](TxElement* node) {
        for (auto rule : rules) {
            TxElement* p = util::xmlGetElement(node, "Properties/Property&type=" +
                                               rule.first->getClassIdentifier() +
                                               "&identifier=" + rule.second);
            if (p) p->SetAttribute("identifier", rule.first->getIdentifier());
        }
        return true;
    });
    d.convertVersion(&vc);
}
Example #4
0
void util::renamePort(Deserializer& d, std::initializer_list<std::pair<const Port*, std::string>> rules) {
    NodeVersionConverter vc([&rules](TxElement* node) {
        for (auto rule : rules) {
            TxElement* elem = nullptr;
            if (auto p = dynamic_cast<const Outport*>(rule.first)) {
                elem = util::xmlGetElement(node, "OutPorts/OutPort&type=" + p->getClassIdentifier() +
                                           "&identifier=" + rule.second);
            } else if (auto p = dynamic_cast<const Inport*>(rule.first)) {
                elem = util::xmlGetElement(node, "InPorts/InPort&type=" + p->getClassIdentifier() +
                                           "&identifier=" + rule.second);
            }
            if (elem) elem->SetAttribute("identifier", rule.first->getIdentifier());
        }
        return true;
    });
    d.convertVersion(&vc);
}
void MultichannelRaycaster::deserialize(Deserializer& d) {
    util::renamePort(d, {{&entryPort_, "entry-points"}, {&exitPort_, "exit-points"}});

    NodeVersionConverter vc([](TxElement* node) {
        if (TxElement* p1 = xml::getElement(
                node, "InPorts/InPort&type=org.inviwo.ImageMultiInport&identifier=exit-points")) {
            p1->SetAttribute("identifier", "exit");
        }
        if (TxElement* p2 = xml::getElement(
                node, "InPorts/InPort&type=org.inviwo.ImageMultiInport&identifier=entry-points")) {
            p2->SetAttribute("identifier", "entry");
        }
        return true;
    });

    d.convertVersion(&vc);
    Processor::deserialize(d);
}