ihs.h

Go to the documentation of this file.

//
// Copyright (c) 2015-2017 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_UI_IHS_H
#define DATATOOLS_UI_IHS_H

// Standard libraries:
#include <cstdlib>
#include <string>
#include <iostream>
#include <sstream>
#include <exception>
#include <map>
#include <vector>
#include <set>

// Third Party:
// - Boost:
#include <boost/filesystem.hpp>

// This project:
#include <datatools/enriched_base.h>
#include <datatools/properties.h>
#include <datatools/ui/base_command_interface.h>
#include <datatools/ui/base_command.h>

namespace datatools {

  namespace ui {

    class ihs
      : public datatools::enriched_base
    {
    public:

      enum node_type {
        NODE_INVALID   = -1, 
        NODE_INTERFACE =  0, 
        NODE_COMMAND   =  1  
      };

      static std::string node_type_to_label(node_type);

      static node_type label_to_node_type(const std::string & label_);

      static void path_remove_scheme(const std::string & path_, std::string & out_);

      static bool path_has_scheme(const std::string & path_, const std::string & scheme_ = "");

      // Future: Replace with URL validation utility
      // //! Check if a path is valid
      // static bool path_validation(const std::string & path_);

      class node
      : public datatools::i_tree_dumpable
      {
      public:

        node();

        node(node_type type_, const std::string & full_path_);

        virtual ~node();

        void reset();

        void set_type(node_type type_);

        node_type get_type() const;

        bool is_root() const;

        bool is_valid() const;

        bool is_interface() const;

        bool is_command() const;

        datatools::properties & grab_metadata();

        const datatools::properties & get_metadata() const;

        const std::string & get_full_path() const;

        void set_full_path(const std::string &);

        bool has_description() const;

        void set_description(const std::string &);

        const std::string & get_description() const;

        bool has_interface() const;

        bool has_command() const;

        void set_interface(base_command_interface *);

        void set_external_interface(base_command_interface &);

        void reset_interface();

        void set_command(base_command *);

        void reset_command();

        void set_external_command(base_command &);

        base_command_interface & grab_interface();

        const base_command_interface & get_interface() const;

        base_command & grab_command();

        const base_command & get_command() const;

        bool has_parent_node() const;

        void set_parent_node(node & node_);

        void unset_parent_node();

        node & grab_parent_node();

        bool is_child_of(node & node_) const;

        const node & get_parent_node() const;

        void add_child_node(node & node_);

        void remove_child_node(node & node_);

        std::size_t get_number_of_children() const;

        bool has_children() const;

        void set_ihs(ihs &);

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

        void set_trait(const std::string & trait_label_, const bool set_ = true);

        void reset_trait(const std::string & trait_label_);

        bool is_trait(const std::string & trait_label_) const;

      private:

        ihs                    * _ihs_ = nullptr;           
        node_type                _type_;                    
        datatools::properties    _metadata_;                
        std::string              _full_path_;               
        std::string              _description_;             
        bool                     _owned_interface_ = false; 
        base_command_interface * _interface_ = nullptr;     
        bool                     _owned_command_ = false;   
        base_command           * _command_ = nullptr;       
        node *                   _parent_node_;             
        std::set<node *>         _children_;                

        friend class ihs;

      };

      typedef std::map<std::string, node> node_dict_type;

      ihs(const std::string & scheme_ = "");

      virtual ~ihs();

      // //! Return the root path
      // const std::string & get_root_path() const;

      bool has_scheme() const;

      void set_scheme(const std::string &);

      const std::string & get_scheme() const;

      void add_interface(const std::string & parent_path_,
                         const std::string & interface_name_,
                         const std::string & description_ = "");

      void add_interface(const std::string & parent_path_,
                         base_command_interface * interface_);

      void add_interface(const std::string & parent_path_,
                         base_command_interface & interface_);

      void remove_interface(const std::string & interface_path_, bool recursive_ = false);

      void add_command(const std::string & parent_path_,
                       base_command & cmd_);

      void add_command(const std::string & parent_path_,
                       base_command * cmd_);

      void remove_command(const std::string & command_path_);

      void remove(const std::string & path_, bool recursive_ = false);

      bool exists(const std::string & path_) const;

      bool is_interface(const std::string & path_) const;

      bool has_interface(const std::string & path_) const;

      bool is_command(const std::string & path_) const;

      void set_trait(const std::string & path_,
                     const std::string & trait_label_,
                     const bool set_ = true);

      void reset_trait(const std::string & path_,
                       const std::string & trait_label_);

      bool is_trait(const std::string & path_,
                    const std::string & trait_label_) const;

      bool has_command(const std::string & path_) const;

      base_command & grab_command(const std::string & path_);

      const base_command & get_command(const std::string & path_) const;

      base_command_interface & grab_interface(const std::string & path_);

      const base_command_interface & get_interface(const std::string & path_) const;

      bool has_children(const std::string & path_) const;

      void build_children_paths(const std::string & path_,
                                std::vector<std::string> & children_paths_) const;

      std::string get_parent_path(const std::string & path_) const;

      bool has_child(const std::string & path_, const std::string & name_) const;

      void reset();

      std::string canonical_path(const std::string & path_) const;

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

      void build_path(std::set<std::string> & paths_, const uint32_t flags_ = 0) const;

    protected:

      node & _grab_node(const std::string & path_);

      const node & _get_node(const std::string & path_) const;

    private:

      void _set_scheme_(const std::string &);

    private:

      std::string    _scheme_; 
      node_dict_type _nodes_;  

    };

  } // namespace ui

} // namespace datatools

#endif //  DATATOOLS_UI_IHS_H

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