proc-id.hpp

Go to the documentation of this file.

/*
  PROC-ID.hpp  -  symbolic and hash identification of processing steps
 
   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 ENGINE_PROC_ID_H
#define ENGINE_PROC_ID_H
 
 
#include "lib/error.hpp"
#include "lib/hash-standard.hpp"
#include "lib/several.hpp"
#include "lib/nocopy.hpp"
 
#include <utility>
#include <string>
 
 
namespace steam {
namespace engine {
  namespace err = lumiera::error;
  
  using std::move;
  using lib::HashVal;
  using std::string;
  using StrView = std::string_view;
  
  class ProcNode;
  
  
  struct ProcAttrib
    {
      bool manifold :1;
      bool isProxy  :1;
      
      ProcAttrib()
        : manifold{true}
        , isProxy{false}
        { }
      
      friend bool
      operator== (ProcAttrib const& l, ProcAttrib const& r)
      {
        return l.manifold == r.manifold
           and l.isProxy  == r.isProxy;
      }
    };
  
  class ProcID
    : util::MoveOnly   // ◁—— you must not create instances, use ProcID::describe()
    {
      StrView nodeName_;
      StrView portQual_;
      StrView argLists_;
      ProcAttrib attrib_;
      
      ProcID (StrView nodeSymb, StrView portQual, StrView argLists, ProcAttrib);
      
      using ProcNodeRef = std::reference_wrapper<ProcNode>;
      using Leads = lib::Several<ProcNodeRef>;
      
    public:
      static ProcID& describe (StrView nodeSymb, StrView portSpec, ProcAttrib extAttrib =ProcAttrib{});
      
      /* === symbolic descriptors === */
      
      string genProcName()       const;
      string genProcSpec()       const;  
      string genQualifier()      const;
      string genNodeName()       const;
      string genNodeSymbol()     const;
      string genNodeDomain()     const;
      string genNodeSpec(Leads&) const;
      string genSrcSpec (Leads&) const;  
      
      struct ArgModel;
      ArgModel genArgModel()     const;
      
      bool hasManifoldPatt()     const { return attrib_.manifold; }
      bool hasProxyPatt()        const { return attrib_.isProxy; }
      
      friend bool
      operator== (ProcID const& l, ProcID const& r)
      {
        return l.nodeName_ == r.nodeName_
           and l.portQual_ == r.portQual_
           and l.argLists_ == r.argLists_
           and l.attrib_   == r.attrib_;
      }
      
      friend bool
      operator!= (ProcID const& l, ProcID const& r)
      { return not (l == r); }
      
      friend HashVal hash_value (ProcID const&);
    };
  
  
  
  struct ProcID::ArgModel
    : util::MoveAssign
    {
      using Strings = lib::Several<const string>;
      using iterator = Strings::iterator;
      
      Strings iArg;
      Strings oArg;
      
      bool empty()      const { return not hasArgs(); };
      bool hasArgs()    const { return hasInArgs() or hasOutArgs();}
      bool hasInArgs()  const { return not iArg.empty(); }
      bool hasOutArgs() const { return not oArg.empty(); }
      uint inArity()    const { return iArg.size(); }
      uint outArity()   const { return oArg.size(); }
      
    private:
      ArgModel (Strings&& iarg, Strings&& oarg)
        : iArg{move (iarg)}
        , oArg{move (oarg)}
        { }
      friend ArgModel ProcID::genArgModel()  const;
    };
  
  
}} // namespace steam::engine
#endif /*ENGINE_PROC_ID_H*/