CGAL 4.7 - Kinetic Data Structures: Kinetic_framework/trivial_kds.cpp

\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)

CGAL 4.7 - Kinetic Data Structures

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
Kinetic_framework/trivial_kds.cpp
#include <CGAL/Kinetic/Ref_counted.h>
#include <CGAL/Kinetic/Exact_simulation_traits.h>
#include <CGAL/Kinetic/listeners.h>
#include <CGAL/Kinetic/Event_base.h>
#include <iostream>
#include <set>
#include <vector>
#ifdef _MSC_VER
#pragma warning(disable:4355) // complaint about using 'this' to
// initialize a member
#endif
// This must be external since operator<< has to be defined
template <class Object, class Time, class KDS>
struct Trivial_event: public CGAL::Kinetic::Event_base<KDS*>
{
typedef CGAL::Kinetic::Event_base<KDS*> P;
Trivial_event(){}
template <class It, class Map>
Trivial_event(It beg, It end, const Map &m, KDS *kds): P(kds) {
for (; beg != end; ++beg) {
objects_.push_back(m[*beg]);
}
}
void write(std::ostream &out) const {
out << "An event";
}
void process() const
{
std::cout << "The following objects are in the table: ";
for (typename std::vector<Object>::const_iterator
cit= objects_.begin();
cit != objects_.end(); ++cit) {
std::cout << *cit << " ";
}
std::cout << std::endl;
P::kds()->set_processed(true);
}
std::vector<Object> objects_;
};
template <class Traits>
struct Trivial_kds: CGAL::Kinetic::Ref_counted<Trivial_kds<Traits> >
{
typedef Trivial_kds<Traits> This;
typedef typename Traits::Active_points_1_table::Data Point;
typedef typename Traits::Simulator::Time Time;
typedef typename Traits::Active_points_1_table::Key Point_key;
typedef typename Traits::Simulator::Event_key Event_key;
CGAL_KINETIC_DECLARE_LISTENERS(typename Traits::Simulator, typename Traits::Active_points_1_table)
public:
typedef Trivial_event<Point, Time, This> Event;
Trivial_kds(Traits tr): has_certificates_(true),
tr_(tr){
CGAL_KINETIC_INITIALIZE_LISTENERS(tr_.simulator_handle(),
tr_.active_points_1_table_handle());
}
// this method is called with the value true when the event is processed
void set_processed(bool tf) {
if (tf== true) {
event_= Event_key();
set_has_certificates(false);
set_has_certificates(true);
}
}
void audit() const
{
/* In a real KDS you could use tr_.instantaneous_kernel() to build
a static version of the kinetic data structure and check it for
equality with the kinetic version.
*/
CGAL_assertion(event_.is_valid());
std::cout << "The structure is trivially correct at time "
<< tr_.simulator_handle()->audit_time() << std::endl;
}
void set_has_certificates(bool tf) {
typename Traits::Simulator::Handle sp= tr_.simulator_handle();
if (has_certificates_ != tf) {
has_certificates_=tf;
if (has_certificates_) {
CGAL_assertion_code(bool ev=)
event_.is_valid();
CGAL_assertion(!ev);
Time t= CGAL:: to_interval(sp->current_time()).second+1;
event_= sp->new_event(t, Event(objects_.begin(),
objects_.end(),
*tr_.active_points_1_table_handle(),
this));
std::cout << "Created event (" << event_ << ") at time " << t << std::endl;
} else {
if (event_.is_valid()) {
std::cout << "Deleting event " << event_ << std::endl;
sp->delete_event(event_);
event_=Event_key();
}
}
}
}
bool has_certificates() const
{
// you can't use !event_ because the simulation
// might end before the time you tried to schedule the event.
return has_certificates_;
}
void insert(Point_key k) {
std::cout << "Updating structure to include new object "
<< k << "." << std::endl;
objects_.insert(k);
if (has_certificates_) {
std::cout << "Updating all certificates which depend on "
<< k << "." << std::endl;
set_has_certificates(false);
set_has_certificates(true);
}
}
void set(Point_key k) {
if (has_certificates_) {
std::cout << "Updating all certificates which depend on "
<< k << "." << std::endl;
set_has_certificates(false);
set_has_certificates(true);
} else {
std::cout << "An object changed, but there was no certificate."<< std::endl;
}
}
void erase(Point_key k) {
std::cout << "An object " << k << " was removed."<< std::endl;
objects_.erase(k);
if (has_certificates_) {
std::cout << "Updating all certificates which depend on "
<< k << "." << std::endl;
set_has_certificates(false);
set_has_certificates(true);
}
}
protected:
bool has_certificates_;
std::set<Point_key > objects_;
Event_key event_;
Traits tr_;
};
int main(int, char *[])
{
typedef CGAL::Kinetic::Exact_simulation_traits Traits;
typedef Trivial_kds<Traits> TKDS;
Traits tr(1,100);
TKDS::Handle tk= new TKDS(tr);
Traits::Simulator::Handle sp=tr.simulator_handle();
Traits::Simulator::Function_kernel::Construct_function cf
= tr.kinetic_kernel_object().function_kernel_object().construct_function_object();
tk->set_has_certificates(true);
typedef Traits::Kinetic_kernel::Point_2 Point;
Traits::Active_points_1_table::Key k
= tr.active_points_1_table_handle()->insert(Point(cf(1), cf(0)));
sp->set_current_event_number(sp->current_event_number()+10);
tr.active_points_1_table_handle()
->set(k, Traits::Kinetic_kernel::Point_2(cf(2), cf(0)));
sp->set_current_event_number(sp->current_event_number()+10);
tr.active_points_1_table_handle()->erase(k);
sp->set_current_event_number(sp->current_event_number()+10);
return EXIT_SUCCESS;
}