main.cpp

#include "bits/stdc++.h"
#include <semaphore>
#include <thread>

using namespace std;

// ------------------------------------------ functions prototypes
template <typename T>
void print(T t);

template <typename T>
void debugprint(T t);

template <typename T>
void print(vector<T> v);

template <typename T>
void print(vector<T> v, int start, int end);

// ------------------------------------------ classes
struct MQStatus {
public:
  int in{0};
  int out{0};
  int messages_count{0};
  int messages_size{0};
  int total_memory_usage{0};

  void print() {
    std::cout << "in: " << in << '\n';
    std::cout << "out: " << out << '\n';
    std::cout << "messages_count: " << messages_count << '\n';
    std::cout << "messages_size: " << messages_size << '\n';
    std::cout << "total_memory_usage: " << total_memory_usage << '\n';
  }
};

class AyMQ {

private:
  int size{0};
  int in{0};
  int out{0};
  int filled{0};

  binary_semaphore q_lock{1};
  binary_semaphore q_empty{1}; // 0 -> is empty so wait , 1 -> is not empty go on

  std::vector<std::string> messages;

public:
  AyMQ(int size) {
    messages.resize(size);
  }

  bool is_full() {
    return filled == messages.size();
  }

  bool is_empty() {
    return filled == 0;
  }

  bool send_msg(std::string new_message) {


    q_lock.acquire();
    if (is_full()) {
      std::cout << "queue is full my bro! message: " << new_message << " ignored" << '\n';
      q_lock.release();
      return false;
    }
    q_lock.release();


    q_lock.acquire();

      messages[in] = new_message;
      in = (in + 1) % messages.size();

      filled += 1;

      q_empty.release();

      std::cout << "new message added: " << new_message << '\n';
    q_lock.release();

    return true;
  }

  std::string get_msg() {
    std::string out_message;


    q_lock.acquire();
    if (is_empty()) {
      q_empty.acquire();
    }

    out_message = messages[out];
    out = (out + 1) % messages.size();

    filled -= 1;

    std::cout << "front poped: " << out_message << '\n';
    q_lock.release();

    return out_message;
  }

  std::string get_msg_nb() {
    std::string out_message;

    q_lock.acquire();
    if (filled == size) {
      q_lock.release();
      return "queue is empty!";
    }
    q_lock.release();

    q_lock.acquire();

    out_message = messages[out];
    out = (out + 1) % size;

    filled -= 1;

    q_lock.release();

    return out_message;
  }

  MQStatus *stats() {
    print(messages, out, in);
    return new MQStatus{in, out, (int)messages.size(), filled, 0};
  }
};

// ------------------------------------------ main
int main()
{
  std::cout << "Queue is ready!" << '\n';

  // SENARIO1
  // AyMQ mq(5);
  //
  // mq.send_msg("first");
  // mq.send_msg("second");
  // mq.send_msg("third");
  //
  // print("");
  //
  // print(mq.get_msg());
  // print(mq.get_msg());
  // print(mq.get_msg());
  // ENDSENARIO

  // SENARIO2
  // AyMQ *mq = new AyMQ(5);
  //
  // std::thread t1(&AyMQ::send_msg, mq, "first");
  // std::thread t2(&AyMQ::send_msg, mq, "second");
  // std::thread t3(&AyMQ::send_msg, mq, "third");
  //
  // print("");
  //
  // std::thread t4(&AyMQ::get_msg, mq);
  // std::thread t5(&AyMQ::get_msg, mq);
  // std::thread t6(&AyMQ::get_msg, mq);
  //
  // t1.join();
  // t2.join();
  // t3.join();
  // t4.join();
  // t5.join();
  // t6.join();
  // ENDSENARIO

  // SENARIO3
  AyMQ *mq = new AyMQ(5);

  std::thread t1(&AyMQ::send_msg, mq, "first");
  std::thread t2(&AyMQ::send_msg, mq, "second");
  std::thread t3(&AyMQ::send_msg, mq, "third");
  std::thread t4(&AyMQ::send_msg, mq, "fourth");
  std::thread t5(&AyMQ::send_msg, mq, "fifth");
  std::thread t6(&AyMQ::send_msg, mq, "sixth");

  print("");

  std::thread t7(&AyMQ::get_msg, mq);
  std::thread t8(&AyMQ::get_msg, mq);
  std::thread t9(&AyMQ::get_msg, mq);

  // mq->stats();

  t1.join();
  t2.join();
  t3.join();
  t4.join();
  t5.join();
  t6.join();
  t7.join();
  t8.join();
  t9.join();

  MQStatus *mqs = mq->stats();
  mqs->print();
  // ENDSENARIO




  return 0;
}


// ------------------------------------------ classes




// ------------------------------------------ functions
template <typename T>
void print(T t)
{
    std::cout << t << "\n";
}

template <typename T>
void debugprint(T t)
{
    std::cout << "debug: " << t << "\n";
}

template <typename T>
void print(vector<T> v)
{
    cout << "{";
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << ", ";
    }
    cout << "}\n";
}

template <typename T>
void print(vector<T> v, int start, int end)
{
  if (end > v.size() || start > v.size()) {
    std::cout << "end or start is bigger than size of vector?!" << '\n';
    return;
  }

  cout << "{";
  if (start <= end) {
    for (size_t i = start; i < end; i++)
    {
        cout << v[i] << ", ";
    }
  } else {
    for (size_t i = start; i < v.size(); i++) {
      cout << v[i] << ", ";
    }

    for (size_t i = 0; i < end; i++) {
      cout << v[i] << ", ";
    }
  }
  cout << "}\n";
}