## Class tag_processor_v1

zeep::http::tag_processor_v1 — A tag_processor compatible with the old version of libzeep. Works on tags only, not on attributes. Also parses any occurrence of ${}. For newer code, please consider using the v2 version only.

## Synopsis

    // In header: <zeep/http/tag-processor.hpp>

    class tag_processor_v1 : public zeep::http::tag_processor {
    public:
      // construct/copy/destruct
      tag_processor_v1(const char * = tag_processor_v1::ns());

      // public static functions
      static constexpr const char * ns();

      // public member functions
      virtual void
      process_xml(xml::node *, const scope &, std::filesystem::path,
                  basic_template_processor &);

      // protected member functions
      virtual void
      process_tag(const std::string &, xml::element *, const scope &,
                  std::filesystem::path, basic_template_processor &);

      // private member functions
      void process_include(xml::element *, const scope &, std::filesystem::path,
                           basic_template_processor &);
      void process_if(xml::element *, const scope &, std::filesystem::path,
                      basic_template_processor &);
      void process_iterate(xml::element *, const scope &, std::filesystem::path,
                           basic_template_processor &);
      void process_for(xml::element *, const scope &, std::filesystem::path,
                       basic_template_processor &);
      void process_number(xml::element *, const scope &, std::filesystem::path,
                          basic_template_processor &);
      void process_options(xml::element *, const scope &, std::filesystem::path,
                           basic_template_processor &);
      void process_option(xml::element *, const scope &, std::filesystem::path,
                          basic_template_processor &);
      void process_checkbox(xml::element *, const scope &, std::filesystem::path,
                            basic_template_processor &);
      void process_url(xml::element *, const scope &, std::filesystem::path,
                       basic_template_processor &);
      void process_param(xml::element *, const scope &, std::filesystem::path,
                         basic_template_processor &);
      void process_embed(xml::element *, const scope &, std::filesystem::path,
                         basic_template_processor &);
      bool process_el(const scope &, std::string &);
    };

## Description

### `tag_processor_v1` public construct/copy/destruct

1.     tag_processor_v1(const char * ns = tag_processor_v1::ns());

   constructor

   By default the namespace for the v1 processor is the one in ns()

### `tag_processor_v1` public static functions

1.     static constexpr const char * ns();

   default namespace for this processor

### `tag_processor_v1` public member functions

1.     virtual void
       process_xml(xml::node * node, const scope & scope, std::filesystem::path dir,
                   basic_template_processor & loader);

   actual implementation of the tag processing.

### `tag_processor_v1` protected member functions

1.     virtual void
       process_tag(const std::string & tag, xml::element * node, const scope & scope,
                   std::filesystem::path dir, basic_template_processor & loader);

### `tag_processor_v1` private member functions

1.     void process_include(xml::element * node, const scope & scope,
                            std::filesystem::path dir,
                            basic_template_processor & loader);

   handler for mrs:include tags

2.     void process_if(xml::element * node, const scope & scope,
                       std::filesystem::path dir, basic_template_processor & loader);

3.     void process_iterate(xml::element * node, const scope & scope,
                            std::filesystem::path dir,
                            basic_template_processor & loader);

4.     void process_for(xml::element * node, const scope & scope,
                        std::filesystem::path dir,
                        basic_template_processor & loader);

5.     void process_number(xml::element * node, const scope & scope,
                           std::filesystem::path dir,
                           basic_template_processor & loader);

6.     void process_options(xml::element * node, const scope & scope,
                            std::filesystem::path dir,
                            basic_template_processor & loader);

7.     void process_option(xml::element * node, const scope & scope,
                           std::filesystem::path dir,
                           basic_template_processor & loader);

8.     void process_checkbox(xml::element * node, const scope & scope,
                             std::filesystem::path dir,
                             basic_template_processor & loader);

9.     void process_url(xml::element * node, const scope & scope,
                        std::filesystem::path dir,
                        basic_template_processor & loader);

10.     void process_param(xml::element * node, const scope & scope,
                           std::filesystem::path dir,
                           basic_template_processor & loader);

11.     void process_embed(xml::element * node, const scope & scope,
                           std::filesystem::path dir,
                           basic_template_processor & loader);

12.     bool process_el(const scope & scope, std::string & s);