Université de Sherbrooke, développement du jeu vidéo, CSP

#include <memory>
#include <type_traits>
#include <mutex>
#include <array>
#include <iostream>
#include <atomic>
#include <chrono>
#include <utility>
using namespace std;
using namespace std::chrono;

class file_vide {};
class file_pleine {};

namespace owning {
   namespace non_raw {
      template <class T, int N>
         class file_circulaire_concurrente {
            mutex m;
            static_assert(N > 1); // bof
            struct buffer {
               static auto type() {
                  if constexpr (sizeof(T) * N <= 8096)
                     return array<T, N>{};
                  else
                     return make_unique<T[]>(N);
               }
            };
            using buf_type = decltype(buffer::type());
            buf_type buf = buffer::type();
            int ins_pt = 0;
            int ext_pt = 0;
            static int next(int n) {
               return ++n, n == N ? 0 : n;
            }
            static int prev(int n) {
               return n == 0 ? N - 1 : n - 1;
            }
            bool full() const noexcept {
               return next(ins_pt) == ext_pt;
            }
            bool empty() const noexcept {
               return ins_pt == ext_pt;
            }
         public:
            void push(const T &obj) {
               lock_guard _{ m };
               if (full()) throw file_pleine{};
               buf[ins_pt] = obj;
               ins_pt = next(ins_pt);
            }
            void pop() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               ext_pt = next(ext_pt);
            }
            T top() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               return buf[ext_pt];
            }
            bool try_push(const T &obj) {
               lock_guard _{ m };
               if (full()) return false;
               buf[ins_pt] = obj;
               ins_pt = next(ins_pt);
               return true;
            }
            bool try_pop(T &obj) {
               lock_guard _{ m };
               if (empty()) return false;
               obj = buf[ext_pt];
               ext_pt = next(ext_pt);
               return true;
            }
         };
   }
   namespace raw {
      template <class T, int N>
         class file_circulaire_concurrente {
            mutex m;
            static_assert(N > 1); // bof
            struct buffer {
               static auto type() {
                  if constexpr (sizeof(T) * N <= 8096)
                     return array<char, sizeof(T) * N>{};
                  else
                     return make_unique<char[]>(sizeof(T) * N);
               }
            };
            using buf_type = decltype(buffer::type());
            auto data() {
               if constexpr (is_same_v<unique_ptr<char[]>, buf_type>)
                  return buf.get();
               else
                  return &buf[0];
            }
            alignas(T) buf_type buf = buffer::type();
            int ins_pt = 0;
            int ext_pt = 0;
            static int next(int n) {
               return ++n, n == N ? 0 : n;
            }
            static int prev(int n) {
               return n == 0 ? N - 1 : n - 1;
            }
            bool full() const noexcept {
               return next(ins_pt) == ext_pt;
            }
            bool empty() const noexcept {
               return ins_pt == ext_pt;
            }
            void *elem_addr(int n) {
               return data() + n * sizeof(T);
            }
            T &elem(int n) {
               return *static_cast<T*>(elem_addr(n));
            }
         public:
            void push(const T &obj) {
               lock_guard _{ m };
               if (full()) throw file_pleine{};
               new(elem_addr(ins_pt)) T(obj);
               ins_pt = next(ins_pt);
            }
            void pop() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               elem(ext_pt).~T();
               ext_pt = next(ext_pt);
            }
            T top() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               return elem(ext_pt);
            }
            bool try_push(const T &obj) {
               lock_guard _{ m };
               if (full()) return false;
               new(elem_addr(ins_pt)) T(obj);
               ins_pt = next(ins_pt);
               return true;
            }
            bool try_pop(T &obj) {
               lock_guard _{ m };
               if (empty()) return false;
               obj = elem(ext_pt);
               elem(ext_pt).~T();
               ext_pt = next(ext_pt);
               return true;
            }
            file_circulaire_concurrente(const file_circulaire_concurrente &) = delete;
            file_circulaire_concurrente&
               operator=(const file_circulaire_concurrente &) = delete;
            ~file_circulaire_concurrente() {
               for (T _; try_pop(_);)
                  ;
            }
            file_circulaire_concurrente() = default;
         };
   }
}

namespace non_owning {
   namespace non_raw {
      template <class T, int N>
      class file_circulaire_concurrente {
         mutex m;
         static_assert(N > 1); // bof
         T(&buf)[N];
         int ins_pt = 0;
         int ext_pt = 0;
         static int next(int n) {
            return ++n, n == N ? 0 : n;
         }
         static int prev(int n) {
            return n == 0 ? N - 1 : n - 1;
         }
         bool full() const noexcept {
            return next(ins_pt) == ext_pt;
         }
         bool empty() const noexcept {
            return ins_pt == ext_pt;
         }
      public:
         file_circulaire_concurrente(T (&buf)[N]) : buf{ buf } {
         }
         void push(const T &obj) {
            lock_guard _{ m };
            if (full()) throw file_pleine{};
            buf[ins_pt] = obj;
            ins_pt = next(ins_pt);
         }
         void pop() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            ext_pt = next(ext_pt);
         }
         T top() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            return buf[ext_pt];
         }
         bool try_push(const T &obj) {
            lock_guard _{ m };
            if (full()) return false;
            buf[ins_pt] = obj;
            ins_pt = next(ins_pt);
            return true;
         }
         bool try_pop(T &obj) {
            lock_guard _{ m };
            if (empty()) return false;
            obj = buf[ext_pt];
            ext_pt = next(ext_pt);
            return true;
         }
      };
   }
   namespace raw {
      template <class T, int N>
      class file_circulaire_concurrente {
         mutex m;
         static_assert(N > 1); // bof
         alignas(T) char (&buf)[N * sizeof(T)];
         int ins_pt = 0;
         int ext_pt = 0;
         static int next(int n) {
            return ++n, n == N ? 0 : n;
         }
         static int prev(int n) {
            return n == 0 ? N - 1 : n - 1;
         }
         bool full() const noexcept {
            return next(ins_pt) == ext_pt;
         }
         bool empty() const noexcept {
            return ins_pt == ext_pt;
         }
         void *elem_addr(int n) {
            return buf + n * sizeof(T);
         }
         T &elem(int n) {
            return *static_cast<T *>(elem_addr(n));
         }
      public:
         void push(const T &obj) {
            lock_guard _{ m };
            if (full()) throw file_pleine{};
            new(elem_addr(ins_pt)) T(obj);
            ins_pt = next(ins_pt);
         }
         void pop() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            elem(ext_pt).~T();
            ext_pt = next(ext_pt);
         }
         T top() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            return elem(ext_pt);
         }
         bool try_push(const T &obj) {
            lock_guard _{ m };
            if (full()) return false;
            new(elem_addr(ins_pt)) T(obj);
            ins_pt = next(ins_pt);
            return true;
         }
         bool try_pop(T &obj) {
            lock_guard _{ m };
            if (empty()) return false;
            obj = elem(ext_pt);
            elem(ext_pt).~T();
            ext_pt = next(ext_pt);
            return true;
         }
         file_circulaire_concurrente(const file_circulaire_concurrente &) = delete;
         file_circulaire_concurrente &
            operator=(const file_circulaire_concurrente &) = delete;
         ~file_circulaire_concurrente() {
            for (T _; try_pop(_);)
               ;
         }
         file_circulaire_concurrente(char(&buf)[N * sizeof(T)]) : buf{ buf } {
         }
      };
   }
}


template <class F, class ... Args>
   auto test(F f, Args &&... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }


int main() {
   // using owning::non_raw::file_circulaire_concurrente;
   // using owning::raw::file_circulaire_concurrente;
   // file_circulaire_concurrente<int, 10> ze_file; // par exemple
   // using non_owning::non_raw::file_circulaire_concurrente;
   // int buf[10];
   using non_owning::raw::file_circulaire_concurrente;
   alignas(int) char buf[10 * sizeof(int)];
   file_circulaire_concurrente<int, 10> ze_file(buf); // par exemple
   atomic<bool> fini{ false };
   thread producteur{ [&] {
      for (int i = 0; i != 2000;)
         if (ze_file.try_push(i + 1))
            ++i;
         else
            cout << '.' << flush;
      fini = true;
   } };
   thread consommateur{ [&] {
      for (;;)
         if (int n; ze_file.try_pop(n))
            cout << n << ' ';
         else if (fini) {
            for (int n; ze_file.try_pop(n); )
               cout << n << ' ';
            break;
         }
   } };
   producteur.join(); consommateur.join();
}

#include <utility>
class evil_whatever_cast {};

class whatever {
   void *p = nullptr;
   enum class operation {
      destroy, duplicate
   };
   template <class T> struct Mgr {
      static void *operate(operation op, void *p) {
         switch (op) {
         case operation::destroy:
            delete static_cast<T *>(p);
            return nullptr;
         case operation::duplicate:
            return p ? new T(*static_cast<T *>(p)) : nullptr;
         }
         return nullptr;
      }
   };
   void *(*mgr_fct)(operation, void *) = nullptr;
   void clear() {
      if (mgr_fct) mgr_fct(operation::destroy, p);
   }
public:
   bool empty() const noexcept {
      return mgr_fct != nullptr;
   }
   whatever() = default;
   ~whatever() {
      clear();
   }
   whatever(const whatever &other)
      : p{ other.mgr_fct ? other.mgr_fct(operation::duplicate, other.p) : nullptr },
        mgr_fct{ other.mgr_fct } {
   }
   void swap(whatever &other) {
      using std::swap;
      swap(p, other.p);
      swap(mgr_fct, other.mgr_fct);
   }
   whatever &operator=(const whatever &other) {
      whatever{ other }.swap(*this);
      return *this;
   }
   template <class T>
      whatever(T obj) : p{ new T(obj) }, mgr_fct(&Mgr<T>::operate) {
      }
   template <class T>
      whatever &operator=(T && obj) {
         auto q = new T(std::forward<T>(obj)); // for exception-safety
         clear();
         p = q;
         mgr_fct = &Mgr<T>::operate;
         return *this;
      }
   whatever(whatever &&other) noexcept {
      p = std::exchange(other.p, nullptr);
      mgr_fct = std::exchange(other.mgr_fct, nullptr);
   }
   whatever &operator=(whatever &&other) noexcept {
      clear();
      p = std::exchange(other.p, nullptr);
      mgr_fct = std::exchange(other.mgr_fct, nullptr);
   }
   template <class T>
   T unsafe_downcast() const {
      return *static_cast<T *>(p);
   }
   template <class T>
   T as() const {
      return mgr_fct == &Mgr<T>::operate ? unsafe_downcast<T>() : throw evil_whatever_cast{};
   }
};
template <class D>
D whatever_cast(const whatever &p) {
   return p.as<D>();
}

#include <vector>
#include <string>
#include <iostream>
int main() {
   using namespace std;
   vector<whatever> v;
   v.push_back(3);
   v.push_back(3.14159f);
   v.push_back("potato"s); // string
   cout << whatever_cast<float>(v[1]) << endl;
   v[1] = "yo"s;
   cout << whatever_cast<string>(v[1]) << endl;
}

#include "FacetteServer.h"
#include <iostream>
#include <string_view>
using namespace std::literals;
struct Texture {
   constexpr auto getTextureName() const noexcept {
      return "Je suis un nom de texture"sv;
   }
};
struct TextureManager {
   Texture getTexture() const noexcept {
      return {};
   }
};
struct Sound {
   constexpr auto getFileName() const noexcept {
      return "SomeSound.wav"sv;
   }
};
struct SoundManager {
   Sound getSound() const noexcept {
      return {};
   }
};
int main() {
   using namespace std;
   auto &serveur = FacetteServer::get();
   serveur.installer(TextureManager{});
   serveur.installer(SoundManager{});
   // ...
   cout << utiliser_facette<SoundManager>(serveur).getSound().getFileName() << endl;
   cout << utiliser_facette<TextureManager>(serveur).getTexture().getTextureName() << endl;
}