enriched_base.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2013-09-12
 * Last modified: 2015-04-18
 *
 * License:
 *
 * Copyright (C) 2013-2015 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 base class for complex objects with several basic attributes.
 *
 */

#ifndef DATATOOLS_ENRICHED_BASE_H
#define DATATOOLS_ENRICHED_BASE_H

// Standard library:
#include <iostream>
// - Breaks with GCC4.9.2_2 in C++98 :
// #include <cstdint> // requires C++11
// Third party:
#include <boost/cstdint.hpp>

// This project:
#include <datatools/bit_mask.h>
#include <datatools/i_serializable.h>
#include <datatools/i_tree_dump.h>
#include <datatools/logger.h>
#include <datatools/properties.h>

namespace datatools {
  class object_configuration_description;

  class enriched_base
    : public datatools::i_serializable
    , public datatools::i_tree_dumpable
  {

  public:

    static bool validate_name(const std::string & candidate_name_);

    virtual bool is_name_valid(const std::string & name_) const;

    enriched_base();

    enriched_base(const std::string & name_,
                  const std::string & display_name_ = "",
                  const std::string & terse_description_ = "",
                  logger::priority lp_ = logger::PRIO_FATAL);

    virtual ~enriched_base();

    bool has_name() const;

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

    enriched_base & set_name_c(const std::string & name_);

    const std::string & get_name() const;

    void reset_name();

    bool has_display_name() const;

    void set_display_name(const std::string & display_name_);

    enriched_base & set_display_name_c(const std::string & display_name_);

    const std::string & get_display_name() const;

    bool has_terse_description() const;

    void set_terse_description(const std::string & terse_description_);

    enriched_base & set_terse_description_c(const std::string & terse_description_);

    const std::string & get_terse_description() const;

    bool has_auxiliaries() const;

    const datatools::properties & get_auxiliaries() const;

    datatools::properties & grab_auxiliaries();

    void reset_auxiliaries();

    bool is_debug() const;

    void set_logging_priority(logger::priority lp_);

    enriched_base & set_logging_priority_c(logger::priority lp_);

    void set_logging(const std::string & label_);

    logger::priority get_logging_priority() const;

    static logger::priority default_logging_priority();

    void clear();

    void reset();

    void print_tree(std::ostream & out_ = std::clog,
                    const boost::property_tree::ptree & options_ = empty_options()) const override;
    
    void tree_dump(std::ostream & out_ = std::clog,
                   const std::string & title_  = "",
                   const std::string & indent_ = "",
                   bool inherit_ = false) const override;
    
    void initialize(const datatools::properties & config_, bool clear_ = false);

    enum export_config_flags {
      EXPORT_CONFIG_CLEAR             = bit_mask::bit00,
      EXPORT_CONFIG_NAME              = bit_mask::bit01,
      EXPORT_CONFIG_DISPLAY_NAME      = bit_mask::bit02,
      EXPORT_CONFIG_TERSE_DESCRIPTION = bit_mask::bit03,
      EXPORT_CONFIG_LOGGING_PRIORITY  = bit_mask::bit04,
      EXPORT_CONFIG_AUXILIARIES       = bit_mask::bit05,
      EXPORT_CONFIG_DEFAULT           = (EXPORT_CONFIG_CLEAR
                                         | EXPORT_CONFIG_DISPLAY_NAME
                                         | EXPORT_CONFIG_TERSE_DESCRIPTION
                                         | EXPORT_CONFIG_AUXILIARIES),
      EXPORT_CONFIG_LAST             = EXPORT_CONFIG_AUXILIARIES
    };

    void export_to_config(datatools::properties & config_,
                          uint32_t flags_ = EXPORT_CONFIG_DEFAULT,
                          const std::string & prefix_ = "") const;

    static void init_ocd(datatools::object_configuration_description &);

  private:

    std::string _name_;                  
    std::string _display_name_;          
    std::string _terse_description_;     
    logger::priority _logging_priority_; 
    datatools::properties _auxiliaries_; 

    DATATOOLS_SERIALIZATION_DECLARATION_ADVANCED(enriched_base)

#ifndef Q_MOC_RUN
    DR_CLASS_RTTI()
#endif // Q_MOC_RUN

  };

} // end of namespace datatools

#include <boost/serialization/export.hpp>
BOOST_CLASS_EXPORT_KEY2(datatools::enriched_base, "datatools::enriched_base")

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

#endif // DATATOOLS_ENRICHED_BASE_H

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