bbb_activity_sequence.h

Go to the documentation of this file.

/* =========================================================================== *
   |
   |  Copyright (c) 1994-2011 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Ernesto Brau
 * =========================================================================== */

/* $Id$ */

#ifndef B3_ACTIVITY_SEQUENCE_H
#define B3_ACTIVITY_SEQUENCE_H

#include <bbb_cpp/bbb_physical_activity.h>
#include <bbb_cpp/bbb_intentional_activity.h>
#include <string>
#include <vector>
#include <iostream>
#include <boost/variant.hpp>

namespace kjb {
namespace bbb {

class Activity_sequence
{
public:
    typedef boost::variant<Physical_activity, Intentional_activity> Activity;
    typedef std::vector<Activity>::const_iterator const_iterator;

public:
    Activity_sequence(const std::string& role) : role_(role) {}

    const std::string& role() const { return role_; }

    const_iterator begin() const { return activities_.begin(); }

    const_iterator end() const { return activities_.end(); }

    const Activity& activity(size_t j) const { return activities_[j]; }

    size_t size() const { return activities_.size(); }

    void add(const Intentional_activity& activity)
    { 
        activities_.push_back(activity);
    }

    void add(const Physical_activity& activity)
    { 
        activities_.push_back(activity);
    }

private:
    std::string role_;
    std::vector<Activity> activities_;
};

class Output_activity : public boost::static_visitor<>
{
public:
    Output_activity(std::ostream& ost) : ost_(&ost) {}

    template<class A>
    void operator()(const A& act) { *ost_ << act; }

    std::ostream* ost_;
};

class Get_name : public boost::static_visitor<>
{
public:
    Get_name(std::string* nm) : name(nm) {}

    template<class A>
    void operator()(const A& act) const { *name = act.name(); }

    std::string* name;
};

class Get_start : public boost::static_visitor<>
{
public:
    Get_start(size_t* s) : start(s) {}

    template<class A>
    void operator()(const A& act) const { *start = act.start(); }

    size_t* start;
};

class Get_end : public boost::static_visitor<>
{
public:
    Get_end(size_t* e) : end(e) {}

    template<class A>
    void operator()(const A& act) const { *end =  act.end(); }

    size_t* end;
};

class Get_trajectories : public boost::static_visitor<>
{
public:
    Get_trajectories(Traj_set* ts) : trajs(ts) {}

    template<class A>
    void operator()(const A& act) const { *trajs = act.trajectories(); }

    Traj_set* trajs;
};

template<class A>
bool same_activity(const Activity_sequence::Activity& activity, const A& piact)
{
    return boost::get<A>(&activity) == &piact;
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

std::ostream& operator<<(std::ostream& ost, const Activity_sequence& aseq);

}} // namespace kjb::bbb

#endif /*B3_ACTIVITY_SEQUENCE_H */