dgvertex.h

/*
 *  Copyright (C) 2004-2024 Edward F. Valeev
 *
 *  This file is part of Libint compiler.
 *
 *  Libint compiler 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  Libint compiler 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 Libint compiler.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _libint2_src_bin_libint_dgvertex_h_
#define _libint2_src_bin_libint_dgvertex_h_
 
#include <list>
#include <vector>
// #include <dg.h>
#include <dgarc.h>
#include <drtree.h>
#include <exception.h>
#include <global_macros.h>
#include <hashable.h>
#include <key.h>
#include <memory.h>
#include <smart_ptr.h>
 
#include <iostream>
#include <string>
 
namespace libint2 {
 
class DirectedGraph;
 
class DGVertex : public Hashable<KeyTypes::InstanceID, ComputeKey> {
 public:
  typedef MemoryManager::Address Address;
  typedef MemoryManager::Size Size;
  typedef NotSet<Address> AddressNotSet;
  typedef NotSet<std::string> GraphLabelNotSet;
  typedef NotSet<std::string> SymbolNotSet;
  typedef KeyTypes::ClassID ClassID;
  typedef KeyTypes::InstanceID InstanceID;
  typedef KeyTypes::InstanceID KeyType;
  typedef Hashable<KeyType, ComputeKey>::KeyReturnType KeyReturnType;
  typedef std::list<std::shared_ptr<DGArc> > ArcSetType;
 
  ClassID typeid_;
  InstanceID instid_;
  DGVertex(ClassID tid);
  DGVertex(ClassID tid, const std::vector<std::shared_ptr<DGArc> >& parents,
           const std::vector<std::shared_ptr<DGArc> >& children);
  DGVertex(const DGVertex& v);
  virtual ~DGVertex();
 
  void make_a_target();
  bool is_a_target() const { return target_; };
  virtual void add_exit_arc(const std::shared_ptr<DGArc>&);
  virtual void del_exit_arcs();
  void replace_exit_arc(const std::shared_ptr<DGArc>& A,
                        const std::shared_ptr<DGArc>& B);
  void detach();
 
  const ArcSetType& exit_arcs() const { return children_; }
  const ArcSetType& entry_arcs() const { return parents_; }
  unsigned int num_entry_arcs() const;
  ArcSetType::const_iterator first_entry_arc() const {
    return parents_.begin();
  }
  ArcSetType::const_iterator plast_entry_arc() const { return parents_.end(); }
  unsigned int num_exit_arcs() const;
  ArcSetType::const_iterator first_exit_arc() const {
    return children_.begin();
  }
  ArcSetType::const_iterator plast_exit_arc() const { return children_.end(); }
  const std::shared_ptr<DGArc>& exit_arc(
      const std::shared_ptr<DGVertex>& v) const;
 
  virtual KeyReturnType key() const = 0;
  virtual bool equiv(const std::shared_ptr<DGVertex>&) const = 0;
 
  bool precomputed() const;
 
  virtual unsigned int size() const = 0;
 
  virtual const std::string& label() const = 0;
  virtual const std::string& id() const = 0;
  virtual std::string description() const = 0;
  virtual void print(std::ostream& os) const;
 
  const DirectedGraph* dg() const { return dg_; }
  void dg(const DirectedGraph* d) { dg_ = d; }
  const std::string& graph_label() const;
  void set_graph_label(const std::string& graph_label);
 
  const std::shared_ptr<DRTree>& subtree() const { return subtree_; }
 
  //
  // NOTE : the following functions probably belong to a separate class, such as
  // Entity!
  //
 
  void refer_this_to(const std::shared_ptr<DGVertex>& V);
  bool refers_to_another() const { return referred_vertex_ != 0; }
  const std::string& symbol() const;
  void set_symbol(const std::string& symbol);
  bool symbol_set() const;
  void reset_symbol();
  Address address() const;
  void set_address(const Address& address);
  bool address_set() const;
  void need_to_compute(bool ntc);
  void not_need_to_compute() { need_to_compute(false); }
  bool need_to_compute() const;
#if CHECK_SAFETY
  bool declared() const { return precomputed() ? true : declared_; }
  void declared(bool d) { declared_ = d; }
#endif
 
  void prepare_to_traverse();
  unsigned int tag();
  void schedule() { scheduled_ = true; }
  bool scheduled() const { return scheduled_; }
  std::shared_ptr<DGVertex> postcalc() const { return postcalc_; };
  void set_postcalc(const std::shared_ptr<DGVertex>& postcalc) {
    postcalc_ = postcalc;
  };
 
  void reset();
  virtual void unregister() const;
 
 public:
  virtual bool this_precomputed() const = 0;
 
 private:
  const DirectedGraph* dg_;
  std::string graph_label_;
 
  const DGVertex* referred_vertex_;
  std::vector<const DGVertex*> refs_;
  void register_reference(const DGVertex*);
 
  std::string symbol_;
  Address address_;
  // Whether this vertex needs to be computed
  bool need_to_compute_;
#if CHECK_SAFETY
  // has the symbol been declared in the code?
  bool declared_;
#endif
 
  ArcSetType parents_;
  ArcSetType children_;
 
  // Whether this is a "target" vertex, i.e. the target of a calculation
  bool target_;
  // If set to true -- traversal has started and add_entry... cannot be called
  bool can_add_arcs_;
 
  void del_exit_arc(const std::shared_ptr<DGArc>& c);
  void add_entry_arc(const std::shared_ptr<DGArc>&);
  void del_entry_arc(const std::shared_ptr<DGArc>&);
 
  // These members used in traversal and scheduling algorithms
 
  unsigned int num_tagged_arcs_;
  std::shared_ptr<DGVertex> postcalc_;
  bool scheduled_;
 
  // Refback to subtree which contains this vertex
 
  // note that this is a refback (back reference to the "owning" object) so
  // changing it does not change class invariant -- hence mutable
 
  mutable std::shared_ptr<DRTree> subtree_;
  friend void DRTree::add_vertex(const std::shared_ptr<DGVertex>& vertex);
  friend void DRTree::detach_from(const std::shared_ptr<DGVertex>& v);
};
 
//
// Nonmember predicates
//
struct UnrolledIntegralSet {
  bool operator()(const std::shared_ptr<DGVertex>& V);
};
struct NotUnrolledIntegralSet {
  bool operator()(const std::shared_ptr<DGVertex>& V);
};
struct IntegralInTargetIntegralSet {
  bool operator()(const std::shared_ptr<DGVertex>& V);
};
 
inline DGVertexKey key(const DGVertex& v) {
  return DGVertexKey(v.typeid_, v.instid_);
}
 
};  // namespace libint2
 
#endif