Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Merge pull request #302 from mpoquet/rename-s4u-synchro-examples
[simgrid.git] / include / xbt / Extendable.hpp
1 /* Copyright (c) 2015-2018. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #ifndef SIMGRID_XBT_LIB_HPP
8 #define SIMGRID_XBT_LIB_HPP
9
10 #include <cstddef>
11 #include <limits>
12 #include <vector>
13
14 namespace simgrid {
15 namespace xbt {
16
17 template<class T, class U> class Extension;
18 template<class T>          class Extendable;
19
20 template<class T, class U>
21 class Extension {
22   static const std::size_t INVALID_ID = std::numeric_limits<std::size_t>::max();
23   std::size_t id_;
24   friend class Extendable<T>;
25   explicit constexpr Extension(std::size_t id) : id_(id) {}
26 public:
27   explicit constexpr Extension() : id_(INVALID_ID) {}
28   std::size_t id() const { return id_; }
29   bool valid() { return id_ != INVALID_ID; }
30 };
31
32 /** An Extendable is an object that you can extend with external elements.
33  *
34  * An Extension is one dimension of such extension. They are similar to the concept of mixins, that is, a set of behavior that is injected into a class without derivation.
35  *
36  * Imagine that you want to write a plugin dealing with the energy in SimGrid.
37  * You will have to store some information about each and every host.
38  *
39  * You could modify the Host class directly (but your code will soon become messy).
40  * You could create a class EnergyHost deriving Host, but it is not easily combinable
41  *    with a notion of Host extended with another concept (such as mobility).
42  * You could completely externalize these data with an associative map Host->EnergyHost.
43  *    It would work, provided that you implement this classical feature correctly (and it would induce a little performance penalty).
44  * Instead, you should add a new extension to the Host class, that happens to be Extendable.
45  *
46  */
47 template<class T>
48 class Extendable {
49 private:
50   static std::vector<void(*)(void*)> deleters_;
51   std::vector<void*> extensions_;
52 public:
53   static size_t extension_create(void (*deleter)(void*))
54   {
55     std::size_t res = deleters_.size();
56     deleters_.push_back(deleter);
57     return res;
58   }
59   template<class U>
60   static Extension<T,U> extension_create(void (*deleter)(void*))
61   {
62     return Extension<T,U>(extension_create(deleter));
63   }
64   template<class U> static
65   Extension<T,U> extension_create()
66   {
67     return Extension<T, U>(extension_create([](void* p) { delete static_cast<U*>(p); }));
68   }
69   Extendable() : extensions_(deleters_.size(), nullptr) {}
70   ~Extendable()
71   {
72     /* Call destructors in reverse order of their registrations
73      *
74      * The rationale for this, is that if an extension B as been added after
75      * an extension A, the subsystem of B might depend on the subsystem on A and
76      * an extension of B might need to have the extension of A around when executing
77      * its cleanup function/destructor. */
78     for (std::size_t i = extensions_.size(); i > 0; --i)
79       if (extensions_[i - 1] != nullptr && deleters_[i - 1] != nullptr)
80         deleters_[i - 1](extensions_[i - 1]);
81   }
82
83   // Type-unsafe versions of the facet access methods:
84   void* extension(std::size_t rank)
85   {
86     if (rank >= extensions_.size())
87       return nullptr;
88     else
89       return extensions_.at(rank);
90   }
91   void extension_set(std::size_t rank, void* value, bool use_dtor = true)
92   {
93     if (rank >= extensions_.size())
94       extensions_.resize(rank + 1, nullptr);
95     void* old_value = this->extension(rank);
96     extensions_.at(rank) = value;
97     if (use_dtor && old_value != nullptr && deleters_[rank])
98       deleters_[rank](old_value);
99   }
100
101   // Type safe versions of the facet access methods:
102   template<class U>
103   U* extension(Extension<T,U> rank)
104   {
105     return static_cast<U*>(extension(rank.id()));
106   }
107   template<class U>
108   void extension_set(Extension<T,U> rank, U* value, bool use_dtor = true)
109   {
110     extension_set(rank.id(), value, use_dtor);
111   }
112
113   // Convenience extension access when the type has a associated EXTENSION ID:
114   template<class U> U* extension()           { return extension<U>(U::EXTENSION_ID); }
115   template<class U> void extension_set(U* p) { extension_set<U>(U::EXTENSION_ID, p); }
116 };
117
118 template<class T>
119 std::vector<void(*)(void*)> Extendable<T>::deleters_ = {};
120
121 }
122 }
123
124 #endif