errorsIrio.h

#pragma once
 
#include <stdexcept>
#include <string>
 
namespace irio {
namespace errors {
 
class IrioError: public std::runtime_error {
    using std::runtime_error::runtime_error;
};
 
class TerminalNotImplementedError: public IrioError {
    using IrioError::IrioError;
 public:
    TerminalNotImplementedError() :
            IrioError("Terminal not implemented in the profile") {
    }
};
 
class ProfileNotImplementedError: public IrioError {
    using IrioError::IrioError;
 public:
    ProfileNotImplementedError() :
            IrioError("Profile not implemented yet") {
    }
};
 
class ResourceNotFoundError: public IrioError {
    using IrioError::IrioError;
 public:
    ResourceNotFoundError() :
            IrioError("Resource not found") {
    }
 
    ResourceNotFoundError(const std::uint32_t resourceNumber,
            const std::string &resourceName) :
            IrioError(std::to_string(resourceNumber)
                    + " is not a valid " + resourceName + " resource") {    }
};
 
class FPGAVIVersionMismatchError: public IrioError {
 public:
    FPGAVIVersionMismatchError() :
            IrioError("FPGAVIversion mismatch") {
    }
 
    FPGAVIVersionMismatchError(const std::string &foundVersion,
            const std::string &expectedVersion) :
            IrioError(
                    "FPGAVIVserion mismatch (" + foundVersion + " != "
                            + expectedVersion + ")") {
    }
};
 
class UnsupportedPlatformError: public IrioError {
 public:
    UnsupportedPlatformError()
        : IrioError("Platform specified is not supported") {}
    explicit UnsupportedPlatformError(const std::uint8_t platform)
        : IrioError(std::to_string(platform) +
                        "is not a supported platform value") {}
};
 
class UnsupportedDevProfileError: public IrioError {
 public:
    UnsupportedDevProfileError() :
            IrioError("DevProfile specified is not supported") {
    }
 
    UnsupportedDevProfileError(const std::uint8_t devProfile,
            const std::uint8_t platform) :
            IrioError(
                    "DevProfile " + std::to_string(devProfile)
                            + " is not valid for the platform "
                            + std::to_string(platform)) {
    }
};
 
class InitializationTimeoutError: public IrioError {
 public:
    InitializationTimeoutError() :
            IrioError("InitDone not ready in time") {
    }
};
 
class CLUARTTimeout: public IrioError {
 public:
    CLUARTTimeout() :
            IrioError("CL UART timeout") {
    }
};
 
class CLUARTInvalidBaudRate: public IrioError {
 public:
    CLUARTInvalidBaudRate() :
            IrioError("Invalid UART baud rate") {
    }
};
 
class ModulesNotOKError: public IrioError {
    using IrioError::IrioError;
};
 
class RIODiscoveryError: public IrioError {
    using IrioError::IrioError;
};
 
class RIODeviceNotFoundError: public IrioError {
 public:
    RIODeviceNotFoundError() :
            IrioError("") {
    }
 
    explicit RIODeviceNotFoundError(const std::string &serialNumber) :
            IrioError("No RIO device with serial number " + serialNumber) {
    }
};
 
class NiFpgaError: public IrioError {
    using IrioError::IrioError;
};
 
class NiFpgaErrorDownloadingBitfile: public NiFpgaError {
    using NiFpgaError::NiFpgaError;
};
 
class NiFpgaFPGAAlreadyRunning: public NiFpgaError {
    using NiFpgaError::NiFpgaError;
};
 
 
class DMAReadTimeout: public IrioError {
 public:
    DMAReadTimeout(const std::string &nameTermDMA, const std::uint32_t &n) :
            IrioError("Timeout reading " + nameTermDMA + std::to_string(n)) {
    }
};
 
class BFPParseBitfileError: public IrioError {
 public:
    explicit BFPParseBitfileError(const std::string &bitfile)
        : IrioError("Error parsing " + bitfile) {}
 
  BFPParseBitfileError(const std::string &bitfile,
                       const std::string &errDescription)
      : IrioError("Error parsing " + bitfile + ". Error: " + errDescription) {
  }
};
 
class UnsupportedAICouplingForModule: public IrioError {
 public:
    UnsupportedAICouplingForModule() :
            IrioError("Unsupported AI coupling mode for module") {
    }
};
 
}  // namespace errors
}  // namespace irio