Properties.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2021 Univ. Grenoble Alpes, CNRS, Grenoble INP, TIMC, 38000 Grenoble, France
 *
 * Visit http://camitk.imag.fr for more information
 *
 * This file is part of CamiTK.
 *
 * CamiTK is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * CamiTK 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 version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with CamiTK.  If not, see <http://www.gnu.org/licenses/>.
 *
 * $CAMITK_LICENCE_END$
 ****************************************************************************/
 
#ifndef PROPERTIES_H
#define PROPERTIES_H
 
#include "PhysicalModelIO.h"
#include <string>
#include <sstream>
#include <map>
#include <cstdlib>
 
// XSD include
#include <xsd/cxx/tree/containers-wildcard.hxx>
 
class PhysicalModel;
class Properties {
 
public:
    Properties(const std::string n = "");
 
    Properties(PhysicalModel*, const std::string n = "");
 
    virtual ~Properties() = default;
 
    std::string getName() const;
 
    void setName(std::string);
 
    void setPhysicalModel(PhysicalModel*);
 
    PhysicalModel* getPhysicalModel() const;
 
    void xmlToFields(xsd::cxx::tree::attribute_set<char> attrs);
 
    unsigned int numberOfFields() const;
 
    bool isAField(std::string attName) const;
 
    std::string getField(unsigned int) const;
 
    double getDouble(std::string attName);
 
    int getInt(std::string attName) const;
 
    bool getBool(std::string attName) const;
 
    std::string getString(std::string attName) const;
 
    void get(std::string attName, std::string& attVal) const;
 
    void set(std::string attName, double val);
 
    void set(std::string attName, int val);
 
    void set(std::string attName, bool val);
 
    void set(std::string attName, std::string val);
 
protected :
    std::map<std::string, std::string> fields;
 
private:
    std::string name;
 
    PhysicalModel* myPM;
 
};
 
inline bool Properties::isAField(std::string attName) const {
    auto it = fields.find(attName);
    return (it != fields.end());
}
 
inline double Properties::getDouble(std::string attName) {
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        return atof(it->second.c_str());
    }
    else {
        return 0.0;
    }
}
 
inline int Properties::getInt(std::string attName) const {
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        return std::atoi(it->second.c_str());
    }
    else {
        return 0;
    }
}
 
inline bool Properties::getBool(std::string attName) const {
    auto it = fields.find(attName);
 
    if (it == fields.end() || it->second == "false" || it->second == "0") {
        return false;
    }
    else {
        return true;
    }
}
 
inline std::string Properties::getString(std::string attName) const {
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        return it->second;
    }
    else {
        return "";
    }
}
 
inline void Properties::get(std::string attName, std::string& attVal) const {
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        attVal = it->second;
    }
    else {
        attVal = "";
    }
}
 
inline void Properties::set(std::string attName, double val) {
    std::ostringstream oss;
    oss << val;
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        it->second = oss.str();
    }
    else {
        fields.insert(std::pair<std::string, std::string>(attName, oss.str()));
    }
}
 
inline void Properties::set(std::string attName, int val) {
    std::ostringstream oss;
    oss << val;
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        it->second = oss.str() ;
    }
    else {
        fields.insert(std::pair<std::string, std::string>(attName, oss.str()));
    }
}
 
inline void Properties::set(std::string attName, bool val) {
    std::ostringstream oss;
    oss << val;
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        it->second = oss.str() ;
    }
    else {
        fields.insert(std::pair<std::string, std::string>(attName, oss.str()));
    }
}
 
inline void Properties::set(std::string attName, std::string val) {
    auto it = fields.find(attName);
 
    if (it != fields.end()) {
        it->second = val ;
    }
    else {
        fields.insert(std::pair<std::string, std::string>(attName, val));
    }
}
 
inline std::string Properties::getName() const {
    return name;
}
 
inline void Properties::setName(std::string n) {
    name = std::string(n);
}
 
inline void Properties::setPhysicalModel(PhysicalModel* pm) {
    myPM = pm;
}
 
inline PhysicalModel* Properties::getPhysicalModel() const {
    return myPM;
}
 
#endif //PROPERTIES_H