variant_record.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2014-09-22
 * Last modified : 2016-11-03
 *
 * Copyright (C) 2014-2016 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:
 *
 *   A record for a variant parameter or variant in a registry of
 *   configuration variants and associated parameters.
 *
 */

#ifndef DATATOOLS_CONFIGURATION_VARIANT_RECORD_H
#define DATATOOLS_CONFIGURATION_VARIANT_RECORD_H

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

// This project (Bayeux/datatools):
#include <datatools/configuration/utils.h>
#include <datatools/command_utils.h>
#include <datatools/ioutils.h>
#include <datatools/units.h>
#include <datatools/logger.h>

namespace datatools {

  namespace configuration {

    class variant_registry;

    class variant_record
    {
    public:

      // \brief Record for daughter variant record
      class daughter_type {
      public:
        daughter_type(const std::string & name_, variant_record & vrec_, const int rank_ = -1)
          : _name_(name_)
          , _handle_(&vrec_)
          , _rank_((rank_< 0) ? -1 : rank_) {}
        const std::string & get_name() const { return _name_; }
        const variant_record & get_record() const { return *_handle_;}
        variant_record & grab_record() { return *_handle_;}
        bool is_ranked() const { return _rank_ >= 0; }
        int get_rank() const { return _rank_; }
      private:
        std::string      _name_;
        variant_record * _handle_ = nullptr;
        int              _rank_ = -1;
      };

      typedef std::map<std::string, daughter_type> daughter_dict_type;

      variant_record();

      virtual ~variant_record();

      datatools::logger::priority get_logging() const;

      void set_logging(const datatools::logger::priority);

      bool is_valid() const;

      bool has_path() const;

      void set_path(const std::string &);

      const std::string & get_path() const;

      void set_base_name(const std::string &);

      const std::string & get_base_name() const;

      void set_indexes(const std::vector<uint32_t>&);

      const std::vector<uint32_t> & get_indexes() const;

      std::size_t get_occurrence_dimension() const;

      void set_with_update(bool);

      bool has_with_update() const;

      std::string get_leaf_name() const;

      std::string get_parent_name() const;

      bool has_parent_registry() const;

      void set_parent_registry(const variant_registry & rep_);

      const variant_registry & get_parent_registry() const;

      bool has_parent_repository() const;

      const variant_repository & get_parent_repository() const;

      bool is_top_variant() const;

      bool has_parent() const;

      void set_parent(variant_record & parent_, const std::string & daughter_name_, int rank_ = -1);

      const variant_record & get_parent() const;

      variant_record & grab_parent();

      bool has_daughters() const;

      daughter_dict_type & grab_daughters();

      const daughter_dict_type & get_daughters() const;

      const variant_record & get_daughter(const std::string &) const;

      variant_record & grab_daughter(const std::string &);

      bool has_parameter_model() const;

      void set_parameter_model(const parameter_model &);

      const parameter_model & get_parameter_model() const;

      bool has_variant_model() const;

      void set_variant_model(const variant_model &);

      const variant_model & get_variant_model() const;

      bool is_variant() const;

      bool is_parameter() const;

      bool is_fixed_parameter() const;

      void set_active(bool active_);

      bool is_active() const;

      bool value_is_set() const;

      bool default_value_is_set() const;

      bool check_enabled_parameter() const;

      bool check_enabled_value(const parameter_value_type & value_) const;

      bool check_enabled_group(const std::string & group_name_) const;

      command::returned_info set_default_value();

      command::returned_info set_fixed_value();

      bool is_boolean_valid(const bool) const;

      command::returned_info set_boolean_value(bool);

      bool is_integer_valid(const int) const;

      command::returned_info set_integer_value(int);

      bool is_real_valid(const double) const;

      command::returned_info set_real_value(double);

      bool is_string_valid(const std::string &) const;

      command::returned_info set_string_value(const std::string &);

      command::returned_info unset_value();

      command::returned_info value_is_set(bool &) const;

      command::returned_info get_boolean_value(bool &) const;

      command::returned_info get_integer_value(int &) const;

      command::returned_info get_real_value(double &) const;

      command::returned_info get_string_value(std::string &) const;

      command::returned_info value_to_string(std::string & format_) const;

      command::returned_info string_to_value(const std::string & format_);

      void build();

      void build_list_of_ranked_parameter_records(std::vector<std::string> & ranked_) const;

      void reset();

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

      void update();

      void forced_update();

    private:

      // FUTURE: better to have this method
      // void _add_daughter_(variant_record &, name, rank... );

      void _compute_ranked_unranked_daughters_();

      void _update_();

      void _update_parameter_();

      void _update_variant_();

      void _fix_();

      void _fix_parameter_value_();

      void _fix_dependers_on_this_variant_();

    private:

      // Management:
      datatools::logger::priority _logging_ = datatools::logger::PRIO_FATAL; 
      bool                        _with_update_ = false;       

      // Configuration:
      std::string              _path_;                      
      std::string              _base_name_;                 
      std::vector<uint32_t>    _indexes_;                   
      const variant_registry * _parent_registry_ = nullptr; 
      const parameter_model *  _parameter_model_ = nullptr; 
      const variant_model   *  _variant_model_ = nullptr;   
      variant_record *         _parent_ = nullptr;          
      daughter_dict_type       _daughters_;                 
      std::vector<std::string> _ranked_daughters_;          
      std::vector<std::string> _unranked_daughters_;        

      // Working data:
      bool        _active_ = false;    
      bool        _value_set_ = false; 
      bool        _boolean_value_;     
      int32_t     _integer_value_;     
      double      _real_value_;        
      std::string _string_value_;      

    };

  } // end of namespace configuration

} // end of namespace datatools

#endif // DATATOOLS_CONFIGURATION_VARIANT_RECORD_H

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