visitor.hh

Go to the documentation of this file.

// This file is part of Awali.
// Copyright 2016-2022 Sylvain Lombardy, Victor Marsault, Jacques Sakarovitch
//
// Awali is a 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, see <http://www.gnu.org/licenses/>.
 
#ifndef COMMON_JSON_VISITOR_HH
#define COMMON_JSON_VISITOR_HH
 
#include <cstddef>
 
#include <awali/common/json/node.hh>
#include <awali/common/json_ast.hh>
 
namespace awali {
namespace json {
 
enum class visit_t {
  IGNORE_UNVISITED = -1,
  CONTINUE = 0,
  IGNORE_UNVISITED_CHILDREN = 1,
  IGNORE_UNVISITED_CHILDREN_AND_SIBLINGS = 2
};
 
class visitor_t {
private:
  visit_t _stop;
  json::path_t _path_from_root;
  template<typename L> inline void visit_leaf(L* node) 
  { enter(node); if (!is_stopped()) leaf(node->value); leave(node);}
 
public:
  inline void stop(visit_t b = visit_t::IGNORE_UNVISITED) {_stop=b;}
  inline void step_stop() {
    switch(_stop) {
      case visit_t::IGNORE_UNVISITED_CHILDREN:
        _stop = visit_t::CONTINUE;
        break;
      case visit_t::IGNORE_UNVISITED_CHILDREN_AND_SIBLINGS:
        _stop = visit_t::IGNORE_UNVISITED_CHILDREN;
        break;
      default:{}
    }
  }
  inline bool is_stopped() {return visit_t::CONTINUE != _stop;}
  inline visit_t stop_status() {return _stop;}
  inline json::path_t const& path() {return _path_from_root; }
  inline unsigned depth() {return _path_from_root.size(); }
 
protected:
  visitor_t() : _stop(visit_t::CONTINUE), _path_from_root() {}
 
  /* Part of these functions are supposed to be overriden. */
 
  virtual void enter(node_t const*) {}
 
 
  virtual void enter(bool_t const*) {}
  
 
  virtual void enter(object_t const*) {}
  
  virtual void enter(array_t const*) {}
 
  virtual void enter(int_t const*) {}
  
  virtual void enter(string_t const*) {}
  
  virtual void enter(float_t const*) {}
 
  virtual void enter(null_t const*) {}
 
 
  virtual void leaf(int) {}
 
  virtual void leaf(std::string const&) {}
 
  virtual void leaf(double) {}
 
  virtual void leaf(bool) {}
  
  virtual void leaf(std::nullptr_t) {}
 
 
  virtual void before_child(object_t const*, std::string const&,
                            node_t const*) {}
 
  virtual void after_child(object_t const*, std::string const&,
                           node_t const*) {}
  
 
  virtual void before_child(array_t const*, unsigned,
                            node_t const*) {}
 
  virtual void after_child(array_t const*, unsigned,
                           node_t const*) {}
 
  virtual void before_child(node_t const*, uint_or_string_t const&,
                           node_t const*) {}
 
  virtual void after_child(node_t const*, uint_or_string_t const&,
                           node_t const*) {}
 
  /* These functions are called in between */
 
  virtual void between_children(node_t const*) {}
 
  virtual void between_children(object_t const*) {}
  
  virtual void between_children(array_t const*) {}
 
  virtual void leave(node_t const*) {}
 
  virtual void leave(bool_t const*) {}
  virtual void leave(object_t const*) {}
  virtual void leave(array_t const*) {}
  virtual void leave(int_t const*) {}
  virtual void leave(string_t const*) {}
  virtual void leave(float_t const*) {}
  virtual void leave(null_t const*) {}
 
  /* These functions are usually not overriden. */
  inline virtual void visit(bool_t const* node) {visit_leaf(node);}
  inline virtual void visit(int_t const* node) {visit_leaf(node);}
  inline virtual void visit(string_t const* node) {visit_leaf(node);}
  inline virtual void visit(float_t const* node) {visit_leaf(node);}
  inline virtual void visit(null_t const* node) 
  {enter(node); if (!is_stopped()) leaf(nullptr); leave(node);}
 
  virtual void visit(object_t const* node);
  virtual void visit(array_t const* node);
  virtual void visit(node_t const* node);
 
public:
  inline virtual void run(json_ast_t tree) { run (&(*tree)); }
  inline virtual void run(node_t const* node) { visit(node); }
 
  virtual ~visitor_t() = default;
};
 
 
} // end of namespace json
} // end of namespace awali
#endif