argument.h

Go to the documentation of this file.

//
// Copyright (c) 2015 by François Mauger <mauger@lpccaen.in2p3.fr>
//
// This file is part of Datatools.
//
// Datatools 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.
//
// Datatools 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 Datatools. If not, see <http://www.gnu.org/licenses/>.

#ifndef DATATOOLS_INTROSPECTION_ARGUMENT_H
#define DATATOOLS_INTROSPECTION_ARGUMENT_H

// Standard library:
#include <string>

// Third party:
// - Boost:
#include <boost/optional.hpp>
#include <boost/any.hpp>
#include <boost/program_options.hpp>
// - Bayeux/datatools:
#include <datatools/properties.h>

// This project:
#include <datatools/introspection/access_type.h>
#include <datatools/introspection/data_description.h>

namespace datatools {

  namespace introspection {

    class method;

    class argument
      : public datatools::i_tree_dumpable
    {
    public:

      argument();

      ~argument();

      bool has_method() const;

      void set_method(const method &);

      void reset_method();

      const method & get_method() const;

      bool has_rank() const;

      std::size_t get_rank() const;

      void set_rank(std::size_t);

      bool has_name() const;

      const std::string & get_name() const;

      void set_name(const std::string &);

      bool has_access() const;

      access_type get_access() const;

      void set_access(access_type);

      bool has_description() const;

      const std::string & get_description() const;

      void set_description(const std::string &);

      bool is_input() const;

      bool is_output() const;

      bool has_data_description() const;

      data_description & grab_data_description();

      const data_description & get_data_description() const;

      void set_data_description(const data_description &);

      bool has_default_value() const;

      template <class T>
      bool is_default_value_a() const
      {
        return _default_value_.type() == typeid(T);
      }

      template <class T>
      const T & get_default_value_as() const
      {
        DT_THROW_IF(!has_default_value(), std::logic_error,
                  "No default value is set!");
        DT_THROW_IF(typeid(T) != get_data_description().native_type(),
                    std::logic_error,
                    "Unmatching type info!");
        return boost::any_cast<T>(_default_value_);
      }

      template <class T>
      void set_default_value_as(const T & value_)
      {
        DT_THROW_IF(typeid(T) != get_data_description().native_type(),
                    std::logic_error,
                    "Unmatching type info!");
        _default_value_ = value_;
        return;
      }

      const boost::any & get_default_value() const;

      void set_default_value(const boost::any & any_value_);

      bool has_default_value_str() const;

      const std::string & get_default_value_str() const;

      void set_default_value_str(const std::string & v_);

      bool is_valid() const;

      void initialize();

      void initialize(const datatools::properties &);

      void reset();

      enum arg_xc_flags {
        ARG_XC_CLEAR              = bit_mask::bit00,
        ARG_XC_ACCESS             = bit_mask::bit01,
        ARG_XC_DATA_DESCRIPTION   = bit_mask::bit02,
        ARG_XC_RANK               = bit_mask::bit03,
        ARG_XC_NAME               = bit_mask::bit04,
        ARG_XC_DESCRIPTION        = bit_mask::bit05,
        ARG_XC_DEFAULT_VALUE_STR  = bit_mask::bit06,
        ARG_XC_DEFAULT = (ARG_XC_CLEAR
                         | ARG_XC_ACCESS
                         | ARG_XC_DATA_DESCRIPTION
                         | ARG_XC_RANK
                         | ARG_XC_NAME
                         | ARG_XC_DESCRIPTION
                         | ARG_XC_DEFAULT_VALUE_STR),
        ARG_XC_LAST    = ARG_XC_DEFAULT_VALUE_STR
      };

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

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

    private:

      access_type      _access_;           
      data_description _data_description_; 
      const method   * _method_;           
      boost::optional<std::size_t> _rank_; 
      boost::optional<std::string> _name_; 
      boost::optional<std::string> _description_; 
      boost::any                   _default_value_; 
      boost::optional<std::string> _default_value_str_; 

    };

  } // namespace introspection

} // namespace datatools

#endif // DATATOOLS_INTROSPECTION_ARGUMENT_H

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