C++ XmlSerializer::serialize方法代码示例

/**
 * Tests that direct deseralization of a pointer to an abstract class leads to
 * a @c XMLSerializationMemoryAllocationException.
 */
void testMemoryAllocationException() {
    Abstract* a = new Specific();

    std::stringstream stream;

    XmlSerializer s;
    s.serialize("Abstract", a);
    s.write(stream);

    // Reset all variables to default values...
    delete a;
    a = 0;

    XmlDeserializer d;
    d.read(stream);
    try {
        d.deserialize("Abstract", a);
        delete a;
        test(false, "No exception raised on abstract class memory allocation try");
    }
    catch (XmlSerializationMemoryAllocationException&) {
    }
}

Processor* Processor::clone() const {
    try {
        std::stringstream stream;

        // first serialize
        XmlSerializer s;
        s.serialize("this", this);
        s.write(stream);

        // then deserialize again
        XmlDeserializer d;
        d.read(stream);
        Processor* proc = 0;
        d.deserialize("this", proc);

        proc->setDescriptions();
        return proc;
    }
    catch (std::exception& e) {
        LERROR("Failed to clone processor '" << getID() << "': " << e.what());
        return 0;
    }
}

/**
 * Tests serialization and deserialization of a @c std::set.
 */
void testSet() {
    const int SETELEMENTCOUNT = 5;

    std::set<int> set;
    for (int i = 0; i < SETELEMENTCOUNT; ++i)
        set.insert(i);

    std::stringstream stream;

    XmlSerializer s;
    s.serialize("set", set);
    s.write(stream);

    // Reset all variables to default values...
    set.clear();
    test(set.size() == 0, "set is not empty");

    XmlDeserializer d;
    d.read(stream);
    d.deserialize("set", set);

    test((int)set.size() == SETELEMENTCOUNT, "not all set items deserialized");

    bool deserializedValues[SETELEMENTCOUNT];
    for (int i = 0; i < SETELEMENTCOUNT; ++i)
        deserializedValues[i] = false;

    for (std::set<int>::iterator it = set.begin(); it != set.end(); ++it)
        if (*it >= 0 && *it < SETELEMENTCOUNT)
            deserializedValues[*it] = true;

    for (int i = 0; i < SETELEMENTCOUNT; ++i) {
        std::stringstream itemStream;
        itemStream << i;
        test(deserializedValues[i], "int item '" + itemStream.str() + "' not deserialized");
    }
}

/**
 * Tests serialization and deserialization of @c AbstractSerializable null pointers.
 */
void testBugAbstractSerializableNullPointerSerialization() {
    Abstract* a = 0;

    std::stringstream stream;

    AbstractFactory factory;

    XmlSerializer s;
    s.setUseAttributes(true);
    s.registerFactory(&factory);
    s.serialize("Abstract", a);
    s.write(stream);

    XmlDeserializer d;
    d.setUseAttributes(true);
    d.registerFactory(&factory);
    d.read(stream);
    try {
        d.deserialize("Abstract", a);
    }
    catch (XmlSerializationMemoryAllocationException&) {
        test(false, "bug occured, since memory allocation exception is thrown for 0 pointer");
    }
}

void VolumeHistogramIntensity::serialize(XmlSerializer& s) const  {
    s.serialize("histograms", histograms_, "channel");
}

void MeshListGeometry::serialize(XmlSerializer& s) const {
    s.serialize("meshes", meshes_);
}

void PlotSelectionEntry::serialize(XmlSerializer& s) const {
    s.serialize("selection", selection_);
    s.serialize("highlight", highlight_);
    s.serialize("renderLabel", renderLabel_);
    s.serialize("zoomTo", zoomTo_);
}

void PlotFunctionDiscret::DiscretizeValues::serialize(XmlSerializer& s) const {
    s.serialize("Interval",interval);
    s.serialize("Stepwidth",stepwidth);
    s.serialize("Columns",columns);
}

void PropertyKeyValue<tgt::Camera>::serialize(XmlSerializer& s) const {
    // base class props
    s.serialize("time", time_);
    s.serialize("smooth", smooth_);
    s.serialize("before", before_);
    s.serialize("after", after_);

    // camera
    s.serialize("projectionMode", (int)value_.getProjectionMode());

    s.serialize("position", value_.getPosition());
    s.serialize("focus", value_.getFocus());
    s.serialize("upVector", value_.getUpVector());

    s.serialize("frustLeft", value_.getFrustLeft());
    s.serialize("frustRight", value_.getFrustRight());
    s.serialize("frustBottom", value_.getFrustBottom());
    s.serialize("frustTop", value_.getFrustTop());
    s.serialize("frustNear", value_.getNearDist());
    s.serialize("frustFar", value_.getFarDist());
    s.serialize("fovy", value_.getFovy());

}

void PlotDataFitFunction::FittingValues::serialize(XmlSerializer& s) const {
    s.serialize("regressionType",regressionType);
    s.serialize("column",column);
    s.serialize("Dimension",dimension);
}

void TransFuncBanana::serialize(XmlSerializer& s) const {
    TransFuncPrimitive::serialize(s);
    for (int i = 0; i < 4; ++i)
        s.serialize("coords", coords_[i]);
}

void VolumeCollection::serialize(XmlSerializer& s) const {
    s.serialize("VolumeHandles", volumeHandles_, "VolumeHandle");
}

/**
 * Tests serialization and deserialization of polymorphic classes.
 */
void testPolymorphism() {
    Parent p;
    p.pdata = 1;
    Child c;
    c.pdata = 2;
    c.cdata = 3;
    Parent* pp = &p;
    Parent* pc = &c;

    Parent* child1 = new Child();
    child1->pdata = 4;
    dynamic_cast<Child*>(child1)->cdata = 5;
    Child* child2 = new Child();
    child2->pdata = 6;
    child2->cdata = 7;

    Factory factory;

    std::stringstream stream;

    try {
        XmlSerializer s;
        s.registerFactory(&factory);
        s.serialize("p", p);
        s.serialize("c", c);
        s.serialize("pp", pp);
        s.serialize("pc", pc);
        s.serialize("child1", child1);
        s.serialize("child2", child2);
        s.write(stream);
        delete child1;
        delete child2;
    }
    catch (...) {
        delete child1;
        delete child2;
        throw;
    }

    // Reset all variables to default values...
    p.pdata = 0;
    c.pdata = 0;
    c.cdata = 0;
    pp = 0;
    pc = 0;
    child1 = 0;
    child2 = 0;

    XmlDeserializer d;
    d.registerFactory(&factory);
    d.read(stream);
    d.deserialize("p", p);
    d.deserialize("c", c);
    d.deserialize("pp", pp);
    d.deserialize("pc", pc);
    d.deserialize("child1", child1);
    d.deserialize("child2", child2);

    test(p.pdata, 1, "p.pdata incorrect deserialized");
    test(c.pdata, 2, "c.pdata incorrect deserialized");
    test(c.cdata, 3, "c.cdata incorrect deserialized");
    test(pp != 0, "pp still null");
    test(pp == &p, "pp does not point to p");
    test(pc != 0, "pc still null");
    test(pc == &c, "pc does not point to c");
    test(child1 != 0, "child1 still null");
    test(child1->pdata, 4, "child1.pdata incorrect deserialized");
    test(dynamic_cast<Child*>(child1) != 0, "child1 deserialized without using correct polymorphic type");
    test(dynamic_cast<Child*>(child1)->cdata, 5, "child2.cdata incorrect deserialized");
    test(child2 != 0, "child2 still null");
    test(child2->pdata, 6, "child2.pdata incorrect deserialized");
    test(child2->cdata, 7, "child2.cdata incorrect deserialized");

    delete child1;
    delete child2;
}

 /**
  * @see Serializable::serialize
  */
 virtual void serialize(XmlSerializer& s) const {
     Parent::serialize(s);
     s.serialize("cdata", cdata);
 }

void PortConnection::serialize(XmlSerializer& s) const {
    s.serialize("Outport", outport_);
    s.serialize("Inport", inport_);
}