resource.h

Go to the documentation of this file.

// $Id$
// Author: John Wu <John.Wu at ACM.org>
// Lawrence Berkeley National Laboratory
// Copyright (c) 2000-2016 the Regents of the University of California
#ifndef IBIS_RESOURCE_H
#define IBIS_RESOURCE_H
#include "util.h"       // ibis::util::strnewdup(), std::less<const char*>
#include <fstream>      // std::ofstream
#include <map>          // std::map

class FASTBIT_CXX_DLLSPEC ibis::resource {
public:
    typedef std::map< const char*, resource*, ibis::lessi > gList;
    typedef std::map< const char*, char*, ibis::lessi > vList;

    ~resource() {clear();};
    resource() : prefix(0), context(0) {};
    explicit resource(const char *fn) : prefix(0), context(0) {(void)read(fn);}
    resource(const resource* ctx, const char* pfx) :
        prefix(ibis::util::strnewdup(pfx)), context(ctx) {}
    resource(const resource& rhs) :
        groups(rhs.groups), values(rhs.values),
        prefix(ibis::util::strnewdup(rhs.prefix)), context(rhs.context) {}
    resource& operator=(const resource& rhs);

    const char* operator[](const char *name) const;
    double getNumber(const char* name) const;
    bool isTrue(const char *name) const;

    int  read(const char* fn=0);
    void write(const char* fn=0) const;
    void add(const char *name, const char *value);

    bool empty() const {return (values.empty() && groups.empty());}
    gList::const_iterator gBegin() const {return groups.begin();}
    gList::const_iterator gEnd() const {return groups.end();}
    vList::const_iterator vBegin() const {return values.begin();}
    vList::const_iterator vEnd() const {return values.end();}

    inline const resource* getGroup(const char* name) const;
    inline const char* getValue(const char *name) const;
    inline std::string getPrefix() const;

    static void clear(vList &vl);
    static void parseNameValuePairs(const char* in, vList& lst);
    static bool isStringTrue(const char *val);

private:
    static const char* delimiters;
    gList groups;       
    vList values;       
    const char *prefix;
    const resource* context;

    void clear(); // clear the memory occupied by the strings
    void write(std::ostream& out, const char* ctx=0) const;
};

// only search the top level level
inline const ibis::resource* ibis::resource::getGroup(const char* name) const {
    const ibis::resource* group = 0;
    if (name==0) return group;
    if (*name==static_cast<char>(0)) return group;

    gList::const_iterator it = groups.find(name);
    if (it != groups.end())
        group = (*it).second;
    return group;
} // ibis::resource::getGroup

// only search the top level
inline const char* ibis::resource::getValue(const char* name) const {
    const char* value = 0;
    if (name==0) return value;
    if (*name==static_cast<char>(0)) return value;

    vList::const_iterator it = values.find(name);
    if (it != values.end())
        value = (*it).second;
    return value;
} // ibis::resource::getValue

// get the full prefix of the resource
inline std::string ibis::resource::getPrefix() const {
    std::string ret;
    if (context != 0)
        ret = context->getPrefix();
    if (prefix != 0) {
        if (ret.empty()) {
            ret = prefix;
        }
        else {
            ret += '.';
            ret += prefix;
        }
    }
    return ret;
} // ibis::resource::getPrefix

inline bool ibis::resource::isStringTrue(const char *val) {
    return(val != 0 && *val != 0 &&
           ((*val == '1') || (*val == 't') || (*val == 'y') ||
            (*val == 'T') || (*val == 'Y') || (stricmp(val, "on") == 0)));
} // ibis::resource::isStringTrue
#endif // IBIS_RESOURCE_H