Versioned< T, _Strategy > Class Template Reference

Wrapper to make any class Versioned. More...

#include <versioned.h>

Inheritance diagram for Versioned< T, _Strategy >:

Collaboration diagram for Versioned< T, _Strategy >:

Public Member Functions
	Versioned (const T &val)
	Construct a new Versioned object from your object. More...
	~Versioned ()
	Destroy the Versioned object. More...
const T &	Get () const
	Get the current value of the object in the current Revision. More...
bool	Set (const T &v, const std::function< bool(T &)> &updater=nullptr)
	Set new value of the object. More...
void	Release (std::shared_ptr< Segment > release) override
	Forget version that was changed in some Segment. More...
void	Collapse (std::shared_ptr< Revision > main, std::shared_ptr< Segment > parent) override
	Collapse all changes made in Revision into one. More...
void	Merge (std::shared_ptr< Revision > main, std::shared_ptr< Revision > joinRev, std::shared_ptr< Segment > join) override
	Merge changes from two Revisions. More...

Public Attributes
std::map< int, T >	versions
	Map of all versions of specified object. More...

Detailed Description

template<class T, typename _Strategy = DefaultMergeStrategy<T>>
class Versioned< T, _Strategy >

Wrapper to make any class Versioned.

Template Parameters

T	Class that needs to be versioned

Definition at line 53 of file versioned.h.

Constructor & Destructor Documentation

Versioned()

template<class T , typename _Strategy >

Versioned< T, _Strategy >::Versioned

(

const T &

val

)

Construct a new Versioned object from your object.

Parameters

val	Your object

Definition at line 163 of file versioned.h.

                                            {
    Set(Revision::currentRevision, v);
}

~Versioned()

template<class T , typename _Strategy >

Versioned< T, _Strategy >::~Versioned

inline

Destroy the Versioned object.

Removes all mentions of that versioned object in current Revision

Definition at line 168 of file versioned.h.

{
    std::shared_ptr<Segment> s = Revision::currentRevision->current;
 
    while (s) {
        if (versions.find(s->version) != versions.end()) {
            for (auto it = s->written.begin(); it != s->written.end();){
                if (*it == this)
                    it = s->written.erase(it);
                else
                    it++;
            }
        }
        s = s->parent;
    }
}

Member Function Documentation

Collapse()

template<class T , typename _Strategy >

void Versioned< T, _Strategy >::Collapse ( std::shared_ptr< Revision >  main, std::shared_ptr< Segment >  parent  )

overridevirtual

Collapse all changes made in Revision into one.

Parameters

main	Revision to start collapsing from
parent	Segment until which to collapse

Implements VersionedI.

Definition at line 244 of file versioned.h.

                                                                                                 {
    if (versions.find(main->current->version) == versions.end()) {
        Set(main, versions[parent->version]);
    }
    Release(parent);
}

Get()

template<class T , typename _Strategy >

const T & Versioned< T, _Strategy >::Get

Get the current value of the object in the current Revision.

Returns

T Object value

See also

Revision

Definition at line 186 of file versioned.h.

                                          {
    return Get(Revision::currentRevision);
}

Merge()

template<class T , typename _Strategy >

void Versioned< T, _Strategy >::Merge ( std::shared_ptr< Revision >  main, std::shared_ptr< Revision >  joinRev, std::shared_ptr< Segment >  join  )

overridevirtual

Merge changes from two Revisions.

Parameters

main	Revision to merge into
joinRev	Revision to merge
join	Segment to which to merge

Implements VersionedI.

Definition at line 252 of file versioned.h.

                                                                                                                             {
    std::shared_ptr<Segment> s = joinRev->current;
    while (versions.find(s->version) == versions.end()) {
        if (!s->parent)
            break;
 
        s = s->parent;
    }
    if (s == join) {
        SetMerge(main, versions[join->version]);
    }
}

Release()

template<class T , typename _Strategy >

void Versioned< T, _Strategy >::Release ( std::shared_ptr< Segment >  release )

overridevirtual

Forget version that was changed in some Segment.

Parameters

release

Segment to forget

See also

Segment

Implements VersionedI.

Definition at line 239 of file versioned.h.

                                                                   {
    versions.erase(release->version);
}

Set()

template<class T , typename _Strategy >

bool Versioned< T, _Strategy >::Set	(	const T &	v,
		const std::function< bool(T &)> &	updater = nullptr
	)

Set new value of the object.

Parameters

v	New object value
updater	Function to update value

Returns

bool result of updater if defined, else true

If updater function is defined, object will be updated in-place instead of overwrite

Definition at line 205 of file versioned.h.

                                                                                 {
    return Set(Revision::currentRevision, v, updater);
}

Member Data Documentation

versions

template<class T , typename _Strategy = DefaultMergeStrategy<T>>

std::map<int, T> Versioned< T, _Strategy >::versions

Map of all versions of specified object.

Segment versions where that object was changed are used as a keys

See also

Segment

Definition at line 61 of file versioned.h.

---

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

• lib/include/versioned.h