Properties.cpp

Go to the documentation of this file.

#include <face_contour_detector/Properties.h>

# include <map>
# include <sstream>
# include <iostream>
# include <fstream>
# include <string>
# include <stdio.h>
# include <stdlib.h>

namespace face_contour_detector {

        Properties::Properties() {}

        Properties::Properties(const Properties& other) : m_m(other.m_m) {}

        void Properties::LoadFromTxtFile(const std::string& file) {
                std::ifstream fstream;
                fstream.open(file.c_str());
                if (!fstream.is_open()) {
                        std::stringstream s;
                        s<<file<<" could not be opened"<<std::endl;
                        throw s.str();
                }
                LoadFromStream(fstream);
                fstream.close();
        }

        void Properties::LoadFromStream(std::istream& s) {
                std::string line;
                int lnumber = 0;
                while (s.good()) {
                        getline(s, line);
                        std::stringstream name;
                        std::stringstream value;
                        bool correct = true;
                        bool eq = false;
                        bool spaced = false;
                        bool escaped = true;
                        for (std::string::iterator it = line.begin(); it < line.end(); it++) {
                                //name_
                                if (!eq && ((*it) == ' ' || (*it) == '\t')) {
                                        spaced = true;
                                //name_=
                                } else if (!eq && (*it) == ':') {
                                        spaced = false;
                                        eq = true;
                                //name_asdf
                                } else if (!eq && spaced) {
                                        correct = false;
                                        break;
                                //na
                                } else if (!eq && !spaced){
                                        name<<(*it);
                                //name_=_
                                } else if (eq && !spaced && ((*it) == ' ' || (*it) == '\t')) {
                                        spaced = true;
                                //name_=_val
                                } else if (eq && spaced) {
                                        if (!escaped && (*it) == '\\') {
                                                escaped = true;
                                        } else if (escaped && (*it) == 'n') {
                                                value<<"\n";
                                                escaped = false;
                                        } else {
                                                value<<(*it);
                                                escaped = false;
                                        }
                                }
                        }
                        if (correct && eq && !escaped) {
                                m_m[name.str()] = value.str();
                        } else {
                                if (line.compare("") != 0) {
                                        if (!eq) {
                                                std::cerr<<"found no ':' in line "<<lnumber<<", ignored it"<<std::endl;
                                        } else if (escaped) {
                                                std::cerr<<"there was a '\\' at the end of the line "<<lnumber<<", ignored the line"<<std::endl;
                                        } else if (!correct) {
                                                std::cerr<<"there was an error reading line "<<lnumber<<", ignored it (maybe no spaces between the '=' ?)"<<std::endl;
                                        }
                                }

                        }
                        lnumber++;
                }
        }

        void Properties::LoadFromStreamNoOverwrite(std::istream& s, std::stringstream& notReadable) {
                std::string line;
                int lnumber = 0;
                while (s.good()) {
                        getline(s, line);
                        std::stringstream name;
                        std::stringstream value;
                        bool correct = true;
                        bool eq = false;
                        bool spaced = false;
                        bool escaped = true;
                        for (std::string::iterator it = line.begin(); it < line.end(); it++) {
                                //name_
                                if (!eq && ((*it) == ' ' || (*it) == '\t')) {
                                        spaced = true;
                                //name_=
                                } else if (!eq && (*it) == ':') {
                                        spaced = false;
                                        eq = true;
                                //name_asdf
                                } else if (!eq && spaced) {
                                        correct = false;
                                        break;
                                //na
                                } else if (!eq && !spaced){
                                        name<<(*it);
                                //name_=_
                                } else if (eq && !spaced && ((*it) == ' ' || (*it) == '\t')) {
                                        spaced = true;
                                //name_=_val
                                } else if (eq && spaced) {
                                        if (!escaped && (*it) == '\\') {
                                                escaped = true;
                                        } else if (escaped && (*it) == 'n') {
                                                value<<"\n";
                                                escaped = false;
                                        } else {
                                                value<<(*it);
                                                escaped = false;
                                        }
                                }
                        }
                        if (correct && eq && !Exists(name.str())) {
                                m_m[name.str()] = value.str();
                        } else if (!Exists(name.str()) && line.compare("") != 0) {
                                notReadable<<line<<std::endl;
                                if (!eq) {
                                        std::cerr<<"found no ':' in line "<<lnumber<<", ignored it"<<std::endl;
                                } else if (escaped) {
                                        std::cerr<<"there was a '\\' at the end of the line "<<lnumber<<", ignored the line"<<std::endl;
                                } else if (!correct) {
                                        std::cerr<<"there was an error reading line "<<lnumber<<", ignored it (maybe no spaces between the '=' ?)"<<std::endl;
                                }
                        }
                        lnumber++;
                }
        }

        void Properties::SaveToTxtFile(const std::string& file) {
                std::ifstream ifstream;
                ifstream.open(file.c_str());

                std::string notReadable;

                if (ifstream.is_open()) {

                        //Read file before overwriting it
                        std::stringstream notReadableStream;

                        LoadFromStreamNoOverwrite(ifstream, notReadableStream);

                        ifstream.close();

                        //Save unknown stuff for saving later
                        notReadable = notReadableStream.str();
                }

                //Delete file content
                std::ofstream ofstream;
                ofstream.open(file.c_str(), std::ios_base::out | std::ios_base::trunc);
                if (!ofstream.is_open()) {
                        std::stringstream s;
                        s<<file<<" could not be opened for writing"<<std::endl;
                        throw s.str();
                }

                //Save it
                AppendSaveToStream(ofstream);

                //Add prev not readable
                ofstream<<notReadable;
                ofstream.close();
        }

        void Properties::AppendSaveToStream(std::ostream& s) {
                for (std::map<std::string, std::string>::iterator it=m_m.begin() ; it != m_m.end(); it++ ) {
                        //name
                        std::string name = (*it).first;
                        std::string value = (*it).second;
                        s << M_Replace(M_Replace(name, "\\", "\\\\"), "\n", "\\n")<<
                        // =
                                ": "<<
                        //value
                                M_Replace(M_Replace(value, "\\", "\\\\"), "\n", "\\n")<<
                                std::endl;
                }
        }

        bool Properties::Exists(const std::string& key) const { return m_m.find(key) != m_m.end(); }

        std::string Properties::ReadString(const std::string& key) const { return std::string(m_m.find(key)->second); }

        float Properties::ReadFloat(const std::string& key) const { return atof(m_m.find(key)->second.c_str()); }

        double Properties::ReadDouble(const std::string& key) const { return atof(m_m.find(key)->second.c_str()); }

        int Properties::ReadInt(const std::string& key) const { return atoi(m_m.find(key)->second.c_str()); }

        bool Properties::ReadBool(const std::string& key) const {
                if (m_m.find(key)->second.compare("true")  == 0)
                        return true;
                if (m_m.find(key)->second.compare("1") == 0)
                        return true;
                return false;
        }

        void Properties::Set(const std::string& key, const std::string& value) {
                m_m[key] = std::string(value);
        }

        void Properties::Set(const std::string& key, const char* value) {
                m_m[key] = std::string(value);
        }

        void Properties::Set(const std::string& key, int value) {
                std::stringstream s;
                s<<value;
                m_m[key] = s.str();
        }

        void Properties::Set(const std::string& key, float value) {
                std::stringstream s;
                s<<value;
                m_m[key] = s.str();
        }

        void Properties::Set(const std::string& key, double value) {
                std::stringstream s;
                s<<value;
                m_m[key] = s.str();
        }

        void Properties::Set(const std::string& key, bool value) {
                m_m[key] = value?"true":"false";
        }

        void Properties::Clear() { m_m.clear(); }

}