FPGAException.h

#pragma once

#include "devices/fpga/NiFpga.h"
#include "helpers.h"

namespace scope {

class FPGAException
    : public std::exception {

public:
    FPGAException(const int32_t& _status)
        : std::exception()
        , fpga_status(_status) {
    }

    FPGAException(const int32_t& _status, const char* const _msg)
        : std::exception(_msg)
        , fpga_status(_status) {
    }

    const int32_t fpga_status;
};

struct FPGAStatusChecker {
    static bool Check(const NiFpga_Status& _st) {
        if(NiFpga_IsError(_st))
            return false;
        return true;
    }
};

template<bool ThrowException>
class FPGAStatusT {

protected:
    NiFpga_Status status;

    CString fpga_message;
    
    void Assign(const NiFpga_Status& _st) {
        status = _st;
        switch (status ) {
        case NiFpga_Status_FifoTimeout:
            fpga_message = L"FIFO timeout";
            break;
        case NiFpga_Status_InvalidParameter:
            fpga_message = L"Invalid parameter";
            break;
        case NiFpga_Status_ResourceNotFound:
            fpga_message = L"Resource not found";
            break;
        case NiFpga_Status_SignatureMismatch:
            fpga_message = L"Bitfile signature mismatch";
            break;
        case NiFpga_Status_IncompatibleBitfile:
            fpga_message = L"Bitfile incompatible";
            break;
        case NiFpga_Status_InvalidResourceName:
            fpga_message = L"Invalid resource name";
            break;
        case NiFpga_Status_BitfileReadError:
            fpga_message = L"Bitfile read error";
            break;
        case NiFpga_Status_CommunicationTimeout:
            fpga_message = L"Communication between FPGA and host timed out";
            break;
        case NiFpga_Status_BadReadWriteCount:
            fpga_message = L"The number of FIFO elements is invalid. Either the number is greater than the depth of the host memory DMA FIFO, or more elements were requested for";
            break;
        default:
            fpga_message = L"Unknown";
        }

        if( !FPGAStatusChecker::Check(status) ) {
            DBOUT(L"FPGAException " << status << L" " << fpga_message.GetString());
        }

        if( !FPGAStatusChecker::Check(status) && ThrowException )
            throw FPGAException(status);
    }

public:
    FPGAStatusT(const NiFpga_Status& _st = NiFpga_Status_Success)
        : fpga_message(L"") {
        Assign(_st);
    }

    FPGAStatusT& operator= (const NiFpga_Status& _st) {
        Assign(_st);
        return *this;
    }

    operator NiFpga_Status () const {
        return status;
    }

    bool Success() const {
        return FPGAStatusChecker::Check(status);
    }
};

typedef FPGAStatusT<true> FPGAStatus;

typedef FPGAStatusT<false> FPGAStatusSafe;

}