MaybeDisplayParent.h

Go to the documentation of this file.

#ifndef fhiclcpp_types_detail_MaybeDisplayParent_h
#define fhiclcpp_types_detail_MaybeDisplayParent_h

#include "cetlib/exempt_ptr.h"
#include "fhiclcpp/detail/Indentation.h"
#include "fhiclcpp/types/detail/ParameterBase.h"

#include <cctype>
#include <sstream>
#include <string>
#include <vector>

//===================================================================================
namespace fhicl::detail {

  using base_ptr = cet::exempt_ptr<ParameterBase>;

  class MaybeDisplayParent {
  public:
    MaybeDisplayParent(ParameterBase const& p,
                       bool const showParents,
                       Indentation& ind)
      : show_{showParents}
      , names_{showParents ? get_parents(p.key()) : std::vector<std::string>{}}
      , indent_{ind}
    {
      std::ostringstream os;

      if (show_) {

        for (auto it = names_.begin(), e = names_.end() - 1; it != e; ++it) {
          std::string const& name = *it;
          std::string const& next_name = *std::next(it);

          // We use the indent_ member so that we can properly
          // update the indentation level.  However, the literal
          // indented string should not include any characters in it
          // for the parents of the parameter in question.
          std::string const indent(indent_().size(), ' ');
          if (!std::isdigit(name[0])) {
            if (std::isdigit(next_name[0])) {
              os << indent << name << ": [  # index: " << next_name << '\n';
              closingBraces_.push_back(indent + "]\n");
            } else {
              os << indent << name << ": {\n";
              closingBraces_.push_back(indent + "}\n");
            }
          } else {
            if (!std::isdigit(next_name[0])) {
              os << indent << "{\n";
              closingBraces_.push_back(indent + "}\n");
            } else {
              os << indent << "[  # index: " << next_name << '\n';
              closingBraces_.push_back(indent + "]\n");
            }
          }
          indent_.push();
        }
      } else {
      }

      fullPayload_ = os.str();
    }

    std::string const&
    parent_names() const
    {
      return fullPayload_;
    }

    std::string
    closing_braces() const
    {
      if (!show_)
        return "";

      std::string result;
      for (auto it = closingBraces_.crbegin(), re = closingBraces_.crend();
           it != re;
           ++it) {
        result.append(*it);
        indent_.pop();
      }
      return result;
    }

  private:
    bool show_;
    std::string fullPayload_{};
    std::vector<std::string> names_;
    std::vector<std::string> closingBraces_{};
    Indentation& indent_;

    std::vector<std::string> get_parents(std::string const& k);

    bool
    is_sequence_element(ParameterBase const& p)
    {
      auto pos = p.key().find_last_of("]");
      return pos != std::string::npos && pos == p.key().size() - 1;
    }
  };
}

#endif /* fhiclcpp_types_detail_MaybeDisplayParent_h */

// Local variables:
// mode: c++
// End: