D:/Programmierung/C/TRTK/src/Timestamp.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2010 - 2014 Christoph Haenisch

    Chair of Medical Engineering (mediTEC)
    RWTH Aachen University
    Pauwelsstr. 20
    52074 Aachen
    Germany

    See license.txt for more information.

    Version 0.1.1 (2011-09-09)
*/

#include <cassert>
#include <cstddef>
#include <queue>

#include "TRTK/Timestamp.hpp"


using std::queue;
using std::map;
using std::set;
using std::string;


namespace TRTK
{


//                                Timestamp                                 //

Timestamp::Timestamp()
{
};


Timestamp::~Timestamp()
{
};


Timestamp::ObjectInfo & Timestamp::operator[](const string & object_name)
{
    if (objects.count(object_name))
    {
        return objects[object_name];
    }
    else
    {
        // First initialize the ObjectInfo object, store it in the
        // map and then return its reference. Otherwise it would
        // not know its parent collection, that is /this/.

        objects.insert(std::pair<string, ObjectInfo>(object_name, ObjectInfo(*this)));
        return objects[object_name];
    }
};


//                                ObjectInfo                                //

Timestamp::ObjectInfo::ObjectInfo() :
    parent_collection(*reinterpret_cast<Timestamp *>(NULL)),
    timestamp(0)
{
    const bool DO_NO_USE_THIS_CONSTRUCTOR = false;
    assert(DO_NO_USE_THIS_CONSTRUCTOR);
}


Timestamp::ObjectInfo::ObjectInfo(Timestamp & parent_collection) :
    parent_collection(parent_collection),
    timestamp(0)
{
}


Timestamp::ObjectInfo::~ObjectInfo()
{
}


void Timestamp::ObjectInfo::addDependency(const std::string & object_name)
{
    dependencies.insert(object_name);
}


bool Timestamp::ObjectInfo::dependenciesHaveChanged() const
{
    // Check if the timestamps of all dependencies are further back in
    // time than the timestamp of this object.

    std::set<std::string>::const_iterator it;

    for (it = dependencies.begin(); it != dependencies.end(); ++it)
    {
        if (!(parent_collection[*it].dependenciesUpToDate(timestamp)))
        {
            return true;
        }
    }

    return false;
}


bool Timestamp::ObjectInfo::dependencyHasChanged(const std::string & other_object) const
{
    return !parent_collection[other_object].dependenciesUpToDate(timestamp);
}


bool Timestamp::ObjectInfo::dependenciesUpToDate(const clock_t & timestamp) const
{
    // Are there any dependencies?

    if (dependencies.size() == 0)
    {
        // No, there aren't any dependencies.

        if (this->timestamp < timestamp)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        // Yes, there are dependencies. Thus, check, if all dependencies
        // have a timestamp that is further back in time than the given
        // one. In this case return true, else return false.

        std::set<std::string>::const_iterator it;

        for (it = dependencies.begin(); it != dependencies.end(); ++it)
        {
            if (!(parent_collection[*it].dependenciesUpToDate(timestamp)))
            {
                return false;
            }
        }

        return true;
    }
}


bool Timestamp::ObjectInfo::isMoreRecentThan(const std::string & object, bool dependencies) const
{
    if (!dependencies)
    {
        return timestamp > parent_collection[object].timestamp;
    }
    else
    {
        // Check if 'object' is back in time compared to *this. If this
        // is the case also check its dependencies. Do this by inserting
        // direct dependencies into a queue and subsequently comparing
        // these entries in the same manner as above.

        queue<string> dependencies;
        dependencies.push(object);

        while (!dependencies.empty())
        {
            string object = dependencies.front();
            dependencies.pop();

            if (timestamp < parent_collection[object].timestamp)
            {
                return false;
            }

            set<string>::const_iterator it = parent_collection[object].dependencies.begin();

            while (it != parent_collection[object].dependencies.end())
            {
                dependencies.push(*it++);
            }
        }

        return true;
    }
}


void Timestamp::ObjectInfo::removeDependency(const std::string & object_name)
{
    dependencies.erase(object_name);
}


void Timestamp::ObjectInfo::update()
{
    timestamp = std::clock();
}


} // namespace TRTK