#include <thread.h>#include <threads/exception.h>#include <iostream>#include <map>#include <deque>#include <string>extern "C" {#include <errno.h>};using namespace std;class Var {public:  Var() { }  virtual ~Var() { }  virtual unsigned int sizeOf() const = 0;};class VarInt : public Var {  int t;public:  VarInt() : Var(), t(0) { }  VarInt(int newT) : Var(), t(newT) { }  virtual ~VarInt() { }  void set(int newT) { t = newT; }  int get() const { return t; }  virtual unsigned int sizeOf() const { return sizeof(int); }};class VarHolder {  map<string,Var *> data;  typedef map<string,Var *>::const_iterator dataConstIter;public:  VarHolder() { }  ~VarHolder() { }  // New copy constructor  VarHolder(const VarHolder &newT) {    string name;    dataConstIter begin = newT.data.begin();    dataConstIter end = newT.data.end();    while(begin != end) {      name = begin->first;      set(name, newT.get(name));      begin++;    }  }  bool varExists(const string& name) const {    dataConstIter iter = data.find(name);    if(iter == data.end()) return false;    return true;  }  void set(const string& name, int t) {    if(varExists(name)) delete data[name];    data[name] = new VarInt(t);  }  int get(const string& name) const {    if(!varExists(name)) return 0;              dataConstIter iter = data.find(name);    VarInt *dt = dynamic_cast<VarInt *>(iter->second);    if(dt == 0) return 0;    return dt->get();  }  void erase(const string& name) {    if(varExists(name)) delete data[name];  }  void clear() {    data.clear();  }};class VarQueue {  deque<VarHolder> q;  cpp_threads::Mutex* q_mutex;public:  VarQueue() {    q_mutex = new      cpp_threads::Mutex(cpp_threads::attributes::process_private_e);    q_mutex->kind(cpp_threads::Mutex::recursive_e);  }  ~VarQueue() {    delete q_mutex;  }    void put(const VarHolder& t) {    q_mutex->lock();    q.push_front(t);    q_mutex->unLock();  }    VarHolder get() {    VarHolder t;        // check the number of elements in the queue, return empty VarHolder if queue is empty    if(!q.size()) return t;    // Make the iterator, lock things up, pull the VarHolder from the queue    deque<VarHolder>::iterator iter;    q_mutex->lock();    iter = q.end();    iter--;                         // Move to last element    t = *iter;    q.pop_back();    q_mutex->unLock();        return t;  }} varqueue;        class worker : public cpp_threads::Pthread {public:  worker() : cpp_threads::Pthread() { }protected:  int thread(void*) {    VarHolder t;    for(int count = 0; count < 100000; count++) {      cout << "WorkerThread: " << count << endl;      t.clear();      t.set("#: ", count);      varqueue.put(t);    }    return 0;  }};int main(int argc, char* argv[]) {          cpp_threads::Pthread* workerThread = new worker;  workerThread->run();          VarHolder t;  for(int count = 0; count < 100000; count++) {    cout << "MainThread: " << count << endl;    t.clear();    t.set("#: ", count);    varqueue.put(t);  }  cout << "MainThread done.\n";  workerThread->join();  cout << "WorkerThread done.\n";  return 0;}