xml_example.cpp

Go to the documentation of this file.

#include <iostream>

#include <ros/ros.h>

#include <ros/package.h>

#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>
#include <boost/shared_ptr.hpp>

using namespace std;
using boost::property_tree::ptree;

class Calibration
{
    public:
        
        double max;
        double min;
};

class Sensor
{
    public:
        
        typedef boost::shared_ptr<Sensor> Ptr;
        
        string name;
        string type;
        Calibration calibration;

};

class Pedal
{
    public:
        
        typedef boost::shared_ptr<Pedal> Ptr;
        
        vector<Sensor::Ptr> sensors;
        string name;
};

ostream& operator<<(ostream& o, Sensor::Ptr& sensor)
{
    o<<"Sensor: "<<sensor->name<<" ";
    o<<"Type: "<<sensor->type<<" ";
    o<<"Min: "<<sensor->calibration.min<<" ";
    o<<"Max: "<<sensor->calibration.max<<" ";
    return o;
}

const ptree& empty_ptree()
{
    static ptree t;
    return t;
}

// Read data from XML file
vector<Pedal::Ptr> readPedalCalibration(string file_name,string& user_name, ptree& pt)
{
    vector<Pedal::Ptr> pedals;
    
    // Try to read the file, if can't files doesn't exist!
    try
    {
        read_xml(file_name, pt, boost::property_tree::xml_parser::trim_whitespace);
    }catch(boost::property_tree::xml_parser::xml_parser_error& error)
    {
//         cout<<"Cannot read XML file:\n\t"<<error.what()<<endl;
        cout << "Cannot read XML file" << endl;
        return pedals;
    }
    
    user_name = pt.get<std::string>("calibration.<xmlattr>.user_name");
    
    cout<<"Calibration for user: "<<user_name<<endl;
    
    BOOST_FOREACH(ptree::value_type const& v, pt.get_child("calibration"))
    {    
        if(v.first == "pedal")
        {
            Pedal::Ptr pedal(new Pedal);
            
            pedal->name = v.second.get<string>("name");
            
            for(auto it=v.second.begin();it!=v.second.end();it++)
            {
                if(it->first == "sensor")
                {
                    Sensor::Ptr sensor(new Sensor);
                    
                    sensor->name = it->second.get<string>("name");
                    sensor->type = it->second.get<string>("type");
                    sensor->calibration.max = it->second.get<double>("max");
                    sensor->calibration.min = it->second.get<double>("min");
                    
                    pedal->sensors.push_back(sensor);
                }
            }
            
            pedals.push_back(pedal);
        }
    }
    
    return pedals;
}

// Overwrite an existing XML file
void writeExistingCalibrationFile(string file_name, ptree& pt,const vector<Pedal::Ptr>& pedals)
{
    boost::property_tree::ptree root_node;

    for(auto it = pt.begin(); it != pt.end();it++)
    {
//         cout<<it->first<<endl; // debug
        if(it->first == "calibration")
        {
            for(auto cc_it = it->second.begin();cc_it!=it->second.end();cc_it++)//cc_it - calibration child iterator
            {
//                 cout<<"  "<<cc_it->first<<endl; // debug
                if(cc_it->first=="pedal")
                {
                    //get the pedal name
                    string pedal_name = cc_it->second.get<string>("name");
                    
                    Pedal::Ptr pedal;
                    find_if(pedals.begin(),pedals.end(),[&](const Pedal::Ptr& p){if(p->name == pedal_name){pedal = p; return true;}});
                                        
                    for(auto pc_it = cc_it->second.begin(); pc_it!=cc_it->second.end();pc_it++)//pc_it - pedal child iterator
                    {
//                         cout<<"    "<<pc_it->first<<endl; // debug
                        if(pc_it->first == "sensor")
                        {
                            string sensor_name = pc_it->second.get<string>("name");
                            
                            Sensor::Ptr sensor;
                            find_if(pedal->sensors.begin(),pedal->sensors.end(),[&](const Sensor::Ptr& s){if(s->name == sensor_name){sensor = s; return true;}});
                            
                            for(auto sc_it = pc_it->second.begin(); sc_it!=pc_it->second.end();sc_it++)
                            {
                                if(sc_it->first=="type")
                                    sc_it->second.put_value(sensor->type);
                                
                                if(sc_it->first=="min")
                                    sc_it->second.put_value(sensor->calibration.min);
                                
                                if(sc_it->first=="max")
                                    sc_it->second.put_value(sensor->calibration.max);
                            }
                        }
                    }
                }
            }
        }
    }
    
    boost::property_tree::xml_writer_settings<char> settings('\t', 1);
    
    // Write the property tree to the XML file.
    write_xml(file_name, pt,std::locale(), settings);
}

// Writing XML file for the first time
void writeCalibrationFile(string file_name,const vector<Pedal::Ptr>& pedals)
{
    ptree pt;
    
    boost::property_tree::ptree root_node;
   
    for(uint i=0;i<pedals.size();i++)
    {
        boost::property_tree::ptree pedal;
        
        for(uint h=0;h<pedals[i]->sensors.size();h++)
        {
            boost::property_tree::ptree sensor;

            sensor.add("name", pedals[i]->sensors[h]->name);
            sensor.add("type", pedals[i]->sensors[h]->type);
            sensor.add("min", pedals[i]->sensors[h]->calibration.min);
            sensor.add("max", pedals[i]->sensors[h]->calibration.max);
            
            pedal.add_child("sensor",sensor);
        }
        
        
        root_node.add_child("pedal",pedal);
    }
    
    pt.add_child("calibration",root_node);

    boost::property_tree::xml_writer_settings<char> settings('\t', 1);
    
    // Write the property tree to the XML file.
    write_xml(file_name, pt,std::locale(), settings);
}

int main()
{
    // File name and username
    string file_name = ros::package::getPath("pedal_monitor") + "/src/calibration_test.xml";
    string user;
    
    ptree pt;
    
    // Read existing file.xml
    vector<Pedal::Ptr> pedals = readPedalCalibration(file_name,user,pt);
    
    // Get user and number of pedals (EXAMPLE)
    cout<<"The calibration file for "<<user<<" has: "<<pedals.size()<<" pedals."<<endl;
    
    // Get data from pedal 1 and sensor 1 (EXAMPLE)
    cout<<"Pedal 1 max: "<<pedals[0]->sensors[0]->calibration.max<<" min: "<<pedals[0]->sensors[0]->calibration.min<<endl;
    
    // Switching values of pedal 1 and sensor 1 (EXAMPLE)
    pedals[0]->sensors[0]->calibration.max = 23434;
    
    // Read all data of pedal sensors
    for(auto it=pedals.begin();it!=pedals.end();it++)
    {
        cout<<"Pedal: "<<(*it)->name<<endl;
        
        for(auto it_sensors= (*it)->sensors.begin(); it_sensors != (*it)->sensors.end(); it_sensors++)
             cout<<"\t"<<(*it_sensors)<<endl;
    }
    
    // Overwrite calibration file
    writeExistingCalibrationFile(ros::package::getPath("pedal_monitor") + "/src/test.xml",pt,pedals);
    
    return 0;
}