root/platform/logService/LogStatus_impl.cpp @ 3832

#include "LogStatus_impl.h"

#include <iostream>

LogStatus_impl::LogStatus_impl()
{
    LogStatus_impl::LogStatus_impl(MAX_SIZE_DEFAULT);
}

LogStatus_impl::LogStatus_impl(unsigned long long len)
{
    circLogSeq = new CircularLogRecordSequence(len);

    test_mutex = new omni_mutex();
    test_mutex->release();

    operationalState = LogService::enabled;
    administrativeState = LogService::unlocked;
    logFullAction = LogService::HALT;

    availabilityStatus.offDuty = false;
    availabilityStatus.logFull = circLogSeq->isFull();
}

LogStatus_impl::~LogStatus_impl()
{
    //
    // Undefined behavior 
    //
    delete circLogSeq;
}

unsigned long long LogStatus_impl::getMaxSize()
{
    return circLogSeq->getMaxLen();
}

unsigned long long LogStatus_impl::getCurrentSize()
{
    // Should be byte size of Log
    return circLogSeq->getCurrentLen();
}

unsigned long long LogStatus_impl::getNumRecords()
{
    return circLogSeq->getCurrentLen();
}

LogService::LogFullAction LogStatus_impl::getLogFullAction()
{
    return logFullAction;
}

LogService::AvailabilityStatus LogStatus_impl::getAvailabilityStatus()
{
    return availabilityStatus;
}

LogService::AdministrativeState LogStatus_impl::getAdministrativeState()
{
    return administrativeState;
}

LogService::OperationalState LogStatus_impl::getOperationalState()
{
    return operationalState;
}

CircularLogRecordSequence::CircularLogRecordSequence(unsigned long long len)
{
    maxLen = len;
    currentLen = 0;
    wrIndex = 0;
    currentId = 0;

    seq = new LogService::LogRecordSequence(len);
    seq->length(len);

    if (maxLen == 0)
        logFull = true;
    else
        logFull = false;
}

CircularLogRecordSequence::CircularLogRecordSequence()
{
    // Create null sequence
    CircularLogRecordSequence(0);
}

void
CircularLogRecordSequence::writeLogRecord(const LogService::LogRecord& record)
{
    // Special case, do nothing
    if (maxLen == 0) {
        std::cerr << "Error: Log is unwritable" << std::endl;
        return;
    }

    // Wrap write index if necessary
    if (wrIndex >= maxLen) {
        std::cout << "Wrapping write index from " << wrIndex << " to zero" << std::endl;
        wrIndex = 0;
    }

    // Write entry
    (*seq)[wrIndex] = record;
    wrIndex++;

    // Increase log length if not full
    if (!logFull) {
        currentLen++;
    }

    // Check if maximum size is reached
    if (currentLen == maxLen) {
        logFull = true;
    }
}

LogService::LogRecord
CircularLogRecordSequence::readLogRecord(unsigned long long index)
throw (InvalidIndex) 
{   
    if (index >= currentLen) {
        std::cerr << "Error: Invalid index" << std::endl;
        throw InvalidIndex(index);
    }
    else {
        return (*seq)[index];
    }
}

LogService::LogRecordSequence*
CircularLogRecordSequence::readLogRecords(unsigned long long index, 
    CORBA::ULong &howMany, LogService::RecordId &id)
    throw (InternalFailure)
{
    LogService::LogRecordSequence_var newSeq = new LogService::LogRecordSequence();
    newSeq->length(0);

    // Requested Index > Log Size (Invalid)
    if (index >= currentLen) {
        std::cerr << "Error: Invalid index" << std::endl;
        howMany = 0;
        id = currentId;
        return newSeq._retn();
    }

    // Requested Index < Current Index & !Truncate
    if (index < wrIndex && (index + howMany) <= wrIndex) {
        newSeq->length(howMany);

        for (unsigned long long i = 0; i < howMany; i++) {
            newSeq[i] = (*seq)[index + i];
        }

        // Set currentId
        if ( (index + howMany) == wrIndex)
            id = currentId;
        else
            id = (*seq)[index + howMany].id;

        return newSeq._retn();;
    }

    // Requested Index < Current Index & Truncate
    if (index < wrIndex && (index + howMany) > wrIndex) {
        howMany = wrIndex - index;
        newSeq->length(howMany);

        for (unsigned long long i = 0; i < howMany; i++) {
            newSeq[i] = (*seq)[index + i];
        }

        // Set currentId
        id = currentId;

        return newSeq._retn();;
    }

    // Requested Index > Current Index & !Wrap
    if (index >= wrIndex && (index + howMany) <= currentLen) {
        seq->length(howMany);

        for (unsigned long long i = 0; i < howMany; i++) {
            newSeq[i] = (*seq)[index + i];
        }

        // Set currentId
        if ( (index + howMany) == currentLen) {
            if (wrIndex == 0)
                id = currentId;
            else
                id = (*seq)[0].id;
        }
        else {
            id = (*seq)[index + howMany].id;
        }

        return newSeq._retn();;
    }

    // Requested Index > Current Index & Wrap & !Truncate
    if (index >= wrIndex && (index + howMany) > currentLen &&
        howMany <= (currentLen - index) + wrIndex ) {

        newSeq->length(howMany);

        unsigned long long len1 = currentLen - index;
        unsigned long long len2 = howMany - (currentLen - index);

        for (unsigned long long i = 0; i < len1; i++) {
            newSeq[i] = (*seq)[index + i];
        }
        for (unsigned long long i = len1; i < len2; i++) {
            newSeq[i] = (*seq)[0 + i];
        }

        // Set currentId
        if ( len2 == wrIndex)
            id = currentId;
        else
            id = (*seq)[len2].id;

        return newSeq._retn();;
    }

    // Requested Index > Current Index & Wrap & Truncate
    if (index >= wrIndex && (index + howMany) > currentLen &&
        howMany > (currentLen - index) + wrIndex ) {

        howMany = (currentLen - index) + wrIndex;
        newSeq->length(howMany);

        unsigned long long len1 = currentLen - index;
        unsigned long long len2 = wrIndex;

        for (unsigned long long i = 0; i < len1; i++) {
            newSeq[i] = (*seq)[index + i];
        }
        for (unsigned long long i = len1; i < len2; i++) {
            newSeq[i] = (*seq)[0 + i];
        }

        // Set currentId
        id = currentId;

        return newSeq._retn();;
    }
    // Never reached
    std::cerr << "Error: Internal failure" << std::endl;
    throw InternalFailure();
}

unsigned long long
CircularLogRecordSequence::findIndexFromTime(const LogService::LogTime& fromTime)
{
    bool searchFront = true;
    unsigned long long index = currentLen; 

    if (wrIndex < currentLen) {
        for (unsigned long long i = wrIndex; i < currentLen; i++) {
            LogService::LogRecord record = (*seq)[i];
 
            if (record.time.seconds > fromTime.seconds) {
                index = i;
                searchFront = false;
                break;
            }
            if (record.time.seconds == fromTime.seconds &&
                record.time.nanoseconds >= fromTime.nanoseconds) {
                index = i;
                searchFront = false;
                break;
            }
        }
    }
    if (searchFront) {
        for (unsigned long long i = 0; i < wrIndex; i++) {
            LogService::LogRecord record = (*seq)[i];
 
            if (record.time.seconds > fromTime.seconds) {
                index = i;
                break;
            }
            if (record.time.seconds == fromTime.seconds &&
                record.time.nanoseconds >= fromTime.nanoseconds) {
 
                index = i;
                break;
            }
        }
    }

    return index;
}

unsigned long long
CircularLogRecordSequence::findIndexById(unsigned long long id)
{
    bool searchFront = true;
    unsigned long long index = currentLen;

    if (wrIndex < currentLen) {
        for (unsigned long long i = wrIndex; i < currentLen; i++) {
            if ( (*seq)[i].id == id) {
                index = i;
                searchFront = false;
                break;
            }
        }
    }
    if (searchFront) {
        for (unsigned long long i = 0; i < wrIndex; i++) {
            if ( (*seq)[i].id == id) {
                index = i;
                break;
            }
        }
    }

    return index;
}

unsigned long long
CircularLogRecordSequence::getMaxLen()
{
    return maxLen;
}

void
CircularLogRecordSequence::setMaxLen(unsigned long long len)
{
    maxLen = len;
    seq->length(len);

    // Truncate | Unchanged
    if (currentLen >= maxLen) {
        currentLen = maxLen;
        logFull = true;
    }
    // Expand
    else {
        // Should probably re-sort the log from wrapping
        // Overwrite/delete out-of-order entries instead
        if (currentLen != wrIndex) {
            currentLen = wrIndex;
        }
        logFull = false;
    }

}

unsigned long long
CircularLogRecordSequence::getCurrentLen()
{
    return currentLen;
}

bool
CircularLogRecordSequence::isFull()
{
    return logFull;
}

void
CircularLogRecordSequence::clearLog()
{
    wrIndex = 0;
    currentLen = 0;

    if (maxLen == 0)
        logFull = true;
    else
        logFull = false;
}

CircularLogRecordSequence::~CircularLogRecordSequence()
{
    delete seq;
}