ConfigMap.H

Go to the documentation of this file.

#ifndef CONFIGMAP_H
#define CONFIGMAP_H

#include <G3D/G3DAll.h>
#include <sstream>
#include "G3DOperators.H"

namespace VRG3D {


#if (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500) || \
    (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)))
#define QUOTED_STRING const char *
#else
#define QUOTED_STRING char *
#endif







typedef ReferenceCountedPointer<class ConfigMap> ConfigMapRef;
class ConfigMap : public ReferenceCountedObject
{
public:
  ConfigMap(Log *log) {
    _log = log;
  }

  ConfigMap(const std::string &filename, Log *log) {
    _log = log;
    readFile(filename);
  }

  ConfigMap(int argc, char **argv, Log *log, bool exitOnUnrecognizedArgument);

  virtual ~ConfigMap() {}

  void printArgumentHelpAndExit(const std::string &programName);
  bool readFile(const std::string &filename);

  template <class T>
  bool retypeString(const std::string &str, T &val) {
    std::istringstream is(str.c_str());
    is >> val;
    if (!is) {
      return false;
    }
    else {
      return true;
    }
  }

  template <class VALTYPE>
  VALTYPE get(std::string keyString, const VALTYPE &defaultVal) {
    if (containsKey(keyString)) {
      std::string valString = getValue(keyString);
      VALTYPE val;
      bool ok = retypeString(valString, val);
      if (ok) {
        return val;
      }
      else {
        if (_log) {
          _log->printf("ConfigMap Error: cannot remap '%s'", valString.c_str());
        }
        else {
          printf("ConfigMap Error: cannot remap '%s'", valString.c_str());
        }
        return defaultVal;
      }
    }
    else {
      if (_log) {
        _log->printf("ConfigMap Warning: no mapping for '%s'.\n", keyString.c_str());
      }
      else {
        printf("ConfigMap Warning: no mapping for '%s'.\n", keyString.c_str());
      }
      return defaultVal;
    }
  }
  
  std::string get(QUOTED_STRING keyString, QUOTED_STRING defaultVal) {
    if (containsKey(keyString))
      return replaceEnvVars(getValue(keyString));
    else {
      if (_log) {
        _log->printf("ConfigMap Warning: no mapping for '%s'.\n", keyString);
      }
      else {
        printf("ConfigMap Warning: no mapping for '%s'.\n", keyString);
      }
      return replaceEnvVars(defaultVal);
    }
  }

  std::string get(QUOTED_STRING keyString, std::string defaultVal) {
    if (containsKey(keyString))
      return replaceEnvVars(getValue(keyString));
    else {
      if (_log) {
        _log->printf("ConfigMap Warning: no mapping for '%s'.\n", keyString);
      }
      else {
        printf("ConfigMap Warning: no mapping for '%s'.\n", keyString);
      }
      return replaceEnvVars(defaultVal);
    }
  }

  std::string get(std::string keyString, QUOTED_STRING defaultVal) {
    if (containsKey(keyString))
      return replaceEnvVars(getValue(keyString));
    else {
      if (_log) {
        _log->printf("ConfigMap Warning: no mapping for '%s'.\n", keyString.c_str());
      }
      else {
        printf("ConfigMap Warning: no mapping for '%s'.\n", keyString.c_str());
      }
      return replaceEnvVars(defaultVal);
    }
  }

  std::string get(std::string keyString, std::string defaultVal) {
    if (containsKey(keyString))
      return replaceEnvVars(getValue(keyString));
    else {
      if (_log) {
        _log->printf("ConfigMap Warning: no mapping for '%s'.\n", keyString.c_str());
      }
      else {
        printf("ConfigMap Warning: no mapping for '%s'.\n", keyString.c_str());
      }
      return replaceEnvVars(defaultVal);
    }
  }

  bool         containsKey(const std::string &keyString);
  std::string  getValue(const std::string &keyString);
  void         set(const std::string &key, const std::string &value);
  void         debugPrint();

private:
  Table<std::string, std::string> _map;
  Log* _log;
};


} // end namespace


#endif

---