properties.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2008-02-19
 * Last modified: 2019-01-17
 *
 * License:
 *
 * Copyright (C) 2008-2019 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 simple properties dictionary with I/O functionalities.
 *
 */

#ifndef DATATOOLS_PROPERTIES_H
#define DATATOOLS_PROPERTIES_H

// Standard Library:
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>
#include <memory>

// Third Party:
// - Boost:
#include <boost/cstdint.hpp>
#include <boost/serialization/access.hpp>

// This Project:
#include <datatools/datatools_config.h>
#include <datatools/i_serializable.h>
#include <datatools/i_tree_dump.h>
#include <datatools/i_clear.h>
#include <datatools/i_cloneable.h>
#include <datatools/bit_mask.h>
#include <datatools/exception.h>

namespace datatools {


  class properties
    : public datatools::i_serializable
    , public datatools::i_tree_dumpable
    , public datatools::i_clear
    , public datatools::i_cloneable
  {
  public:
    
    //----------------------------------------------------------------------
    //
    class data {
      
    public:
      static const int ERROR_SUCCESS = 0;
      static const int ERROR_FAILURE = 1;
      static const int ERROR_BADTYPE = 2;
      static const int ERROR_RANGE   = 3;
      static const int ERROR_LOCK    = 4;

      static const uint8_t MASK_TYPE          = 0x7;  // = 00000111
      static const uint8_t MASK_UNIT_SYMBOL   = 0x8;  // = 00001000 for real parameters
      static const uint8_t MASK_EXPLICIT_PATH = 0x10; // = 00010000 for string parameters
      static const uint8_t MASK_EXPLICIT_UNIT = 0x20; // = 00100000 for real parameters
      static const uint8_t MASK_LOCK          = 0x40; // = 01000000
      static const uint8_t MASK_VECTOR        = 0x80; // = 10000000

      static const uint8_t TYPE_NONE    = 0x0; // = 000
      static const uint8_t TYPE_BOOLEAN = 0x1; // = 001
      static const uint8_t TYPE_INTEGER = 0x2; // = 010
      static const uint8_t TYPE_REAL    = 0x3; // = 011
      static const uint8_t TYPE_STRING  = 0x4; // = 100

      static const char TYPE_BOOLEAN_SYMBOL = 'B';
      static const char TYPE_INTEGER_SYMBOL = 'I';
      static const char TYPE_REAL_SYMBOL    = 'R';
      static const char TYPE_STRING_SYMBOL  = 'S';

      static const char STRING_FORBIDDEN_CHAR = '"';

      static const int SCALAR_DEF  = -1;
      static const int SCALAR_SIZE =  1;

      struct defaults {
        static bool boolean_value(); // return false
        static int integer_value();  // return 0
        static double real_value();  // return 0.0
        static const std::string string_value(); // return empty string
      };

    public:
      
      typedef std::vector<bool>        vbool;   
      typedef std::vector<int32_t>     vint;    
      typedef std::vector<double>      vdouble; 
      typedef std::vector<std::string> vstring; 

    public:

      data(char type_ = TYPE_INTEGER_SYMBOL,
           int size_ = SCALAR_DEF);

      data(bool value_, int size_ = SCALAR_DEF);

      data(int value_, int size_ = SCALAR_DEF);

      data(double value_, int size_ = SCALAR_DEF);

      data(const std::string & value_, int size_ = SCALAR_DEF);

      data(const char* value_, int size_ = SCALAR_DEF);

      virtual ~data();

      bool has_description() const;

      void set_description(const std::string & description_);

      const std::string & get_description() const;

      int set_unit_symbol(const std::string & symbol_);

      const std::string & get_unit_symbol() const;

      bool has_type() const;

      int get_type() const;

      bool is_boolean() const;

      bool is_integer() const;

      bool is_real() const;

      bool is_string() const;

      bool is_path() const;

      bool is_scalar() const;

      bool is_vector() const;

      bool is_locked() const;

      bool has_unit_symbol() const;

      bool has_explicit_unit() const;

      bool is_explicit_path() const;

      bool is_unlocked() const;

      int boolean(int size_ = SCALAR_DEF);

      int integer(int size_ = SCALAR_DEF);

      int real(int size_ = SCALAR_DEF);

      int string(int size_ = SCALAR_DEF);

      int lock();

      int unlock();

      int32_t get_size() const;

      int32_t size() const;

      bool empty() const;

      bool index_is_valid(int index_) const;

      bool get_boolean_value(int index_ = 0) const;

      int get_integer_value(int index_ = 0) const;

      double get_real_value(int index_ = 0) const;

      std::string get_string_value(int index_ = 0) const;

      int set_value(bool value_, int index_ = 0);

      int set_value(int value_, int index_ = 0);

      int set_value(double value_, int index_ = 0, bool explicit_unit_ = false);

      int set_value_with_unit(double value_, int index_ = 0, const std::string & unit_symbol_ = "");

      int set_explicit_unit(bool explicit_unit_flag_);

      int set_explicit_path(bool explicit_path_flag_);

      int set_value(const std::string & value_, int index_ = 0, bool explicit_path_flag_ = false);

      int set_value(const char * value_, int index_ = 0, bool explicit_path_flag_ = false);

      int get_value(bool & value_, int index_ = 0) const;

      int get_value(int & value_, int index_ = 0) const;

      int get_value(double & value_, int index_ = 0) const;

      int get_value(std::string & value_, int index_ = 0) const;

      std::string get_type_label() const;

      std::string get_vector_label() const;

      static bool has_forbidden_char(const std::string & checked_);

      void dump(std::ostream & out_) const;

      void to_string(std::ostream & out_) const;

      static std::string get_error_message(int error_code_);

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

    private:
      
      void clear_values_();

      void clear_unit_symbol_();

      int init_values_(char type_ = TYPE_INTEGER_SYMBOL,
                       int size_ = SCALAR_DEF);

      BOOST_SERIALIZATION_BASIC_DECLARATION()

      private:
      std::string _description_; 

      uint8_t     _flags_;          
      vbool       _boolean_values_; 
      vint        _integer_values_; 
      vdouble     _real_values_;    
      vstring     _string_values_;  
      std::string _unit_symbol_;    

    }; //----- end of data inner class


    //----------------------------------------------------------------------
    // Key validator inner classes
    struct basic_key_validator
      : public std::unary_function<std::string,bool>
    {
      virtual ~basic_key_validator()
      {
        return;
      }

      virtual bool operator()(const std::string & key_arg_) const = 0;
    };

    class default_key_validator
      : public basic_key_validator
    {
    public:
      static const std::string & allowed_chars();

      default_key_validator();

      virtual ~default_key_validator();

      virtual bool operator()(const std::string & key_arg_) const;
    };

    //----------------------------------------------------------------------
    // Config inner class
    //
    friend class config;
    class config {
    public:

      static const std::string & lock_decorator();
      static const std::string & as_directive();
      static const std::string & in_directive();
      static const std::string & path_decorator();
      static const std::string & metacomment_prefix();

      enum decoration_mode_type {
        MODE_BARE          = 0,         
        MODE_HEADER_FOOTER = 1,         
        MODE_DEFAULT       = MODE_BARE, 
        mode_bare          = MODE_BARE,
        mode_header_footer = MODE_HEADER_FOOTER
      };

      enum options_flag {
        SKIP_PRIVATE       = bit_mask::bit00, 
        FORBID_VARIANTS    = bit_mask::bit01, 
        LOG_MUTE           = bit_mask::bit02, 
        LOG_DEBUG          = bit_mask::bit03, 
        LOG_TRACE          = bit_mask::bit04, 
        SMART_MODULO       = bit_mask::bit05, 
        HEADER_FOOTER      = bit_mask::bit06, 
        REQUESTED_TOPIC    = bit_mask::bit07, 
        FORBID_INCLUDES    = bit_mask::bit08, 
        DONT_CLEAR         = bit_mask::bit09, 
        RESOLVE_PATH       = bit_mask::bit10, 
        ALLOW_KEY_OVERRIDE = bit_mask::bit11, 
        LOG_WARNING        = bit_mask::bit12  
      };

      config(uint32_t options_ = 0,
             const std::string & topic_ = "",
             const std::string & section_name_ = "",
             int section_start_line_number_ = -1);

      virtual ~config();

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

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

      void read(std::istream & in_, properties & prop_);

      void read(const std::string & in_, properties & prop_);

      void write(std::ostream & out_, const properties & prop_);

      void write(const std::string & filename_, const properties & prop_);

      int get_current_line_number() const;

      void set_reader_input(const std::string & filename_, int line_count_ = -1);

      bool has_topic() const;

      void set_topic(const std::string & topic_);

      const std::string & get_topic() const;

      bool has_section_info() const;

      void set_section_info(const std::string & section_name_,
                            int section_start_line_number_);

      void reset_section_info();

      const std::string & get_section_name() const;

      int get_section_start_line_number() const;

      void reset();

      void write_metacomment(std::ostream & out_,
                             const std::string & tag_,
                             const std::string & value_ = "",
                             const std::string & comment_ = "");

      void write_data(std::ostream & out_,
                      const std::string & data_key_,
                      const properties::data& prop_data_,
                      const std::string & unit_symbol_ = "",
                      const std::string & unit_label_ = "",
                      const std::string & comment_ = "");

    private:

      void _init_defaults_();

      void _read_(std::istream & in_, properties & prop_);

      void _write_(std::ostream & out_, const properties & prop_);

    private:

      // Configuration:
      logger::priority _logging_; 
      int    _mode_;              
      bool   _dont_clear_;        
      bool   _use_smart_modulo_;  
      bool   _write_public_only_; 
      bool   _forbid_variants_;   
      bool   _forbid_includes_;   
      bool   _requested_topic_;   
      bool   _resolve_path_;      
      bool   _allow_key_override_ = false; 
      std::string _topic_;             
      std::string _section_name_;      
      int _section_start_line_number_; 

      // Working parsing data:
      size_t      _current_line_number_; 
      std::string _current_filename_;    

    }; //----- end of class config

    //----------------------------------------------------------------------
    // properties class declarations
    //
  public:

    static const std::string & private_property_prefix();

    // Typedefs declarations:
    
  protected:

    typedef std::map<std::string, data> pmap;

  public:

    typedef std::vector<std::string>    keys_col_type;

  public:
    
    properties();

    explicit properties(const std::string & desc_);

    properties(const std::string & desc_, const basic_key_validator &);

    explicit properties(const basic_key_validator &);

    /* with external key validator (deletion_on_destroy_==false)
     * with internal key validator (deletion_on_destroy_==true)
     *      validator is deleted in the destructor.
     */

    properties(const std::string & desc_, const basic_key_validator *,
               bool deletion_on_destroy_ = true);

    explicit properties(const basic_key_validator *,
                        bool deletion_on_destroy_ = true);

    virtual ~properties();

    int32_t size() const;

    bool empty() const;

    void set_description(const std::string &);

    const std::string & get_description() const;

    bool fetch_short_description(std::string &) const;

    bool has_short_description() const;

    std::string get_short_description() const;

    bool has_auxiliary_descriptions() const;

    bool fetch_auxiliary_descriptions(std::vector<std::string> &) const;

    void unset_key_validator();

    void set_default_key_validator();

    void set_key_validator(const basic_key_validator &);

    void set_key_validator(const basic_key_validator *,
                           bool deletion_on_destroy_ = true);

    std::vector<std::string> keys() const;

    const std::string & key (int) const;

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

    const data & get(const std::string & prop_key_) const;

    void store(const std::string & key_, const data & value_);

    void keys_not_starting_with(std::vector<std::string> &, const std::string & prefix_) const;

    std::vector<std::string> keys_not_starting_with(const std::string & prefix_) const;

    void keys_starting_with(std::vector<std::string> &, const std::string & prefix_) const;

    std::vector<std::string> keys_starting_with(const std::string & prefix_) const;

    void keys_not_ending_with(std::vector<std::string> &, const std::string & suffix_) const;

    std::vector<std::string> keys_not_ending_with(const std::string & suffix_) const;

    void keys_ending_with(std::vector<std::string> &, const std::string & suffix_) const;

    std::vector<std::string> keys_ending_with(const std::string & suffix_) const;

    void lock(const std::string & prop_key_);

    void unlock(const std::string & prop_key_);

    bool is_locked(const std::string & prop_key_) const;

    static std::string make_private_key(const std::string & prop_key_);

    static bool key_is_private(const std::string & prop_key_);

    static bool key_is_public(const std::string & prop_key_);

    bool is_private(const std::string & prop_key_) const;

    bool is_public(const std::string & prop_key_) const;

    bool is_boolean(const std::string & prop_key_) const;

    bool is_integer(const std::string & prop_key_) const;

    bool is_real(const std::string & prop_key_) const;

    bool is_string(const std::string & prop_key_) const;

    bool is_scalar(const std::string & prop_key_) const;

    bool is_vector(const std::string & prop_key_) const;

    // 2012-11-14 FM : Should be deprecated
    int32_t size(const std::string & prop_key_) const;

    int32_t key_size(const std::string & prop_key_) const;

    bool has_key(const std::string & prop_key_) const;

    void key_lock (const std::string & prop_key_);

    void key_unlock (const std::string & prop_key_);

    const std::string & get_key_description (const std::string & prop_key_) const;

    void set_key_description (const std::string & prop_key_, const std::string &desc_);

    // 2011-11-27 FM: could be useful
    //void rename (const std::string & prop_key_, const std::string & a_new_key);

    void erase(const std::string & key_);

    void erase_all();

    void erase_all_starting_with(const std::string & prefix_);

    void erase_all_not_starting_with(const std::string & prefix_);

    void export_all(properties & props_) const;

    void export_all_adding_prefix(properties & props_, const std::string & prefix_) const;

    void export_starting_with(properties & props_,
                              const std::string & prop_key_prefix_) const;

    void export_and_rename_starting_with(properties & props_,
                                         const std::string & prop_key_prefix_,
                                         const std::string & new_prefix_) const;

    void export_not_starting_with(properties & props_,
                                  const std::string & prop_key_prefix_) const;

    template <class key_predicate>
    void export_if(properties & props_, const key_predicate & predicate_) const;

    template <class key_predicate>
    void export_not_if(properties & props_,
                       const key_predicate & predicate_) const;

    void erase_all_ending_with(const std::string & suffix_);

    void erase_all_not_ending_with(const std::string & suffix_);

    void export_ending_with(properties & props_,
                            const std::string & suffix_) const;

    void export_not_ending_with(properties & props,
                                const std::string & suffix_) const;

    void clean(const std::string & prop_key_);

    virtual void clear();

    void reset();

    void store_flag(const std::string & prop_key_, const std::string & desc_ = "",
                    bool lock_ = false);


    void set_flag(const std::string & prop_key_);


    void unset_flag(const std::string & prop_key_);

    void store(const std::string & prop_key_, bool value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store_boolean(const std::string & prop_key_, bool value_,
                       const std::string & desc_ = "", bool lock_ = false);

    void store(const std::string & prop_key_, int value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store_integer(const std::string & prop_key_, int value_,
                       const std::string & desc_ = "",
                       bool lock_ = false);

    void store(const std::string & prop_key_, double value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store_real(const std::string & prop_key_, double value_,
                    const std::string & desc_ = "", bool lock_ = false);


    void store_real_with_explicit_unit(const std::string & prop_key_, double value_,
                                       const std::string & desc = "", bool lock_ = false);

    void store_with_explicit_unit(const std::string & prop_key_, double value_,
                                  const std::string & desc = "", bool lock_ = false);

    void set_explicit_unit(const std::string & prop_key_, bool a_explicit_unit = true);

    bool has_explicit_unit(const std::string & prop_key_) const;

    void set_unit_symbol(const std::string & prop_key_, const std::string & unit_symbol = "");

    bool has_unit_symbol(const std::string & prop_key_) const;

    const std::string & get_unit_symbol(const std::string & prop_key_) const;

    void set_explicit_path(const std::string & prop_key_, bool a_explicit_path = true);

    bool is_explicit_path(const std::string & prop_key_) const;

    void store(const std::string & prop_key_, const std::string & value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store_string(const std::string & prop_key_, const std::string & value_,
                      const std::string & desc_ = "", bool lock_ = false);

    void store_path(const std::string & prop_key_, const std::string & path_value_,
                    const std::string & desc_ = "", bool lock_ = false);

    void store(const std::string & prop_key_, const char* value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store(const std::string & prop_key_, const data::vbool & value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store(const std::string & prop_key_, const data::vint & value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store(const std::string & prop_key_, const data::vdouble & value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store(const std::string & prop_key_, const data::vstring & value_,
               const std::string & desc_ = "", bool lock_ = false);

    void store_paths(const std::string & prop_key_, const data::vstring & path_value_,
                     const std::string & desc_ = "", bool lock_ = false);

    void change(const std::string & key_, bool value_, int index_ = 0);

    void change_boolean(const std::string & key_, bool value_, int index_ = 0);

    void change_boolean_scalar(const std::string & key_, bool value_);

    void change_boolean_vector(const std::string & key_, bool value_, int index_);

    void change(const std::string & key_, int value_, int index_ = 0);

    void change_integer(const std::string & key_, int value_, int index_ = 0);

    void change_integer_scalar(const std::string & key_, int value_);

    void change_integer_vector(const std::string & key_, int value_, int index_);

    void change(const std::string & key_, double value_, int index_ = 0);

    void change_real(const std::string & key_, double value_, int index_ = 0);

    void change_real_scalar(const std::string & key_, double value_);

    void change_real_vector(const std::string & key_, double value_, int index_);

    void change(const std::string & key_, const std::string & value_,
                int index_ = 0);

    void change_string(const std::string & key_, const std::string & value_,
                       int index_ = 0);

    void change_string_scalar(const std::string & key_, const std::string & value_);

    void change_string_vector(const std::string & key_, const std::string & value_,
                              int index_);

    void change(const std::string & key_, const char * value_, int index_ = 0);

    void change(const std::string & key_, const data::vbool & values_);

    void change(const std::string & key_, const data::vint & values_);

    void change(const std::string & key_, const data::vdouble & values_);

    void change(const std::string & key_, const data::vstring & values_);

    void update_flag(const std::string & key_);

    void update(const std::string & key_, bool value_);

    void update_boolean(const std::string & key_, bool value_);

    void update(const std::string & key_, int value_);

    void update_integer(const std::string & key_, int value_);

    void update(const std::string & key_, double value_);

    void update_real(const std::string & key_, double value_);

    void update_real_with_explicit_unit(const std::string & key_, double value_);

    void update_with_explicit_unit(const std::string & key_, double value_);

    void update(const std::string & key_, const std::string & value_);

    void update(const std::string & key_, const char* value_);

    void update_string(const std::string & key_, const std::string & value);

    void update(const std::string & key_, const data::vbool & values_);

    void update(const std::string & key_, const data::vint & values_);

    void update(const std::string & key_, const data::vdouble & values_);

    void update(const std::string & key_, const data::vstring & values_);

    bool has_flag(const std::string & key_) const;

    void fetch(const std::string & key_, bool & value_, int index_ = 0) const;

    void fetch(const std::string & key_, int & value_, int index_ = 0) const;

    void fetch(const std::string & key_, double & value_, int index_ = 0) const;

    void fetch(const std::string & key_, std::string & value_,
               int index = 0) const;

    void fetch(const std::string & key_, data::vbool & values_) const;

    void fetch(const std::string & key_, data::vint & values_) const;

    void fetch(const std::string & key_, data::vdouble & values_) const;

    void fetch_dimensionless(const std::string & key_, data::vdouble & values_) const;

    void fetch(const std::string & key_, data::vstring & values_) const;

    void fetch(const std::string & key_, std::set<std::string> & values_, bool allow_duplication_ = false) const;

    void fetch_unique_ordered(const std::string & key_, std::vector<std::string> & values_) const;

    void fetch(const std::string & key_, std::set<int> & values, bool allow_duplication_ = false) const;

    void fetch_positive(const std::string & key_, std::set<unsigned int> & values_, bool allow_duplication_ = false) const;

    bool fetch_boolean(const std::string &, int index_ = 0) const;

    bool fetch_boolean_scalar(const std::string & name_) const;

    bool fetch_boolean_vector(const std::string & name_, int index_) const;

    int fetch_integer(const std::string & name_, int index_ = 0) const;

    unsigned int fetch_positive_integer(const std::string & name_, int index_ = 0) const;

    unsigned int fetch_strict_positive_integer(const std::string & name_, int index_ = 0) const;

    int fetch_range_integer(const std::string & name_, int min_, int max_, int index_ = 0) const;

    int fetch_integer_scalar(const std::string & name_) const;

    int fetch_integer_vector(const std::string & name_ , int index_) const;

    double fetch_real(const std::string & name_, int index_ = 0) const;

    double fetch_dimensionless_real(const std::string & name_, int index_ = 0) const;

    double fetch_real_with_explicit_unit(const std::string & name_, int index_ = 0) const;

    double fetch_real_with_explicit_dimension(const std::string & name_, const std::string & dimension_, int index_ = 0) const;

    double fetch_real_scalar(const std::string & name_) const;

    double fetch_real_vector(const std::string & name_, int index_) const;

    std::string fetch_string(const std::string & name_, int index_ = 0) const;

    char fetch_one_character(const std::string & name_, int index_ = 0) const;

    std::string fetch_string_scalar(const std::string & name_) const;

    std::string fetch_string_vector(const std::string & name_, int index_) const;

    std::string fetch_path(const std::string & name_, int index_ = 0) const;

    std::string fetch_path_scalar(const std::string & name_) const;

    std::string fetch_path_vector(const std::string & name_, int index_) const;

    void dump(std::ostream & out_ = std::clog) const;

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

    void print_tree(std::ostream & out_ = std::clog,
                    const boost::property_tree::ptree & options_ = empty_options()) const override;

    std::string key_to_string(const std::string & key_) const;

    std::string key_to_property_string(const std::string & key_) const;

    void export_to_string_based_dictionary(std::map<std::string, std::string> & dict_,
                                           bool quoted_strings_ = true) const;

    void write_configuration(const std::string & filename_,
                             uint32_t options_ = config::SMART_MODULO | config::SKIP_PRIVATE) const;

    void read_configuration(const std::string & filename_,
                            uint32_t options_ = config::SMART_MODULO);

    static void write_config(const std::string & filename_,
                             const properties & props_,
                             uint32_t options_ = 0);

    static void read_config(const std::string & filename_,
                            properties & props_,
                            uint32_t options_ = 0);

    static std::string build_property_key(const std::string & prefix_,
                                          const std::string & subkey_);

     
  protected:

    static default_key_validator & global_default_key_validator();

  private:

    void _check_nokey_(const std::string & prop_key_) const;

    void _check_key_(const std::string & prop_key_, data ** data_);

    void _check_key_(const std::string & prop_key_, const data ** data_) const;

    void _validate_key_(const std::string & prop_key_) const;

    void _clear_key_validator_();

  private:

    // Internal data:
    std::string                 _description_;            
    pmap                        _props_;                  

    // Not serialized:
    const basic_key_validator * _key_validator_ = nullptr; 
    bool                        _key_validator_deletion_;  

    DATATOOLS_CLONEABLE_DECLARATION(properties)

    
    DATATOOLS_SERIALIZATION_DECLARATION_ADVANCED(properties)
    DATATOOLS_SERIALIZATION_BACKWARD_SERIAL_TAG_SUPPORT()

#ifndef Q_MOC_RUN
    DR_CLASS_RTTI()
#endif // Q_MOC_RUN

  };

  const properties & empty_config();

  //----------------------------------------------------------------------
  // properties class template method definitions
  //
  template <class key_predicate>
  void properties::export_if(properties & props_,
                             const key_predicate & predicate_) const
  {
    DT_THROW_IF (this == &props_,
                 std::logic_error, "Self export is not allowed !");
    keys_col_type ks;
    for (pmap::const_iterator iter = _props_.begin(); iter != _props_.end();
         ++iter) {
      if (predicate_(iter->first)) {
        ks.push_back(iter->first);
      }
    }
    for (keys_col_type::const_iterator i = ks.begin(); i !=  ks.end(); ++i) {
      properties & ptmp = const_cast<properties &>(*this);
      props_._props_[*i] = ptmp._props_[*i];
    }
    return;
  }

  template <class key_predicate>
  void properties::export_not_if(properties & props_,
                                 const key_predicate & predicate_) const
  {
    DT_THROW_IF (this == &props_,
                 std::logic_error, "Self export is not allowed !");
    keys_col_type ks;
    for (pmap::const_iterator iter = _props_.begin(); iter != _props_.end();
         ++iter) {
      if (!predicate_(iter->first)) {
        ks.push_back(iter->first);
      }
    }
    for (keys_col_type::const_iterator i = ks.begin(); i != ks.end(); ++i) {
      properties & ptmp = const_cast<properties &>(*this);
      props_._props_[*i] = ptmp._props_[*i];
    }
    return;
  }

} // end of namespace datatools

// Support for serialization tag :
DATATOOLS_SERIALIZATION_EXT_SERIAL_TAG_DECLARATION(::datatools::properties)
// Support for old serialization tag :
DATATOOLS_SERIALIZATION_EXT_BACKWARD_SERIAL_TAG_DECLARATION(::datatools::properties)

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-local-typedef"
#endif
#include <boost/serialization/export.hpp>
#ifdef __clang__
#pragma clang diagnostic pop
#endif

BOOST_CLASS_EXPORT_KEY2(datatools::properties, "datatools::properties")

#ifndef Q_MOC_RUN
// Activate reflection layer for the 'datatools::properties' class:
DR_CLASS_INIT(::datatools::properties)
#endif // Q_MOC_RUN

// Explicit class version:
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(datatools::properties::data, 2)
BOOST_CLASS_VERSION(datatools::properties, 2)

#endif // DATATOOLS_PROPERTIES_H

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