shells/utilities/PropertiesParser.h

Go to the documentation of this file.

// -*- C++ -*- 
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//                                   Fehmi Cirak
//                        California Institute of Technology
//                           (C) 2004 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Adapted from Guntram Berti's IO library included in the amroc framework
//
#ifndef PROPERTIESPARSER_H
#define PROPERTIESPARSER_H
#include <map>
#include <list>
#include <string>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cctype>


// declarations
namespace utilities {
    class Mutator;
    template <typename T>
    class TypedMutator;
    class PropertiesParser;
    std::istream& skip_comment(std::istream& in); 
}


// local function and functor
namespace {
    // case insensitive char comparisson
    bool ciCharLess(const char& c1, const char& c2) 
    {
        return std::tolower(static_cast<unsigned char>(c1))<
            std::tolower(static_cast<unsigned char>(c2));
    }
    
    
    // case insensitive string comparisson functor
    struct ciStringCompare { 
        bool operator()(const std::string& s1, const std::string& s2) const 
            {
                return std::lexicographical_compare(s1.begin(), s1.end(),
                                                    s2.begin(), s2.end(), ciCharLess);
            }
    };
}



// abstract class
class utilities::Mutator {
public:
    virtual void read (std::istream& in)  = 0;
    virtual void print(std::ostream& out, const std::string& name) const = 0;
    virtual ~Mutator() {}
};


namespace utilities {

template<typename T>
class TypedMutator : public Mutator {
public:
    TypedMutator(T& v) : _v(v) {}
    ~TypedMutator() {}
    void read(std::istream& in) { in >> _v;}
    void print(std::ostream& out, const std::string& prefix) const 
        {
            out << prefix << _v;
        }
    
private:
    T&    _v;
};

} // namespace utilities


class utilities::PropertiesParser {
public:
    
    PropertiesParser() 
        {
            _table = new _TableType;
            _unrecognized = new _UnrecognizedList;
        }    
    
    ~PropertiesParser();
    
    void addVariable(const std::string& name, Mutator* m);
    
    void addVariable(const char*  name, Mutator* m);

    void readVariable(std::istream& is);

    void readValues(std::istream& is);
    
    void printValues(std::ostream& out, const std::string& pre, 
                     const std::string& sep) const;
    
    bool hasUnrecognized() const;
    
    void printUnrecognized(std::ostream& out) const;

    template<class T>
    void registerPropertiesVar(const std::string& name, T& t)
        { 
            utilities::TypedMutator<T>* p = new utilities::TypedMutator<T>(t);
            addVariable(name, p);
        }
        
private:
    typedef std::map<std::string, Mutator*, ciStringCompare> _TableType;
    typedef std::list<std::string>                           _UnrecognizedList;
    
    _TableType         *_table;
    _UnrecognizedList  *_unrecognized;
    
};

#endif

---