gen-node.hpp

Go to the documentation of this file.

/*
  GEN-NODE.hpp  -  generic node element for tree like data representation

  Copyright (C)         Lumiera.org
    2015,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  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, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef LIB_DIFF_GEN_NODE_H
#define LIB_DIFF_GEN_NODE_H


#include "lib/error.hpp"
#include "lib/idi/entry-id.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/diff/record.hpp"
#include "lib/variant.hpp"
#include "lib/util.hpp"

#include <optional>
#include <utility>
#include <string>
#include <deque>

namespace lib {
namespace diff{
  
  namespace error = lumiera::error;
  
  struct GenNode;
  struct Ref;
  
  template<>
  struct RecordSetup<GenNode>
    {
      using Storage = std::vector<GenNode>;
      using ElmIter = typename Storage::const_iterator;
      
      using Access  = GenNode const&;
    };
  
  
  
  
  using Rec = Record<GenNode>;
  using RecRef = RecordRef<GenNode>;
  using MakeRec = Rec::Mutator;
  using DataValues = meta::Types<int
                                ,int64_t
                                ,short
                                ,char
                                ,bool
                                ,double
                                ,string
                                ,time::Time
                                ,time::Offset
                                ,time::Duration
                                ,time::TimeSpan
                                ,hash::LuidH
                                ,RecRef
                                ,Rec
                                >;
  
  
  
  class DataCap
    : public Variant<DataValues>
    {
    public:
      template<typename X>
      DataCap(X&& x)
        : Variant<DataValues>(std::forward<X>(x))
        { }
      
      DataCap(DataCap const&) =default;
      DataCap(DataCap&&)      =default;
      DataCap(DataCap& o)
        : DataCap((DataCap const&)o)
        { }
      
      DataCap& operator= (DataCap const&)  =default;
      DataCap& operator= (DataCap&&)       =default;
      
      bool matchData (DataCap const&)  const;
      bool matchNum  (int64_t)         const;
      bool matchTxt  (string const&)   const;
      bool matchTime (time::TimeValue) const;
      bool matchBool (bool)            const;
      bool matchDbl  (double)          const;
      bool matchLuid (hash::LuidH)     const;
      bool matchRec  (RecRef const&)   const;
      bool matchRec  (Rec const&)      const;
      
      struct Locator;
      Locator expand()  const;
      
      operator string() const;
      
      template<typename X>
      X& get();
      template<typename X>
      X const& get()  const;
      
      Rec::scopeIter
      childIter()  const
        {
          const Rec* rec = unConst(this)->maybeGet<Rec>();
          if (!rec)
            return Rec::scopeIter();
          else
            return rec->scope();
        }
      
      bool isNested()  const;
      
      string recordType()  const;
      
      template<typename X>
      std::optional<X>
      retrieveAttribute (string key)  const;
      
      bool hasAttribute (string key)  const;
      
    private:
      Rec* maybeAccessNestedRec();
    };
  
  
  struct GenNode
    {
      class ID
        : public idi::BareEntryID
        {
          friend struct GenNode;
          
          template<typename X>
          ID (X*, string const& symbolicID)
            : idi::BareEntryID (symbolicID,
                                idi::getTypeHash<X>())
            { }
          
          ID (idi::BareEntryID&& rawD)
            : idi::BareEntryID{move (rawD)}
            { }
          
        public:
          explicit
          ID (GenNode const& node)
            : ID(node.idi)
            { }
          
          // standard copy operations acceptable
          
          operator string()  const
            {
              return "ID(\""+getSym()+"\")";
            }
        };
      
      
      //------GenNode Data fields---
      
      ID      idi;
      DataCap data;
      
      
      template<typename X>
      GenNode(X&& val)
        : idi(&val, buildChildID<X>())
        , data(std::forward<X>(val))
        { }
      
      template<typename X>
      GenNode(string const& symbolicID, X&& val)
        : idi(&val, symbolicID)
        , data(std::forward<X>(val))
        { }
      
      GenNode(string const& symbolicID, const char* text)
        : GenNode(symbolicID, string(text))
        { }
      
      GenNode(const char* text)
        : GenNode(string(text))
        { }
      
      GenNode(GenNode const&)  =default;
      GenNode(GenNode&&)       =default;
      GenNode(GenNode& o)  : GenNode((GenNode const&)o) { }
      GenNode(Ref const& r);
      GenNode(Ref &  r);
      GenNode(Ref && r);
      
      GenNode&
      operator= (GenNode const& o)
        {
          if (&o != this)
            {
              data = o.data;
              idi = o.idi;
            }
          return *this;
        }
      
      GenNode&
      operator= (GenNode&& o)
        {
          ASSERT (&o != this);
          data = std::forward<DataCap>(o.data);
          idi  = std::forward<ID>(o.idi);
          return *this;
        }
      
      //note: NOT defining a swap operation, because swapping inline storage is pointless!
      
      
      
      
      operator string()  const
        {
          return "GenNode-"+string(idi)+"-"+string(data);
        }
      
      bool
      isNamed()  const
        {
          return not util::startsWith (idi.getSym(), "_CHILD_");
        }
      
      bool
      isTypeID()  const
        {
          return "type" == idi.getSym();
        }
      
      template<typename X>
      bool contains (X const& elm)  const;
      
      
      bool matches (GenNode const& o)  const { return this->matches(o.idi); }  
      bool matches (ID const& id)      const { return idi == id;            }
      bool matches (int     number)    const { return data.matchNum(number);}
      bool matches (int64_t number)    const { return data.matchNum(number);}
      bool matches (short   number)    const { return data.matchNum(number);}
      bool matches (char    number)    const { return data.matchNum(number);}
      bool matches (double  number)    const { return data.matchDbl(number);}
      bool matches (string text)       const { return data.matchTxt(text);}
      bool matches (const char* text)  const { return data.matchTxt(text);}
      bool matches (time::TimeValue t) const { return data.matchTime(t);  }
      bool matches (bool b)            const { return data.matchBool(b);  }
      bool matches (hash::LuidH h)     const { return data.matchLuid(h);  }
      bool matches (RecRef const& ref) const { return data.matchRec(ref); }
      bool matches (Rec const& rec)    const { return data.matchRec(rec); }
      
      class ScopeExplorer;
      
      struct ScopeExplorerIterator;
      using iterator = ScopeExplorerIterator;
      
      iterator begin()      ;
      iterator begin() const;
      iterator end()        ;
      iterator end()   const;
      
      
      using ChildDataIter = TransformIter<Rec::scopeIter, DataCap const&>;
      
      friend ChildDataIter
      childData (GenNode const& n)
      {
        return ChildDataIter{ n.data.childIter()
                            , [](GenNode const& child) ->DataCap const&
                                {
                                  return child.data;
                                }
                            };
      }
      
      friend ChildDataIter
      childData (Rec::scopeIter&& scopeIter)
      {
        return ChildDataIter{ std::forward<Rec::scopeIter>(scopeIter)
                            , [](GenNode const& child) ->DataCap const&
                                {
                                  return child.data;
                                }
                            };
      }
      
      
      friend string
      name (GenNode const& node)
      {
        return node.idi.getSym();
      }
      
      friend bool
      operator== (GenNode const& n1, GenNode const& n2)
      {
        return n1.idi == n2.idi
            && n1.data.matchData(n2.data);
      }
      
      friend bool
      operator!= (GenNode const& n1, GenNode const& n2)
      {
        return not (n1 == n2);
      }
      
      struct IDComparator
        {
          bool
          operator() (GenNode const& left, GenNode const& right)  const
            {
              return left.idi.getSym() < right.idi.getSym();
            }
        };
      
      template<typename X>
      static GenNode
      asAttribute (idi::BareEntryID && rawID, X&& payload)
        {
          return GenNode{ID{move (rawID)}, DataCap{forward<X> (payload)}};
        }
      
      template<typename X>
      std::optional<X>
      retrieveAttribute (string key)  const;
      
      bool hasAttribute (string key)  const;
      bool isNested()                 const;
      bool hasChildren()              const;
      Rec::scopeIter getChildren()    const;

      
      
    protected:
      GenNode (ID&& id, DataCap&& d)
        : idi(std::move(id))
        , data(std::move(d))
        { }
      
      template<typename X>
      static GenNode::ID
      fabricateRefID (string const& symbolicID)
        {
          X* typeID(0);
          return ID(typeID, symbolicID);
        }
      
    private:
      template<typename X>
      static string
      buildChildID()
        {
          return "_CHILD_" + idi::generateSymbolicID<X>();
        }
    };
  
  
  string renderCompact (GenNode const&);
  string renderCompact (RecRef const&);
  string renderCompact (Rec const&);
  
  
  
  
  
  
  template<typename ELM>
  struct can_wrap_in_GenNode
    {
      using Yes = lib::meta::Yes_t;
      using No  = lib::meta::No_t;
      
      template<class X>
      static Yes check(typename variant::CanBuildFrom<X, DataValues>::Type*);
      template<class X>
      static No  check(...);
      
    public:
      static const bool value = (sizeof(Yes)==sizeof(check<ELM>(0)));
    };
  
  
  
  
  /* === iteration / recursive expansion === */
  
  
  struct DataCap::Locator
    {
      const GenNode* node_;
      Rec::iterator scope_;
      
      Locator()
        : node_(nullptr)
        { }
      
      Locator(GenNode const& n)
        : node_(&n)
        { }
      
      Locator(Rec const& r)
        : node_(nullptr)
        , scope_(r.begin())
        { }
      
      const GenNode *
      get()  const
        {
          return node_? node_
                      : scope_? scope_.operator->()
                              : nullptr;
        }
      
      /* === Iteration control API for IterStateWrapper == */
      
      bool
      checkPoint()  const
        {
          return this->get();
        }
      
      GenNode const&
      yield()  const
        {
          return *get();
        }
      
      void
      iterNext()
        {
          if (node_)
            node_ = nullptr;
          else
            ++scope_;
        }
    };
  
  
  class GenNode::ScopeExplorer
    {
      using ScopeIter = IterStateWrapper<const GenNode, DataCap::Locator>;
      
      std::deque<ScopeIter> scopes_;
      
    public:
      ScopeExplorer() { }
      ScopeExplorer(GenNode const& n)
        {
          scopes_.emplace_back(n);
        }
      
      size_t
      depth()  const
        {
          return scopes_.size();
        }
      
      /* === Iteration control API for IterStateWrapper == */
      
      bool
      checkPoint()  const
        {
          return not  scopes_.empty()
             and bool(scopes_.back());
        }
      
      GenNode const&
      yield()  const
        {
          return *(scopes_.back());
        }
      
      void
      iterNext()
        {
          ScopeIter& current = scopes_.back();
          scopes_.emplace_back (current->data.expand());
          ++current;
          while (not scopes_.empty() and not scopes_.back())
            scopes_.pop_back();
        }
      
      friend bool
      operator== (ScopeExplorer const& s1, ScopeExplorer const& s2)
      {
        return not s1.scopes_.empty()
            && not s2.scopes_.empty()
            && s1.scopes_.size() == s2.scopes_.size()
            && s1.yield() == s2.yield();
      }
    };
  
  
  inline DataCap::Locator
  DataCap::expand()  const
  {
    Rec* val = unConst(this)->maybeGet<Rec>();
    if (!val)
      return Locator();
    else
      return Locator(*val);
  }
  
  
  struct GenNode::ScopeExplorerIterator
    : IterStateWrapper<const GenNode, ScopeExplorer>
    {
      using IterStateWrapper<const GenNode, ScopeExplorer>::IterStateWrapper;
      
      size_t level()  const { return unConst(this)->stateCore().depth(); }
    };
  
  
  inline GenNode::iterator GenNode::begin()        { return iterator(*this); }
  inline GenNode::iterator GenNode::begin() const  { return iterator(*this); }
  inline GenNode::iterator GenNode::end()          { return iterator(); }
  inline GenNode::iterator GenNode::end()   const  { return iterator(); }
  
  template<typename X>
  inline bool
  GenNode::contains (X const& elm)  const
  {
    for (auto & n : *this)
      if (n.matches(elm))
        return true;
    return false;
  }
  
  
  
  
  /* === References : special treatment on element access === */
  
  template<typename X>
  inline X&
  DataCap::get()
  {
    return Variant<DataValues>::get<X>();
  }
  
  template<typename X>
  inline X const&
  DataCap::get()  const
  {
    return Variant<DataValues>::get<X>();
  }
  
  template<>
  inline Rec&
  DataCap::get()
  {
    Rec* rec = maybeGet<Rec>();
    if (rec) return *rec;
    
    return Variant<DataValues>::get<RecRef>();
  }
  
  template<>
  inline Rec const&
  DataCap::get()  const
  {
    Rec* rec = unConst(this)->maybeGet<Rec>();
    if (rec) return *rec;
    
    return Variant<DataValues>::get<RecRef>();
  }
  
  inline Rec*
  DataCap::maybeAccessNestedRec()
  {
    Rec* nested = maybeGet<Rec>();
    if (!nested)
      { // 2nd try: maybe we hold a reference?
        RecRef* ref = maybeGet<RecRef>();
        if (ref and not ref->empty())
          nested = ref->get();
      }
    return nested;
  }
  
  inline string
  DataCap::recordType()  const
  {
    Rec* nested = unConst(this)->maybeAccessNestedRec();
    return nested? nested->getType()
                 : util::BOTTOM_INDICATOR;
  }
  
  inline bool
  DataCap::isNested()  const
  {
    return nullptr != unConst(this)->maybeAccessNestedRec();
  }
  
  
  template<typename X>
  inline std::optional<X>
  DataCap::retrieveAttribute (string key)  const
  {
    static_assert (not std::is_reference_v<X>
                  ,"optional access only possible by value");
    
    Rec* nested = unConst(this)->maybeAccessNestedRec();
    if (nested and nested->hasAttribute (key))
      {
        DataCap const& nestedAttributeData = nested->get(key).data;
        X* payload = unConst(nestedAttributeData).maybeGet<X>();
        if (payload) return *payload;  // Note: payload copied into optional
      }
    return std::nullopt;
  }
  
  inline bool
  DataCap::hasAttribute (string key)  const
  {
    Rec* nested = unConst(this)->maybeAccessNestedRec();
    return nested and nested->hasAttribute (key);
  }
  
  template<typename X>
  inline std::optional<X>
  GenNode::retrieveAttribute (string key)  const
  {
    return data.retrieveAttribute<X> (key);
  }
  
  inline bool
  GenNode::hasAttribute (string key)  const
  {
    return data.hasAttribute (key);
  }
  
  inline bool
  GenNode::isNested()  const
  {
    return data.isNested();
  }
  
  inline bool
  GenNode::hasChildren()  const
  {
    return not isnil (data.childIter());
  }
  
  inline Rec::scopeIter
  GenNode::getChildren()  const
  {
    return data.childIter();
  }

  
  
  
  
  
  struct Ref
    : GenNode
    {
      explicit
      Ref(string const& symbolicID)
        : GenNode(fabricateRefID<Rec> (symbolicID)//note: seeds the type hash with Rec, not RecRef
                 , DataCap(RecRef()))            // note: places NIL into the reference part
        { }
      
      Ref(GenNode& oNode)
        : GenNode(ID(oNode)
                 , DataCap(RecRef(oNode.data.get<Rec>())))
        { }
      
      static const Ref I;       
      static const Ref NO;      
      static const Ref END;     
      static const Ref THIS;    
      static const Ref CHILD;   
      static const Ref ATTRIBS; 
    };
  
  
  // slice down on copy construction...
  inline GenNode::GenNode(Ref const& r)  : idi(r.idi), data(r.data)   { }
  inline GenNode::GenNode(Ref &  r)      : idi(r.idi), data(r.data)   { }
  inline GenNode::GenNode(Ref && r)      : idi(std::move(r.idi)),
                                           data(std::move(r.data))    { }

  
  /* === Specialisation to add fluent GenNode builder API to Record<GenNode> === */
  
  template<>
  inline GenNode
  MakeRec::genNode()
  {
    return GenNode{std::move(record_)};
  }
  
  template<>
  inline GenNode
  MakeRec::genNode (idi::BareEntryID rawID)
  {
    return GenNode::asAttribute (std::move(rawID), std::move(record_));
  }
  
  template<>
  inline GenNode
  MakeRec::genNode (string const& symbolicID)
  {
    return GenNode{symbolicID, std::move(record_)};
  }
  
  
  /* === Extension point to apply a tree-diff === */
  
  template<>
  void MakeRec::buildMutator (BufferHandle buff);
  
  
  
  /* === Specialisation for handling of attributes in Record<GenNode> === */
  
  template<>
  inline bool
  Rec::isAttribute (GenNode const& attrib)
  {
    return attrib.isNamed();
  }
  
  template<>
  inline bool
  Rec::isTypeID (GenNode const& attrib)
  {
    return attrib.isTypeID();
  }
  
  template<>
  inline string
  Rec::extractTypeID (GenNode const& v)
  {
    return isTypeID(v)? v.data.get<string>()
                      : Rec::TYPE_NIL;
  }
  
  template<>
  inline string
  Rec::extractKey (GenNode const& v)
  {
    return isAttribute(v)? v.idi.getSym()
                         : "";
  }
  
  template<>
  inline GenNode const&
  Rec::extractVal (GenNode const& v)
  {
    return v;
  }
  
  template<>
  inline string
  Rec::renderAttribute (GenNode const& a)
  {
    return a.idi.getSym() +" = "+ string(a.data);
  }
  
  template<>
  template<typename X>
  inline GenNode
  Rec::buildAttribute (string const& key, X&& payload)
  {
    return GenNode{key, forward<X>(payload)};
  }
  
  
  
}// namespace lib::diff

namespace variant {
    using diff::Rec;
    
    template<typename TYPES>
    struct CanBuildFrom<diff::MakeRec, Node<Rec, TYPES>>
      : std::true_type
      {
        using Type = Rec;
      };

}} // namespace lib::variant
#endif /*LIB_DIFF_GEN_NODE_H*/