/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/params

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_params
#define inlib_params

// used in OpenPAW to handle OPT and SET.
// used in Lib/Session to handle parameters.

#include <list>
#include <string>
#include <vector>

namespace inlib {

template <class K,class V>
class param {
public:
  param(
   int a_ategory
  ,const K& a_key
  ,const std::string& a_label
  ,const V& a_value
  ,const V& a_default
  ,const V& a_alternative
  )
  :m_category(a_ategory)
  ,m_key(a_key)
  ,m_label(a_label)
  ,m_value(a_value)
  ,m_default(a_default)
  ,m_alternative(a_alternative)
  ,m_touched(false){
  }
  virtual ~param(){}
public:
  param(const param& aFrom)
  :m_category(aFrom.m_category)
  ,m_key(aFrom.m_key)
  ,m_label(aFrom.m_label)
  ,m_value(aFrom.m_value)
  ,m_default(aFrom.m_default)
  ,m_alternative(aFrom.m_alternative)
  ,m_touched(false){
  }
  param& operator =(const param& aFrom){
    m_category = aFrom.m_category;
    m_key = aFrom.m_key;
    m_label = aFrom.m_label;
    m_value = aFrom.m_value;
    m_default = aFrom.m_default;
    m_alternative = aFrom.m_alternative;
    m_touched = false;
    return *this;
  }
public:
  int category() const { return m_category;}
  bool touched() const { return m_touched;}
  const K& key() const { return m_key;}
  const std::string& label() const { return m_label;}
  const V& value() const { return m_value;}
  const V& default_value() const { return m_default;}
  const V& alternative() const { return m_alternative;}
public:
  int m_category;
  K m_key;
  std::string m_label;
  V m_value;
  V m_default;
  V m_alternative;
  bool m_touched;
};


template <class K,class V>
class params {
public:
  typedef std::list< param<K,V> > list_t;
  typedef typename list_t::iterator it_t;
  typedef typename list_t::const_iterator const_it_t;
public:
  params(const K& a_key_not_found,V a_value_not_found)
  :m_key_not_found(a_key_not_found),m_value_not_found(a_value_not_found){}
  virtual ~params(){}

  params(const params& a_from)
  :m_key_not_found(a_from.m_key_not_found)
  ,m_value_not_found(a_from.m_value_not_found)
  ,m_list(a_from.m_list)
  {}

  params& operator=(const params& a_from) {
    m_key_not_found = a_from.m_key_not_found;
    m_value_not_found = a_from.m_value_not_found;
    m_list = a_from.m_list;
    return *this;
  }
public:
  void add(int a_ategory,const K& a_key,const std::string& a_label,const V& a_value,const V& a_default,const V& a_alternative) {
    m_list.push_back
      (param<K,V>(a_ategory,a_key,a_label,a_value,a_default,a_alternative));
  }

  void remove(const K& a_key) {
    it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        //m_list.remove(*it); //Need a operator==(param,param)
        m_list.erase(it);
        return;
      }
    } 
  }

  void set_value(const K& a_key,V a_value) {
    it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        (*it).m_value = a_value;
        (*it).m_touched = true;
        return;
      }
    } 
  }

  void set_all_to_default() {
    it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      (*it).m_value = (*it).m_default;
      (*it).m_touched = false;
    }
  }

  void set_category_to_default(int a_ategory) {
    it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if((*it).m_category==a_ategory) {
        (*it).m_value = (*it).m_default;
      }
    }
  }

  void set_to_default(const K& a_key) {
    it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        (*it).m_value = (*it).m_default;
      }
    }
  }

  std::string label(const K& a_key) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        return (*it).m_label;
      }
    }
    return "";
  }

  bool category(const K& a_key,int& a_ategory) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        a_ategory = (*it).m_category;
        return true;
      }
    }
    return false;
  }

  bool touched(const K& a_key,bool& a_touched) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        a_touched = (*it).m_touched;
        return true;
      }
    }
    a_touched = false;
    return false;
  }

  V value(const K& a_key) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        return (*it).m_value;
      }
    }
    return m_value_not_found;
  }

  V default_value(const K& a_key) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        return (*it).m_default;
      }
    }
    return m_value_not_found;
  }

  const K& key(V a_value) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_value==(*it).m_value) { //Need operator==(V,V)
        return (*it).m_key;
      }
    }
    return m_key_not_found;
  }

  const K& key_boolean(V a_value) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if( (a_value==(*it).m_default) || 
          (a_value==(*it).m_alternative) ) { //Need operator==(V,V)
        return (*it).m_key;
      }
    }
    return m_key_not_found;
  }

  bool is_key(const K& a_key) const {
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      if(a_key==(*it).m_key) {
        return true;
      }
    }
    return false;
  }

  const list_t& list() const { return m_list;}

  const K& key_not_found() const { return m_key_not_found;}

  V value_not_found() const { return m_value_not_found;}

  std::vector<K> keys() const {
    std::vector<K> ks;
    const_it_t it;
    for(it=m_list.begin();it!=m_list.end();++it) {
      ks.push_back((*it).m_key);
    }
    return ks;
  }

protected:
  K m_key_not_found;
  V m_value_not_found;
  list_t m_list;
};

}

#endif