modularization/src/driver/driver_ultrasonic_dauxi_KS136A/can_producer_consumer.cpp

#include "can_producer_consumer.h"

#include <iostream>

CAN_Producer_Consumer::CAN_Producer_Consumer(const int bufSize)
{
    bufferSize = bufSize;
    buffer.resize(bufferSize);
    freeSpace.release(bufferSize);
}

uint64_t CAN_Producer_Consumer::Produce_Element(const iv::can::canraw &xraw) //return the position of first element int this storage
{
    uint64_t tempPtr = producerPtr % bufferSize;
    freeSpace.acquire();
    producerLock.lock();
    buffer[producerPtr++ % bufferSize] = xraw;
    producerLock.unlock();
    usedSpace.release();

    return tempPtr;
}

uint64_t CAN_Producer_Consumer::Produce_Elements(const iv::can::canmsg &xmsg,const int &size)
{
    uint64_t tempPtr = producerPtr % bufferSize;
    if(size < xmsg.rawmsg_size())
    {
        std::cout<<"Warning! the input size is less than the number of message element."<<std::endl;
        freeSpace.acquire(size);
        producerLock.lock();
        for(int i=0;i<size;i++)
        {
            buffer[producerPtr++ % bufferSize] = xmsg.rawmsg(i);
        }
        producerLock.unlock();
        usedSpace.release(size);
    }
    else
    {
        if(size > xmsg.rawmsg_size())
            std::cout<<"Warning! the input size is more than the number of message element."<<std::endl;
        freeSpace.acquire(xmsg.rawmsg_size());
        producerLock.lock();
        for(int i=0;i<xmsg.rawmsg_size();i++)
        {
            buffer[producerPtr++ % bufferSize] = xmsg.rawmsg(i);
        }
        producerLock.unlock();
        usedSpace.release(xmsg.rawmsg_size());
    }

    return tempPtr;
}

uint64_t CAN_Producer_Consumer::Produce_Elements_From_CANMsg(const iv::can::canmsg &xmsg)
{
    uint64_t tempPtr = producerPtr % bufferSize;
    freeSpace.acquire(xmsg.rawmsg_size());
    producerLock.lock();
    for(int i=0;i<xmsg.rawmsg_size();i++)
    {
        buffer[producerPtr++ % bufferSize] = xmsg.rawmsg(i);
    }
    producerLock.unlock();
    usedSpace.release(xmsg.rawmsg_size());

    return tempPtr;
}

iv::can::canraw CAN_Producer_Consumer::Consume_Element(void)
{
    iv::can::canraw xraw;
    usedSpace.acquire(); //this function is block mode
    consumerLock.lock();
    xraw = buffer.at(consumerPtr++ % bufferSize);
    consumerLock.unlock();
    freeSpace.release();

    return xraw;
}

iv::can::canraw CAN_Producer_Consumer::Consume_Element(const int timeout)
{
    iv::can::canraw xraw;
    bool tempResult = usedSpace.tryAcquire(1,timeout);
    if(tempResult)
    {
        consumerLock.lock();
        xraw = buffer.at(consumerPtr++ % bufferSize);
        consumerLock.unlock();
        freeSpace.release();
    }
    else
        xraw.Clear();

    return xraw;
}

iv::can::canmsg CAN_Producer_Consumer::Consume_Elements(const int &size)
{
    iv::can::canmsg xmsg;
    usedSpace.acquire(size); //this function is block mode
    consumerLock.lock();
    for(int i=0;i<size;i++)
    {
        xmsg.add_rawmsg()->CopyFrom(buffer.at(consumerPtr++ % bufferSize));
    }
    consumerLock.unlock();
    freeSpace.release(size);

    return xmsg;
}

uint64_t CAN_Producer_Consumer::Consume_Element_To_CANMsg(iv::can::canmsg &xmsg)
{
    uint64_t tempPtr = consumerPtr % bufferSize;
    usedSpace.acquire(); //this function is block mode
    iv::can::canraw *praw = xmsg.add_rawmsg();
    consumerLock.lock();
    praw->CopyFrom(buffer.at(consumerPtr++ % bufferSize));
    consumerLock.unlock();
    freeSpace.release();

    return tempPtr;
}

uint64_t CAN_Producer_Consumer::Consume_Element_To_CANMsg(iv::can::canmsg &xmsg,int timeout)
{
    uint64_t tempPtr = consumerPtr % bufferSize;
    bool tempResult = usedSpace.tryAcquire(1,timeout); //this function is block mode
    if(tempResult)
    {
        iv::can::canraw *praw = xmsg.add_rawmsg();
        consumerLock.lock();
        praw->CopyFrom(buffer.at(consumerPtr++ % bufferSize));
        consumerLock.unlock();
        freeSpace.release();
    }

    return tempPtr;
}