stackmap< Key, T, Compare > Struct Template Reference

#include <utils.h>

Collaboration diagram for stackmap< Key, T, Compare >:

Public Member Functions
	stackmap ()
	stackmap (const std::map< Key, T, Compare > &other)
template<typename Other >
void	operator= (const Other &other)
bool	has (const Key &k)
void	set (const Key &k, const T &v)
void	unset (const Key &k)
const T &	get (const Key &k)
void	reset (const Key &k)
const std::map< Key, T, Compare > &	stdmap ()
void	save ()
void	restore ()
	~stackmap ()

Private Attributes
std::vector< std::map< Key, T *, Compare > >	backup_state
std::map< Key, T, Compare >	current_state

Static Private Attributes
static T	empty_tuple

Detailed Description

template<typename Key, typename T, typename Compare = std::less<Key>>
struct stackmap< Key, T, Compare >

Definition at line 35 of file utils.h.

Constructor & Destructor Documentation

template<typename Key, typename T, typename Compare = std::less<Key>>

stackmap< Key, T, Compare >::stackmap ( )

inline

Definition at line 43 of file utils.h.

{ }

template<typename Key, typename T, typename Compare = std::less<Key>>

stackmap< Key, T, Compare >::stackmap ( const std::map< Key, T, Compare > &  other )

inline

Definition at line 44 of file utils.h.

: current_state(other) { }

template<typename Key, typename T, typename Compare = std::less<Key>>

stackmap< Key, T, Compare >::~stackmap ( )

inline

Definition at line 119 of file utils.h.

    {
        while (!backup_state.empty())
            restore();
    }

Member Function Documentation

template<typename Key, typename T, typename Compare = std::less<Key>>

const T& stackmap< Key, T, Compare >::get ( const Key &  k )

inline

Definition at line 77 of file utils.h.

    {
        if (current_state.count(k) == 0)
            return empty_tuple;
        return current_state.at(k);
    }

template<typename Key, typename T, typename Compare = std::less<Key>>

bool stackmap< Key, T, Compare >::has ( const Key &  k )

inline

Definition at line 58 of file utils.h.

    {
        return current_state.count(k) != 0;
    }

template<typename Key, typename T, typename Compare = std::less<Key>>

template<typename Other >

void stackmap< Key, T, Compare >::operator= ( const Other &  other )

inline

Definition at line 47 of file utils.h.

    {
        for (auto &it : current_state)
            if (!backup_state.empty() && backup_state.back().count(it.first) == 0)
                backup_state.back()[it.first] = new T(it.second);
        current_state.clear();

        for (auto &it : other)
            set(it.first, it.second);
    }

template<typename Key, typename T, typename Compare = std::less<Key>>

void stackmap< Key, T, Compare >::reset ( const Key &  k )

inline

Definition at line 84 of file utils.h.

    {
        for (int i = GetSize(backup_state)-1; i >= 0; i--)
            if (backup_state[i].count(k) != 0) {
                if (backup_state[i].at(k) == nullptr)
                    current_state.erase(k);
                else
                    current_state[k] = *backup_state[i].at(k);
                return;
            }
        current_state.erase(k);
    }

template<typename Key, typename T, typename Compare = std::less<Key>>

void stackmap< Key, T, Compare >::restore ( )

inline

Definition at line 107 of file utils.h.

    {
        log_assert(!backup_state.empty());
        for (auto &it : backup_state.back())
            if (it.second != nullptr) {
                current_state[it.first] = *it.second;
                delete it.second;
            } else
                current_state.erase(it.first);
        backup_state.pop_back();
    }

Here is the caller graph for this function:

template<typename Key, typename T, typename Compare = std::less<Key>>

void stackmap< Key, T, Compare >::save ( )

inline

Definition at line 102 of file utils.h.

    {
        backup_state.resize(backup_state.size()+1);
    }

template<typename Key, typename T, typename Compare = std::less<Key>>

void stackmap< Key, T, Compare >::set ( const Key &  k, const T &  v  )

inline

Definition at line 63 of file utils.h.

    {
        if (!backup_state.empty() && backup_state.back().count(k) == 0)
            backup_state.back()[k] = current_state.count(k) ? new T(current_state.at(k)) : nullptr;
        current_state[k] = v;
    }

Here is the caller graph for this function:

template<typename Key, typename T, typename Compare = std::less<Key>>

const std::map<Key, T, Compare>& stackmap< Key, T, Compare >::stdmap ( )

inline

Definition at line 97 of file utils.h.

    {
        return current_state;
    }

template<typename Key, typename T, typename Compare = std::less<Key>>

void stackmap< Key, T, Compare >::unset ( const Key &  k )

inline

Definition at line 70 of file utils.h.

    {
        if (!backup_state.empty() && backup_state.back().count(k) == 0)
            backup_state.back()[k] = current_state.count(k) ? new T(current_state.at(k)) : nullptr;
        current_state.erase(k);
    }

Field Documentation

template<typename Key, typename T, typename Compare = std::less<Key>>

std::vector<std::map<Key, T*, Compare> > stackmap< Key, T, Compare >::backup_state

private

Definition at line 38 of file utils.h.

template<typename Key, typename T, typename Compare = std::less<Key>>

std::map<Key, T, Compare> stackmap< Key, T, Compare >::current_state

private

Definition at line 39 of file utils.h.

template<typename Key, typename T, typename Compare = std::less<Key>>

T stackmap< Key, T, Compare >::empty_tuple

staticprivate

Definition at line 40 of file utils.h.

---

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

• utils.h