text-template-gen-node-binding.hpp

Go to the documentation of this file.

/*
  TEXT-TEMPLATE-GEN-NODE-BINDING.hpp  -  data binding adapter for ETD

   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** 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 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef LIB_TEXT_TEMPLATE_GEN_NODE_BINDING_H
#define LIB_TEXT_TEMPLATE_GEN_NODE_BINDING_H


#include "lib/diff/gen-node.hpp"
#include "lib/text-template.hpp"

#include <string>


namespace lib {
  
  using std::string;
  
  
  namespace text_template {
    
    /* ======= Data binding for GenNode (ETD) ======= */
    
    template<>
    struct DataSource<diff::GenNode>
      {
        using Node = diff::GenNode;
        using Rec  = diff::Rec;
        
        Node const* data_;
        DataSource* parScope_;
        bool isSubScope() { return bool(parScope_); }
        
        DataSource(Node const& root)
          : data_{&root}
          , parScope_{nullptr}
          { }
        
        
        using Value = std::string;
        using Iter = Rec::scopeIter;
        
        Node const*
        findNode (string key)
          {
            if (data_->isNested())
              {// standard case: Attribute lookup
                Rec const& record = data_->data.get<Rec>();
                if (record.hasAttribute (key))
                  return & record.get (key);
              }
            else
            if ("value" == key) // special treatment for a »pseudo context«
              return data_;    //  comprised only of a single value node
             // ask parent scope...
            if (isSubScope())
              return parScope_->findNode (key);
            
            return nullptr;
          }
        
        bool
        contains (string key)
          {
            return bool(findNode (key));
          }
        
        Value
        retrieveContent (string key)
          {
            return renderCompact (*findNode(key));
          }
        
        Iter
        getSequence (string key)
          {
            if (not contains(key))
              return Iter{};
            Node const* node = findNode (key);
            if (not node->isNested())
              return Iter{};
            else
              return node->data.get<Rec>().scope();
          }
        
        DataSource
        openContext (Iter& iter)
          {
            REQUIRE (iter);
            DataSource nested{*this};
            nested.parScope_ = this;
            nested.data_ = & *iter;
            return nested;
          }
      };
    
  }// namespace text_template
  
}// namespace lib
#endif /*LIB_TEXT_TEMPLATE_GEN_NODE_BINDING_H*/