property_string.h

#pragma once
 
#include <string>
 
namespace cgv {
namespace gui {
 
class property_string {
private:
    std::string v_;
    std::string key_value_delimiter_;
    std::string property_delimiter_;
    
    template<typename T>
    std::string convert_to_string(T value) const {
        return std::to_string(value);
    }
 
    std::string convert_to_string(bool value) const {
        return value ? "true" : "false";
    }
 
    std::string convert_to_string(const std::string& value) const {
        return value;
    }
 
    void add_void(const std::string& key, const std::string& value) {
        if(key.empty() && value.empty())
            return;
 
        if(!v_.empty())
            v_ += property_delimiter_;
 
        if(!key.empty() && !value.empty())
            v_ += key + key_value_delimiter_ + value;
        else
            v_ += key + value;
    }
 
public:
    property_string(const std::string& key_value_delimiter = "=", const std::string& property_delimiter = ";") :
        key_value_delimiter_(key_value_delimiter),
        property_delimiter_(property_delimiter) {}
 
    bool empty() const {
        return v_.empty();
    }
 
    void clear() {
        v_.clear();
    }
 
    template<typename T>
    void add(const std::string& key, T value) {
        add_void(key, convert_to_string(value));
    }
 
    template<typename T>
    void add_bracketed(const std::string& key, const T value, char bracket = '\'') {
        std::string str = bracket + convert_to_string(value) + bracket;
        add_void(key, str);
    }
 
    template<typename T>
    void add_bracketed(const std::string& key, const T value, char opening_bracket, char closing_bracket) {
        std::string str = opening_bracket + convert_to_string(value) + closing_bracket;
        add_void(key, str);
    }
 
    operator std::string() const {
        return v_;
    }
};
 
}
}