things.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2011-03-08
 * Last modified : 2014-06-18
 *
 * Copyright (C) 2011-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:
 *
 *   A serializable container for arbitrary serializable objects
 *
 *   Storable objects must :
 *   - have a default constructor
 *   - inherit from the datatools::i_serializable interface
 *   - have a 'serialize' template method (ala Boost)
 *
 * History:
 *
 */
#ifndef DATATOOLS_THINGS_H
#define DATATOOLS_THINGS_H

// Standard Library:
#include <exception>
#include <iostream>
#include <map>
#include <sstream>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <vector>

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

// This Project:
#include <datatools/i_serializable.h>
#include <datatools/serialization_macros.h>
#include <datatools/i_clear.h>
#include <datatools/i_tree_dump.h>
#include <datatools/bit_mask.h>

namespace datatools {

  // Forward declaration:
  class things;

  class bad_things_cast
    : public std::exception
  {
  public:

    explicit bad_things_cast (const std::string & msg_);

    virtual ~bad_things_cast() throw();

    virtual const char* what() const throw();

  private:

    std::string _message_; 

  };

  class things
    : public datatools::i_serializable
    , public datatools::i_tree_dumpable
    , public datatools::i_clear
    , private boost::noncopyable
  {
  public:

    struct entry_type
      : public datatools::i_tree_dumpable
    {
      static const char MASK_CONST = bit_mask::bit00;

    public:

      entry_type();

      virtual ~entry_type();

      bool is_not_const() const;

      bool is_const() const;

      void set_const(bool const_ = true);

      void set_description(const std::string &);

      const std::string & get_description() const;

      bool has_description() const;

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

    public:

      std::string                 description;
      uint8_t                     flags;
      datatools::i_serializable * handle;

      BOOST_SERIALIZATION_BASIC_DECLARATION ()

    };

    // Begin the things declarations...
  public:

    static const bool constant;     // = true;
    static const bool non_constant; // = !constant;
    static const bool copyable;     // = true;
    static const bool noncopyable;  // = !copyable;

    typedef std::map<std::string, entry_type> dict_type;

    things();

    things(const std::string & name_, const std::string & description_ = "");

    // Destructor
    virtual ~things();

    const std::string & get_name() const;

    things & set_name(const std::string &);

    const std::string & get_name_impl() const;

    void set_name_impl(const std::string &);

    bool has_name() const;

    bool has_name_impl() const;

    const std::string & get_description() const;

    things & set_description(const std::string &);

    void set_description_impl(const std::string &);

    const std::string & get_description_impl() const;

    bool has_description_impl() const;

    void reset();

    virtual void clear();

    unsigned int size() const;

    bool empty() const;

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

    bool has_serial_tag(const std::string & name_,
                        const std::string & serial_tag_) const;

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

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

    void set_constant(const std::string & name_, bool const_ = true);

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

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

    void set_description(const std::string & name_, const std::string & desc_);

    void set_entry_description(const std::string & name_, const std::string & desc_);

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

    const std::string & get_entry_name(int index_) const;

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

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

    template<class T>
    T& add(const std::string & name_, const std::string & desc_ = "",
           bool const_ = false);

    template<class T>
    T* pop(const std::string & name_);

    template<class T>
    T& grab(const std::string & name_);

    template<class T>
    bool is_a(const std::string & name_) const;

    template<class T>
    const T& get(const std::string & name_) const;

    const datatools::i_serializable &
    get_entry(const std::string & name_) const;

    datatools::i_serializable &
    grab_entry(const std::string & name_);

    datatools::i_serializable &
    add_entry(const std::string & name_,
              const std::string & serial_tag_,
              const std::string & description_ = "",
              bool const_ = false);

    datatools::i_serializable &
    add_entry_impl(const std::string & name_,
                   const std::string & serial_tag_,
                   const std::string & description_,
                   bool const_);

    bool entry_is_a(const std::string & name_, const std::string &) const;

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

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

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

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

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

    datatools::i_serializable &
    grab(const std::string & name_, const std::string & serial_tag_ = "");

    const datatools::i_serializable &
    get(const std::string & name_, const std::string & serial_tag_ = "") const;

  private:

    void add_impl(const std::string & name_,
                  datatools::i_serializable * obj_,
                  const std::string & desc_ = "",
                  bool const_ = false);

  private:

    // Attributes :
    std::string _name_;        
    std::string _description_; 
    dict_type   _things_;      

    DATATOOLS_SERIALIZATION_DECLARATION_ADVANCED(things)
    DATATOOLS_SERIALIZATION_BACKWARD_SERIAL_TAG_SUPPORT()

    
    DR_CLASS_RTTI()

  };

}  // end of namespace datatools

// Template methods
#include <datatools/things-inl.h>

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

#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::things,"datatools::things")

// Activate reflection layer for the 'datatools::things' class:
DR_CLASS_NONCOPYABLE_INIT(::datatools::things)

// Explicit class version:
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(datatools::things, 1)

#endif // DATATOOLS_THINGS_H

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