MarshallingService.cpp

Go to the documentation of this file.

/***************************************************************************
  tag: FMTC  Tue Mar 11 21:49:27 CET 2008  MarshallingService.cpp

                        MarshallingService.cpp -  description
                           -------------------
    begin                : Tue March 11 2008
    copyright            : (C) 2008 FMTC
    email                : peter.soetens@fmtc.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU General Public                   *
 *   License as published by the Free Software Foundation;                 *
 *   version 2 of the License.                                             *
 *                                                                         *
 *   As a special exception, you may use this file as part of a free       *
 *   software library without restriction.  Specifically, if other files   *
 *   instantiate templates or use macros or inline functions from this     *
 *   file, or you compile this file and link it with other files to        *
 *   produce an executable, this file does not by itself cause the         *
 *   resulting executable to be covered by the GNU General Public          *
 *   License.  This exception does not however invalidate any other        *
 *   reasons why the executable file might be covered by the GNU General   *
 *   Public License.                                                       *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU General Public             *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/



#include "MarshallingService.hpp"
#include "../TaskContext.hpp"
#include "../plugin/ServicePlugin.hpp"

#include "rtt-config.h"
#if !defined(ORO_EMBEDDED)
#include "../OperationCaller.hpp"
#endif
#include "PropertyLoader.hpp"

//ORO_SERVICE_PLUGIN( RTT::marsh::MarshallingService )
ORO_SERVICE_NAMED_PLUGIN(RTT::marsh::MarshallingService, "marshalling")

namespace RTT {
    using namespace detail;

    MarshallingService::shared_ptr MarshallingService::Create(TaskContext* parent){
        shared_ptr sp(new MarshallingService(parent));
        parent->provides()->addService( sp );
        return sp;
    }

    MarshallingService::MarshallingService(TaskContext* parent)
        : Service("marshalling", parent)
    {
        this->doc("Property marshalling interface. Use this service to read and write properties from/to a file.");
        this->addOperation("loadProperties",&MarshallingService::loadProperties, this)
                .doc("Read, and create if necessary, Properties from a file.")
                .arg("Filename","The file to read the (new) Properties from.");
        this->addOperation("storeProperties", &MarshallingService::storeProperties, this)
                .doc("Store properties in a file and overwrite any existing content.")
                .arg("Filename", "The file to write the Properties to.");

        this->addOperation("readProperties", &MarshallingService::readProperties, this)
                .doc("Read all Properties from a file. Returns false if one or more properties are missing or have a wrong type in that file.").arg("Filename", "The file to read the Properties from.");
        this->addOperation("readProperty", &MarshallingService::readProperty, this)
                .doc("Read a single Property from a file.").arg("Name", "The name of (or the path to) the property to read.").arg("Filename", "The file to read the Properties from.");

        this->addOperation("updateProperties", &MarshallingService::updateProperties, this)
                .doc("Read some Properties from a file. Updates only matching properties. Returns false upon type mismatch.")
                .arg("Filename", "The file to read the Properties from.");
        this->addOperation("updateFile", &MarshallingService::updateFile, this)
                .doc("Write some Properties to a file, ie, only the ones that are already present in the file.").arg("Filename", "The file to write the Properties to.");

        this->addOperation("writeProperties", &MarshallingService::writeProperties, this)
                .doc("Write all Properties to a file, but keep existing ones in that file.").arg("Filename", "The file to write the Properties to.");
        this->addOperation("writeProperty", &MarshallingService::writeProperty, this)
                .doc("Write a single Property to a file and keep existing ones in that file.").arg("Name", "The name of (or the path to) the property to write.").arg("Filename", "The file to write the Properties to.");
    }

    bool MarshallingService::loadProperties(const std::string& filename) const
    {
        PropertyLoader pl(mowner);
        return pl.load( filename );
    }

    bool MarshallingService::storeProperties(const std::string& filename) const
    {
        PropertyLoader pl(mowner);
        return pl.store( filename );
    }

    bool MarshallingService::readProperties(const std::string& filename) const
    {
        PropertyLoader pl(mowner);
        return pl.configure( filename, true); // all
    }
    bool MarshallingService::updateProperties(const std::string& filename) const
    {
        PropertyLoader pl(mowner);
        return pl.configure( filename, false); // not all
    }
    bool MarshallingService::writeProperties(const std::string& filename) const
    {
        PropertyLoader pl(mowner);
        return pl.save( filename, true);
    }
    bool MarshallingService::updateFile(const std::string& filename) const
    {
        PropertyLoader pl(mowner);
        return pl.save( filename, false);
    }

    bool MarshallingService::readProperty(const std::string& name, const std::string& filename) {
        PropertyLoader pl(mowner);
        return pl.configure(filename, name);
    }

    bool MarshallingService::writeProperty(const std::string& name, const std::string& filename) {
        PropertyLoader pl(mowner);
        return pl.save(filename, name);
    }


}