CDegreeCache.h

Go to the documentation of this file.

// -*- c++ -*-
//*****************************************************************************
//*****************************************************************************

#ifndef polybori_cache_CDegreeCache_h_
#define polybori_cache_CDegreeCache_h_ 

// include basic definitions
#include <polybori/pbori_defs.h>
#include <polybori/BooleEnv.h>

#include "CCacheManagement.h"

BEGIN_NAMESPACE_PBORI
//class BoolePolyRing;
template <class NaviType>
class CIndexHandle {
public:

  enum { invalid  = CTypes::max_idx };

  typedef NaviType navigator;

  typedef navigator base;

  typedef typename navigator::bool_type bool_type;

  typedef typename CTypes::idx_type idx_type;

  typedef typename CTypes::size_type size_type;

  typedef BoolePolyRing manager_type;

  CIndexHandle(idx_type idx): m_idx(idx) {}

  explicit CIndexHandle(navigator navi, const manager_type& mgr): 
    m_idx(fromNode(navi, mgr)) {}

  idx_type operator*() const {
    return m_idx;
  }

  bool isValid() const {
    return (m_idx != invalid);
  }
protected:
  idx_type fromNode(navigator navi, const manager_type& mgr) const {

    if (!navi.isValid())
      return invalid;

    if PBORI_UNLIKELY(navi.isConstant())
      return mgr.nVariables();
    else 
      return *navi;
  }



  idx_type m_idx;
};


template <class NaviType>
class CIndexCacheHandle {
public:

  typedef NaviType navigator;

  //  typedef navigator base;

  typedef typename navigator::bool_type bool_type;

  typedef typename navigator::value_type idx_type;

  typedef typename navigator::size_type size_type;

  typedef BoolePolyRing manager_type;

  CIndexCacheHandle(idx_type idx, const manager_type& mgr):
    m_navi( toNode(idx, mgr) ) {}

  explicit CIndexCacheHandle(navigator navi): 
    m_navi(navi) {}

  operator navigator() const { return m_navi; }

protected:
  navigator toNode(idx_type idx, const manager_type& mgr) const {

    if PBORI_LIKELY((size_type)idx < mgr.nVariables())
               return  mgr.variable(idx).set().navigation();

    return  mgr.zero().navigation();
  }

  navigator m_navi;
};

template <class DDType>
class CDegreeCache:
  public CCacheManagement<BoolePolyRing, typename CCacheTypes::degree, 1> {
  typedef CDegreeCache self;
public:

  typedef DDType dd_type;
  typedef typename CCacheTypes::degree tag_type;
  typedef CCacheManagement<BoolePolyRing, tag_type, 1> base;


  typedef typename base::node_type input_node_type;
  typedef typename base::manager_type manager_type;
  typedef typename dd_type::navigator navi_type;
  typedef CIndexHandle<navi_type> node_type;
  typedef CIndexCacheHandle<navi_type> node_cache_type;

  CDegreeCache(const manager_type& mgr): base(mgr) {}

  CDegreeCache(const self& rhs): base(rhs) {}

  ~CDegreeCache() {}

  node_type find(input_node_type navi) const{ 
    return node_type(base::find(navi), base::manager()); }

  node_type find(navi_type navi) const{ 
    return node_type(base::find(navi), base::manager()); }

  void insert(input_node_type navi, deg_type deg) const {
    base::insert(navi, node_cache_type(deg, base::manager()));
  }

  void insert(navi_type navi, deg_type deg) const {
    base::insert(navi, node_cache_type(deg, base::manager()));
  }
  node_type find(input_node_type navi, deg_type) const { return self::find(navi); }

  node_type find(navi_type navi, deg_type) const{ return self::find(navi); }

  void insert(input_node_type navi, deg_type, deg_type deg) const {
    self::insert(navi, deg);
  }

  void insert(navi_type navi, deg_type, deg_type deg) const {
    self::insert(navi, deg);
  }

};

template <class DDType>
class CBoundedDegreeCache:
  public CCacheManagement<BoolePolyRing, typename CCacheTypes::degree, 2> {
  typedef CBoundedDegreeCache self;
public:

  typedef DDType dd_type;
  typedef typename CCacheTypes::degree tag_type;
  typedef CCacheManagement<BoolePolyRing, tag_type, 2> base;


  typedef typename base::node_type input_node_type;
  typedef typename base::manager_type manager_type;
  typedef typename dd_type::navigator navi_type;
  typedef CIndexHandle<navi_type> node_type;
  typedef CIndexCacheHandle<navi_type> node_cache_type;

  CBoundedDegreeCache(const manager_type& mgr): base(mgr) {}

  CBoundedDegreeCache(const self& rhs): base(rhs) {}

  ~CBoundedDegreeCache() {}

  node_type find(input_node_type navi, deg_type upper_bound) const{ 
    return node_type(base::find(navi,  
                                node_cache_type(upper_bound, base::manager())),
                     base::manager()); 
  }

  node_type find(navi_type navi, deg_type upper_bound) const{ 
    return node_type(base::find(navi,  
                                node_cache_type(upper_bound, base::manager())),
                     base::manager()); 
  }

  void insert(input_node_type navi, deg_type upper_bound, deg_type deg) const {
    base::insert(navi, node_cache_type(upper_bound, base::manager()),
                 node_cache_type(deg, base::manager()));
  }

  void insert(navi_type navi, deg_type upper_bound, deg_type deg) const {
    base::insert(navi, node_cache_type(upper_bound, base::manager()),
                 node_cache_type(deg, base::manager()));
  }

};


template <class DDType>
class CBlockDegreeCache:
  public CCacheManagement<BoolePolyRing, 
                          typename CCacheTypes::block_degree, 2> {

public:

  typedef DDType dd_type;
  typedef typename CCacheTypes::block_degree tag_type;
  typedef CCacheManagement<BoolePolyRing, tag_type, 2> base;
  typedef CBlockDegreeCache<dd_type> self;


  typedef typename base::node_type input_node_type;
  typedef typename base::manager_type manager_type;
  typedef typename dd_type::navigator navi_type;
  typedef CIndexHandle<navi_type> node_type;
  typedef CIndexCacheHandle<navi_type> node_cache_type;

  CBlockDegreeCache(const manager_type& mgr): base(mgr) {}

  CBlockDegreeCache(const self& rhs): base(rhs) {}

  ~CBlockDegreeCache() {}

  node_type find(input_node_type navi, idx_type idx) const{ 
    return node_type(base::find(navi, node_cache_type(idx, base::manager())), 
                     base::manager()); }

  node_type find(navi_type navi, idx_type idx) const{ 
    return node_type(base::find(navi, node_cache_type(idx, base::manager())), 
                     base::manager()); }

  void insert(input_node_type navi, idx_type idx, size_type deg) const {
    base::insert(navi, node_cache_type(idx, base::manager()), 
                 node_cache_type(deg, base::manager()));
  }

  void insert(navi_type navi, idx_type idx, size_type deg) const {
    base::insert(navi, node_cache_type(idx, base::manager()), 
                 node_cache_type(deg, base::manager()));
  }
};

template <class TagType, 
          class DDType>
class CDegreeArgumentCache:
  public CCacheManagement<BoolePolyRing, TagType, 2>,
  public CAuxTypes {

public:

  typedef DDType dd_type;
  typedef TagType tag_type;
  typedef CCacheManagement<BoolePolyRing, tag_type, 2> base;
  typedef CDegreeArgumentCache<tag_type, dd_type> self;


  typedef typename base::node_type node_type;
  typedef typename base::manager_type manager_type;
  typedef typename dd_type::navigator navi_type;
  typedef CIndexCacheHandle<navi_type> degree_node_type;

  CDegreeArgumentCache(const manager_type& mgr): base(mgr) {}

  CDegreeArgumentCache(const self& rhs): base(rhs) {}

  ~CDegreeArgumentCache() {}

  navi_type find(navi_type navi, size_type deg) const{ 
    return base::find(navi, degree_node_type(deg, base::manager())); 
  }

  void insert(navi_type navi, size_type deg, navi_type result) const {
    base::insert(navi, degree_node_type(deg, base::manager()), result);
  }

};


END_NAMESPACE_PBORI

#endif

---