#include <Vec.h>

Public Member Functions
	vec ()

	vec (int size)

	vec (int size, const T &pad)

	~vec ()

	operator T* (void)

int	size (void) const

void	shrink (int nelems)

void	shrink_ (int nelems)

int	capacity (void) const

void	capacity (int min_cap)

void	prelocate (int ext_cap)

void	growTo (int size)

void	growTo_ (int size)

void	growTo (int size, const T &pad)

void	clear (bool dealloc=false)

void	push (void)

void	push (const T &elem)

void	push_ (const T &elem)

void	pop (void)

const T &	last (void) const

T &	last (void)

const T &	operator[] (int index) const

T &	operator[] (int index)

void	copyTo (vec< T > &copy) const

void	copyTo_ (vec< T > &copy) const

void	moveTo (vec< T > &dest)

Detailed Description

template<class T>
class Gluco2::vec< T >

Definition at line 40 of file Vec.h.

Constructor & Destructor Documentation

◆ vec() [1/3]

template<class T>

Gluco2::vec< T >::vec ( )

inline

Definition at line 56 of file Vec.h.

56: data(NULL) , sz(0) , cap(0) { }

Gluco2::vec

Definition Vec.h:40

◆ vec() [2/3]

template<class T>

Gluco2::vec< T >::vec ( int size )

inlineexplicit

Definition at line 57 of file Vec.h.

57: data(NULL) , sz(0) , cap(0) { growTo(size); }

Gluco2::vec::growTo

void growTo(int size)

Definition Vec.h:126

Gluco2::vec::size

int size(void) const

Definition Vec.h:65

Here is the call graph for this function:

◆ vec() [3/3]

template<class T>

Gluco2::vec< T >::vec	(	int	size,
		const T &	pad )

inline

Definition at line 58 of file Vec.h.

58: data(NULL) , sz(0) , cap(0) { growTo(size, pad); }

Here is the call graph for this function:

◆ ~vec()

template<class T>

Gluco2::vec< T >::~vec ( )

inline

Definition at line 59 of file Vec.h.

59{ clear(true); }

Gluco2::vec::clear

void clear(bool dealloc=false)

Definition Vec.h:141

Here is the call graph for this function:

Member Function Documentation

◆ capacity() [1/2]

template<class T>

void Gluco2::vec< T >::capacity ( int min_cap )

Definition at line 101 of file Vec.h.

                                 {
    if (cap >= min_cap) return;
    int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
    if (add > INT_MAX - cap || (((data = (T*)::realloc((void*)data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM))
        fatal_out_of_memory();
 }

Here is the call graph for this function:

◆ capacity() [2/2]

template<class T>

int Gluco2::vec< T >::capacity ( void ) const

inline

Definition at line 68 of file Vec.h.

68{ return cap; }

Here is the caller graph for this function:

◆ clear()

template<class T>

void Gluco2::vec< T >::clear ( bool dealloc = false )

Definition at line 141 of file Vec.h.

                               {
    if (data != NULL){
        for (int i = 0; i < sz; i++) data[i].~T();
        sz = 0;
        if (dealloc) free(data), data = NULL, cap = 0; } }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyTo()

template<class T>

void Gluco2::vec< T >::copyTo ( vec< T > & copy ) const

inline

Definition at line 94 of file Vec.h.

94{ copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }

Here is the caller graph for this function:

◆ copyTo_()

template<class T>

void Gluco2::vec< T >::copyTo_ ( vec< T > & copy ) const

inline

Definition at line 95 of file Vec.h.

95{ copy.shrink_(copy.size()); copy.growTo_(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }

Gluco2::vec::shrink_

void shrink_(int nelems)

Definition Vec.h:67

Gluco2::vec::growTo_

void growTo_(int size)

Definition Vec.h:134

Here is the caller graph for this function:

◆ growTo() [1/2]

template<class T>

void Gluco2::vec< T >::growTo ( int size )

Definition at line 126 of file Vec.h.

                            {
    if (sz >= size) return;
    capacity(size);
    for (int i = sz; i < size; i++) new (&data[i]) T();
    sz = size; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ growTo() [2/2]

template<class T>

void Gluco2::vec< T >::growTo	(	int	size,
		const T &	pad )

Definition at line 118 of file Vec.h.

                                          {
    if (sz >= size) return;
    capacity(size);
    for (int i = sz; i < size; i++) data[i] = pad;
    sz = size; }

Here is the call graph for this function:

◆ growTo_()

template<class T>

void Gluco2::vec< T >::growTo_ ( int size )

Definition at line 134 of file Vec.h.

                             {
    if (sz >= size) return;
    capacity(size);
    sz = size; }

Here is the call graph for this function:

◆ last() [1/2]

template<class T>

T & Gluco2::vec< T >::last ( void )

inline

Definition at line 87 of file Vec.h.

87{ return data[sz-1]; }

◆ last() [2/2]

template<class T>

const T & Gluco2::vec< T >::last ( void ) const

inline

Definition at line 86 of file Vec.h.

86{ return data[sz-1]; }

Here is the caller graph for this function:

◆ moveTo()

template<class T>

void Gluco2::vec< T >::moveTo ( vec< T > & dest )

inline

Definition at line 96 of file Vec.h.

96{ dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator T*()

template<class T>

Gluco2::vec< T >::operator T* ( void )

inline

Definition at line 62 of file Vec.h.

62{ return data; }

◆ operator[]() [1/2]

template<class T>

T & Gluco2::vec< T >::operator[] ( int index )

inline

Definition at line 91 of file Vec.h.

91{ return data[index]; }

◆ operator[]() [2/2]

template<class T>

const T & Gluco2::vec< T >::operator[] ( int index ) const

inline

Definition at line 90 of file Vec.h.

90{ return data[index]; }

◆ pop()

template<class T>

void Gluco2::vec< T >::pop ( void )

inline

Definition at line 80 of file Vec.h.

80{ assert(sz > 0); sz--, data[sz].~T(); }

assert

#define assert(ex)

Definition util_old.h:213

Here is the caller graph for this function:

◆ prelocate()

template<class T>

void Gluco2::vec< T >::prelocate ( int ext_cap )

Definition at line 109 of file Vec.h.

                                  {
    if (cap >= ext_cap) return;
    if (ext_cap > INT_MAX || (((data = (T*)::realloc((void*)data, ext_cap * sizeof(T))) == NULL) && errno == ENOMEM))
        fatal_out_of_memory();;
    cap = ext_cap;
 }

Here is the call graph for this function:

◆ push() [1/2]

template<class T>

void Gluco2::vec< T >::push ( const T & elem )

inline

Definition at line 78 of file Vec.h.

78{ if (sz == cap) capacity(sz+1); data[sz++] = elem; }

Here is the call graph for this function:

◆ push() [2/2]

template<class T>

void Gluco2::vec< T >::push ( void )

inline

Definition at line 77 of file Vec.h.

77{ if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_()

template<class T>

void Gluco2::vec< T >::push_ ( const T & elem )

inline

Definition at line 79 of file Vec.h.

79{ assert(sz < cap); data[sz++] = elem; }

◆ shrink()

template<class T>

void Gluco2::vec< T >::shrink ( int nelems )

inline

Definition at line 66 of file Vec.h.

66{ assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }

◆ shrink_()

template<class T>

void Gluco2::vec< T >::shrink_ ( int nelems )

inline

Definition at line 67 of file Vec.h.

67{ assert(nelems <= sz); sz -= nelems; }

Here is the caller graph for this function:

◆ size()

template<class T>

int Gluco2::vec< T >::size ( void ) const

inline

Definition at line 65 of file Vec.h.

65{ return sz; }

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

src/sat/glucose2/Vec.h

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ vec() [1/3]

◆ vec() [2/3]

◆ vec() [3/3]

◆ ~vec()

Member Function Documentation

◆ capacity() [1/2]

◆ capacity() [2/2]

◆ clear()

◆ copyTo()

◆ copyTo_()

◆ growTo() [1/2]

◆ growTo() [2/2]

◆ growTo_()

◆ last() [1/2]

◆ last() [2/2]

◆ moveTo()

◆ operator T*()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ pop()

◆ prelocate()

◆ push() [1/2]

◆ push() [2/2]

◆ push_()

◆ shrink()

◆ shrink_()

◆ size()