vraythrow.hpp

#ifndef _VRAY_THROW_HPP_
#define _VRAY_THROW_HPP_
 
#include <cstring>
#include <string>
#include "_vraysdk_utils.hpp"
 
namespace VRay {
    class VRayException {
        std::string msg;
 
    public:
        explicit VRayException(const std::string& msg) : msg(msg) { }
        explicit VRayException() : msg("Unknown V-Ray exception.") { }
 
        const char* what() const {
            return msg.c_str();
        }
 
        std::string toString() const {
            return msg;
        }
    };
 
    struct InitErr : public VRayException {
        explicit InitErr(const std::string& msg) : VRayException(msg) { }
        explicit InitErr() : VRayException("Initialization error.") { }
    };
 
    struct InstantiationErr : public VRayException {
        LicenseError::VRLAuthError appSDKError;
        LicenseError::RenderNodeErr renderNodeError;
        explicit InstantiationErr(const std::string& msg, LicenseError::VRLAuthError appSDK = LicenseError::vrlauth_noError, LicenseError::RenderNodeErr renderNode = 0) : VRayException(msg), appSDKError(appSDK), renderNodeError(renderNode) { }
        explicit InstantiationErr() : VRayException("Instantiation error.") { }
    };
 
    struct FileReadErr : public VRayException {
        explicit FileReadErr(const std::string& msg) : VRayException(msg) { }
        explicit FileReadErr() : VRayException("File reading error or file not found.") { }
    };
 
    struct PluginUnavailableErr : public VRayException {
        explicit PluginUnavailableErr(const std::string& msg) : VRayException(msg) { }
        explicit PluginUnavailableErr() : VRayException("No such plugin error.") { }
    };
 
    struct InvalidRenderElementErr : public VRayException {
        explicit InvalidRenderElementErr(const std::string& msg) : VRayException(msg) { }
        explicit InvalidRenderElementErr() : VRayException("Invalid Render element.") { }
    };
 
    struct InvalidTypeErr : public VRayException {
        explicit InvalidTypeErr(const std::string& msg) : VRayException(msg) { }
        explicit InvalidTypeErr() : VRayException("Invalid type.") { }
    };
 
    struct InvalidListTypeErr : public InvalidTypeErr {
        explicit InvalidListTypeErr(const std::string& msg) : InvalidTypeErr(msg) { }
        explicit InvalidListTypeErr() : InvalidTypeErr("Invalid list type.") { }
    };
 
    struct VFBLayerErr : public VRayException {
        explicit VFBLayerErr(const std::string& msg) : VRayException(msg) {}
        explicit VFBLayerErr() : VRayException("Unknown VFB Layer exception.") {}
    };
 
    struct VFBLayerManagerErr : public VRayException {
        explicit VFBLayerManagerErr(const std::string& msg) : VRayException(msg) {}
        explicit VFBLayerManagerErr() : VRayException("Unknown VFB Layer Manager exception.") {}
    };
 
    struct VFBHistoryManagerErr : public VRayException {
        explicit VFBHistoryManagerErr(const std::string& msg) : VRayException(msg) {}
        explicit VFBHistoryManagerErr() : VRayException("Unknown VFB History Manager exception.") {}
    };
 
    struct NotSupportedErr : public VRayException {
        explicit NotSupportedErr(const std::string& msg) : VRayException(msg) {}
        explicit NotSupportedErr() : VRayException("Not supported error.") {}
    };
}
 
#endif