To use it, include the below header file

#include <disruptor4cpp/disruptor4cpp.h>

#include <cstdint>

#include <exception>

#include <iostream>

#include <thread>

#include <disruptor4cpp/disruptor4cpp.h>

class int_handler : public disruptor4cpp::event_handler<int>

{

public:

int_handler() = default;

virtual ~int_handler() = default;

virtual void on_start() { }

virtual void on_shutdown() { }

virtual void on_event(int& event, int64_t sequence, bool end_of_batch)

{

std::cout << "Received integer: " << event << std::endl;

}

virtual void on_timeout(int64_t sequence) { }

virtual void on_event_exception(const std::exception& ex, int64_t sequence, int* event) { }

virtual void on_start_exception(const std::exception& ex) { }

virtual void on_shutdown_exception(const std::exception& ex) { }

};

int main(int argc, char* argv[])

{

using namespace disruptor4cpp;

// Create the ring buffer.

ring_buffer<int, 1024, busy_spin_wait_strategy, producer_type::multi> ring_buffer;

// Create and run the consumer on another thread.

auto barrier = ring_buffer.new_barrier();

int_handler handler;

batch_event_processor<decltype(ring_buffer)> processor(ring_buffer, std::move(barrier), handler);

std::thread processor_thread([&processor] { processor.run(); });

// Publish some integers.

for (int i = 0; i < 1000; i++)

{

int64_t seq = ring_buffer.next();

ring_buffer[seq] = i;

ring_buffer.publish(seq);

}

// Stop the consumer.

std::this_thread::sleep_for(std::chrono::seconds(1));

processor.halt();

processor_thread.join();

return 0;

}