utils.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2014-05-11
 * Last modified : 2014-08-10
 *
 * Copyright (C) 2014 Francois Mauger <mauger@lpccaen.in2p3.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Description:
 *
 *   Some utilities for the description of configuration variants and parameters.
 *
 */

#ifndef DATATOOLS_CONFIGURATION_UTILS_H
#define DATATOOLS_CONFIGURATION_UTILS_H

// Standard library:
#include <string>
#include <map>

// Third party:
#include <boost/variant.hpp>

// This project (Bayeux/datatools):
#include <datatools/handle.h>
#include <datatools/properties.h>
#include <datatools/command_utils.h>

namespace datatools {

  namespace configuration {

    // Forward declarations:
    class parameter_model;
    class variant_repository;
    class variant_model;
    class model_item;

    typedef handle<variant_model> vm_handle_type;

    typedef handle<parameter_model> pm_handle_type;

    typedef std::map<std::string, model_item> model_item_dict_type;

    bool validate_item_name(const std::string &);

    bool validate_instance_name(const std::string &);

    bool validate_model_name(const std::string &);

    bool validate_group_name(const std::string &);

    // class item {
    class model_item {
    public:

      enum model_type {
        MODEL_UNDEFINED = 0, 
        MODEL_PARAMETER = 1, 
        MODEL_VARIANT   = 2  
      };

      static std::string label_from_model_type(model_type);

      static model_type model_type_from_label(const std::string &);

      static const std::string & variant_suffix();

      static const std::string & parameter_suffix();

      model_item();

      virtual ~model_item();

      void reset();

      const std::string & get_name() const;

      void set_name(const std::string & name_);

      bool is_parameter() const;

      bool is_variant() const;

      bool has_model() const;

      void set_model(model_type);

      model_type get_model() const;

      const properties & get_config() const;

      properties & grab_config();

      const parameter_model & get_parameter_model() const;

      parameter_model & grab_parameter_model();

      const variant_model & get_variant_model() const;

      variant_model & grab_variant_model();

      void set_parameter_handle(const pm_handle_type &);

      void set_variant_handle(const vm_handle_type &);

      bool is_instantiated() const;

      void instantiate(model_item_dict_type &);

      void destroy();

      const pm_handle_type & get_parameter_handle() const;

      pm_handle_type & grab_parameter_handle();

      const vm_handle_type & get_variant_handle() const;

      vm_handle_type & grab_variant_handle();

      parameter_model & make_parameter(const std::string & name_ = "");

      variant_model & make_variant(const std::string & name_ = "");

      virtual void tree_dump(std::ostream & out_ = std::clog,
                             const std::string & title_ = "",
                             const std::string & indent_ = "",
                             bool inherit_ = false) const;

      // Methods to manipulate dictionaries of configuration items:

      static parameter_model & add_parameter_item(model_item_dict_type & dict_,
                                                  const std::string & name_);

      static variant_model & add_variant_item(model_item_dict_type & dict_,
                                              const std::string & name_);

      static bool has_item(const model_item_dict_type & dict_,
                           const std::string & name_,
                           model_item::model_type t_ = MODEL_UNDEFINED);

      static const parameter_model & get_parameter_model(const model_item_dict_type & dict_,
                                                         const std::string & name_);

      static const variant_model & get_variant_model(const model_item_dict_type & dict_,
                                                     const std::string & name_);

      static void remove_item(model_item_dict_type & dict_,
                              const std::string & name_);

      static void print_items(const model_item_dict_type & dict_,
                              std::ostream & out_ = std::clog,
                              const std::string & title_ = "",
                              const std::string & indent_ = "",
                              bool inherit_ = false);

    private:

      std::string    _name_;             
      properties     _config_;           
      model_type     _model_;            
      pm_handle_type _parameter_handle_; 
      vm_handle_type _variant_handle_;   

    };


    struct variant_parameter_set_type {
      std::string registry_key;    
      std::string param_key;       
      std::string param_value_str; 
      variant_parameter_set_type();
      void reset();
      command::returned_info parse(const std::string & variant_set_);
    };

    class variant_parameter_set_comparator {
    public:
      variant_parameter_set_comparator();
      variant_parameter_set_comparator(variant_repository &);
      bool operator()(const std::string & vs1_, const std::string & vs2_) const;
    private:
      variant_repository * _repository_ = nullptr;
    };

    typedef boost::variant<bool, int, double, std::string> parameter_value_type;

  }  // end of namespace configuration

}  // end of namespace datatools

#endif // DATATOOLS_CONFIGURATION_UTILS_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --