dgodfrey206

#include <mutex>
#include <thread>
#include <iostream>

struct Singleton
{
    static Singleton& instance()
    {
        std::lock_guard<std::mutex> lock(m);
        static Singleton s;

dgodfrey206

#include <deque>
#include <stack>
#include <mutex>
#include <thread>
#include <algorithm>
#include <functional>
#include <type_traits>
#include <unordered_map>
#include <condition_variable>

dgodfrey206

#include <iostream>
#include <initializer_list>
#include <stdexcept>

template <class T>
class list;

template <class T>
class Node
{

dgodfrey206

#include <sstream>
#include <iostream>

template<typename Tag, typename Tag::type M>
struct grant_access
{
    friend typename Tag::type get(Tag) { return M; }
};

template<class cT, long n>

dgodfrey206

#include <iostream>

template <class T>
class circular_linked_list
{
    struct node;
    node* tail{nullptr}, **back_ptr{&tail}, **front_ptr{nullptr};
    int m_size{0};
    
    template <class U>

dgodfrey206

Node* DeleteNode(Node*& head, int value)
{
    Node** ptr = &head, *next;
    
    while (*ptr && (*ptr)->data != value)
        ptr = &(*ptr)->next;

    if (!*ptr)
        return NULL;
        

dgodfrey206

#include <iostream>

class Node
{
public:
    Node(int data, Node* left = nullptr, Node* right = nullptr)
        : data(data)
        , left(left)
        , right(right)
    { }

dgodfrey206

#include <iostream>
#include <algorithm>
#include <vector>
#include <fstream>

class insertbuf : public std::streambuf
{
public:
    insertbuf(std::ostream& os, std::string const& data)
        : m_stream(os)

dgodfrey206

#include <iostream>
#include <stdexcept>

template <class T>
class LinkedList;

template <class T>
class ListElement
{
    friend LinkedList<T>;

dgodfrey206

#include <stdexcept>

template <class T>
class Array
{
public:
    Array();
    Array(unsigned int, unsigned int = 0);
    Array(Array const&);
    ~Array();