b2dictionary.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2dictionary.H --
//
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012,2017
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef __B2DICTIONARY_H__
#define __B2DICTIONARY_H__
 
#include <complex>
#include <ostream>
#include <string>
#include <vector>
 
#include "utils/b2csda.H"
#include "utils/b2exception.H"
#include "utils/b2object.H"
 
namespace b2000 {
 
class Dictionary : public Object {
public:
    ~Dictionary() override {}
 
    virtual bool has_key(const std::string& key) const = 0;
 
    virtual bool get_bool(const std::string& key) const = 0;
 
    virtual bool get_bool(const std::string& key, bool default_) const {
        if (!has_key(key)) { return default_; }
        return get_bool(key);
    }
 
    virtual int get_int(const std::string& key) const = 0;
 
    virtual int get_int(const std::string& key, int default_) const {
        if (!has_key(key)) { return default_; }
        return get_int(key);
    }
 
    virtual double get_double(const std::string& key) const = 0;
 
    virtual double get_double(const std::string& key, double default_) const {
        if (!has_key(key)) { return default_; }
        return get_double(key);
    }
 
    virtual b2000::csda<double> get_csda_double(const std::string& key) const = 0;
 
    virtual b2000::csda<double> get_csda_double(
          const std::string& key, b2000::csda<double> default_) const {
        if (!has_key(key)) { return default_; }
        return get_csda_double(key);
    }
 
    virtual std::complex<double> get_complex_double(const std::string& key) const = 0;
 
    virtual std::complex<double> get_complex_double(
          const std::string& key, std::complex<double> default_) const {
        if (!has_key(key)) { return default_; }
        return get_complex_double(key);
    }
 
    virtual std::string get_string(const std::string& key) const = 0;
 
    virtual std::string get_string(const std::string& key, const std::string& default_) const {
        try {
            return get_string(key);
        } catch (std::exception&) { return default_; }
        return "";
    }
 
    template <typename T>
    inline T get(const std::string& key) const {
        UnimplementedError() << THROW;
        return T();
    }
 
    template <typename T>
    inline T get(const std::string& key, const T& default_) const {
        UnimplementedError() << THROW;
        return T();
    }
 
    virtual void get(const std::string& key, std::vector<int>& v) const = 0;
 
    virtual void get(const std::string& key, std::vector<double>& v) const = 0;
 
    virtual void get(const std::string& key, std::vector<b2000::csda<double> >& v) const = 0;
 
    virtual void get(const std::string& key, std::vector<std::complex<double> >& v) const = 0;
 
    virtual void warn_on_non_used_key() const = 0;
 
    virtual std::string has_string() const { return "?"; }
 
    static Dictionary& get_empty();
 
    typedef ObjectTypeIncomplete<Dictionary> type_t;
    static type_t type;
};
 
std::ostream& operator<<(std::ostream& out, const Dictionary& dictionary);
 
template <>
inline std::string Dictionary::get<std::string>(const std::string& key) const {
    return get_string(key);
}
 
template <>
inline bool Dictionary::get<bool>(const std::string& key) const {
    return get_bool(key);
}
 
template <>
inline int Dictionary::get<int>(const std::string& key) const {
    return get_int(key);
}
 
template <>
inline double Dictionary::get<double>(const std::string& key) const {
    return get_double(key);
}
 
template <>
inline b2000::csda<double> Dictionary::get<b2000::csda<double> >(const std::string& key) const {
    return get_csda_double(key);
}
 
template <>
inline std::complex<double> Dictionary::get<std::complex<double> >(const std::string& key) const {
    return get_complex_double(key);
}
 
template <>
inline std::string Dictionary::get<std::string>(
      const std::string& key, const std::string& default_) const {
    return get_string(key, default_);
}
 
template <>
inline bool Dictionary::get<bool>(const std::string& key, const bool& default_) const {
    return get_bool(key, default_);
}
 
template <>
inline int Dictionary::get<int>(const std::string& key, const int& default_) const {
    return get_int(key, default_);
}
 
template <>
inline double Dictionary::get<double>(const std::string& key, const double& default_) const {
    return get_double(key, default_);
}
 
template <>
inline b2000::csda<double> Dictionary::get<b2000::csda<double> >(
      const std::string& key, const b2000::csda<double>& default_) const {
    return get_csda_double(key, default_);
}
 
template <>
inline std::complex<double> Dictionary::get<std::complex<double> >(
      const std::string& key, const std::complex<double>& default_) const {
    return get_complex_double(key, default_);
}
 
}  // namespace b2000
 
#endif