The .NET portion of the shared memory provider

NetCoreModule.cpp

extern "C" ImageNetCoreSharedMemoryConsumer* GetImageConsumer(char * name)
{
	return new ImageNetCoreSharedMemoryConsumer(std::string(name));
}

extern "C" void DeleteImageNetCoreSharedMemoryConsumer(ImageNetCoreSharedMemoryConsumer* consumer)
{
	delete consumer;
}

extern "C" void ImageConsumerSetCallback(ImageNetCoreSharedMemoryConsumer* consumer,
		void(*callback)(const unsigned char *,size_t))
{
	consumer->set_callback(callback);
}

extern "C" void StartImageConsumer(ImageNetCoreSharedMemoryConsumer* consumer)
{
	consumer->start();
}

extern "C" void ImageWait(ImageNetCoreSharedMemoryConsumer* consumer)
{
	consumer->wait();
}

extern "C" SeralizedNetCoreSharedMemoryConsumer * GetSerializedConsumer(const char * name)
{
	return new SeralizedNetCoreSharedMemoryConsumer(name);
}

extern "C" void DeleteSeralizedNetCoreSharedMemoryConsumer(SeralizedNetCoreSharedMemoryConsumer* consumer)
{
	delete consumer;
}

extern "C" void SeralizedConsumerSetCallback(SeralizedNetCoreSharedMemoryConsumer* consumer,
											 void(*callback)(const unsigned char *,size_t))
{
	consumer->set_callback(callback);
}

extern "C" void StartSeralizedConsumer(SeralizedNetCoreSharedMemoryConsumer* consumer)
{
	consumer->start();
}

extern "C" void SeralizedWait(SeralizedNetCoreSharedMemoryConsumer* consumer)
{
	consumer->wait();
}

extern "C" ImageNetCoreSharedMemoryProducer * GetImageProducer(const char * name)
{
	return new ImageNetCoreSharedMemoryProducer(name);
}

extern "C" void DeleteImageProducer(ImageNetCoreSharedMemoryProducer * producer)
{
	delete producer;
}

extern "C" void SendImageData(ImageNetCoreSharedMemoryProducer * producer,void * data_ptr,size_t size)
{
	producer->write_data(std::string(static_cast<char*>(data_ptr),size));
}

extern "C" SeralizedNetCoreSharedMemoryProducer * GetSeralizedProducer(const char * name)
{
	return new SeralizedNetCoreSharedMemoryProducer(name);
}

extern "C" void DeleteSeralizedProducer(SeralizedNetCoreSharedMemoryProducer * producer)
{
	delete producer;
}

extern "C" void SendSeralizedData(SeralizedNetCoreSharedMemoryProducer * producer,void * data_ptr,size_t size)
{
	producer->write_data(std::string(static_cast<char*>(data_ptr),size));
}

NetCoreSharedMemoryConsumer.hpp

template <size_t BufferSize>
	class NetCoreSharedMemoryConsumer
	{
	public:
		explicit NetCoreSharedMemoryConsumer(const std::string& name)
			: consumer_(name){}

		void set_callback(void (*callback_method)(const unsigned char *,size_t))
		{
			consumer_.set_callable([=](const InterprocessMessage<BufferSize>& message)
								   {
										callback_method(reinterpret_cast<const unsigned char *>(message.message),message.message_length);
								   });
		}

		void start()
		{
			consumer_.start();
		}

		void wait()
		{
			consumer_.wait();
		}
	private:
		SharedMemoryConsumer<BufferSize> consumer_;
	};

NetCoreSharedMemoryProducer.hpp

template <size_t BufferSize>
	class NetCoreSharedMemoryProducer
	{
	public:
		explicit NetCoreSharedMemoryProducer(const std::string& name)
			: producer_(name){}

		void write_data(const std::string& data)
		{
			producer_.write_data(data);
		}
	private:
		SharedMemoryProducer<BufferSize> producer_;
	};