ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Public Member Functions | List of all members
Gluco::CMap< T > Class Template Reference

#include <SolverTypes.h>

Public Member Functions

void clear ()
 
int size () const
 
void insert (CRef cr, const T &t)
 
void growTo (CRef cr, const T &t)
 
void remove (CRef cr)
 
bool has (CRef cr, T &t)
 
const T & operator[] (CRef cr) const
 
T & operator[] (CRef cr)
 
int bucket_count () const
 
const vec< typename HashTable::Pair > & bucket (int i) const
 
void moveTo (CMap &other)
 
void debug ()
 

Detailed Description

template<class T>
class Gluco::CMap< T >

Definition at line 351 of file SolverTypes.h.

Member Function Documentation

◆ bucket()

template<class T>
const vec< typename HashTable::Pair > & Gluco::CMap< T >::bucket ( int i) const
inline

Definition at line 377 of file SolverTypes.h.

377{ return map.bucket(i); }

◆ bucket_count()

template<class T>
int Gluco::CMap< T >::bucket_count ( ) const
inline

Definition at line 376 of file SolverTypes.h.

376{ return map.bucket_count(); }

◆ clear()

template<class T>
void Gluco::CMap< T >::clear ( )
inline

Definition at line 361 of file SolverTypes.h.

361{ map.clear(); }

◆ debug()

template<class T>
void Gluco::CMap< T >::debug ( )
inline

Definition at line 383 of file SolverTypes.h.

383 {
384 printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
Gluco::CMap::size
int size() const
Definition SolverTypes.h:362
Here is the call graph for this function:

◆ growTo()

template<class T>
void Gluco::CMap< T >::growTo ( CRef cr,
const T & t )
inline

Definition at line 367 of file SolverTypes.h.

367{ map.insert(cr, t); } // NOTE: for compatibility

◆ has()

template<class T>
bool Gluco::CMap< T >::has ( CRef cr,
T & t )
inline

Definition at line 369 of file SolverTypes.h.

369{ return map.peek(cr, t); }

◆ insert()

template<class T>
void Gluco::CMap< T >::insert ( CRef cr,
const T & t )
inline

Definition at line 366 of file SolverTypes.h.

366{ map.insert(cr, t); }

◆ moveTo()

template<class T>
void Gluco::CMap< T >::moveTo ( CMap< T > & other)
inline

Definition at line 380 of file SolverTypes.h.

380{ map.moveTo(other.map); }

◆ operator[]() [1/2]

template<class T>
T & Gluco::CMap< T >::operator[] ( CRef cr)
inline

Definition at line 373 of file SolverTypes.h.

373{ return map[cr]; }

◆ operator[]() [2/2]

template<class T>
const T & Gluco::CMap< T >::operator[] ( CRef cr) const
inline

Definition at line 372 of file SolverTypes.h.

372{ return map[cr]; }

◆ remove()

template<class T>
void Gluco::CMap< T >::remove ( CRef cr)
inline

Definition at line 368 of file SolverTypes.h.

368{ map.remove(cr); }

◆ size()

template<class T>
int Gluco::CMap< T >::size ( ) const
inline

Definition at line 362 of file SolverTypes.h.

362{ return map.elems(); }
Here is the caller graph for this function:
The documentation for this class was generated from the following file: