Exceptions.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_EXCEPTIONS_H
#define OPENSHOT_EXCEPTIONS_H
 
#include <string>
#include <cstring>
 
namespace openshot {
 
    class ExceptionBase : public std::exception
    {
    protected:
        std::string m_message;
    public:
        ExceptionBase(std::string message) : m_message(message) { }
        virtual ~ExceptionBase() noexcept {}
        virtual const char* what() const noexcept {
            // return custom message
            return m_message.c_str();
        }
        virtual std::string py_message() const {
            // return complete message for Python exception handling
            return m_message;
        }
    };
 
    class FrameExceptionBase : public ExceptionBase
    {
    public:
        int64_t frame_number;
        FrameExceptionBase(std::string message, int64_t frame_number=-1)
            : ExceptionBase(message), frame_number(frame_number) { }
        virtual std::string py_message() const override {
            // return complete message for Python exception handling
            std::string out_msg(m_message +
                (frame_number > 0
                 ? " at frame " + std::to_string(frame_number)
                 : ""));
            return out_msg;
        }
    };
 
 
    class FileExceptionBase : public ExceptionBase
    {
    public:
        std::string file_path;
        FileExceptionBase(std::string message, std::string file_path="")
            : ExceptionBase(message), file_path(file_path) { }
        virtual std::string py_message() const override {
            // return complete message for Python exception handling
            std::string out_msg(m_message +
                (file_path != ""
                 ? " for file " + file_path
                 : ""));
            return out_msg;
        }
    };
 
    class ChunkNotFound : public FrameExceptionBase
    {
    public:
        int64_t chunk_number;
        int64_t chunk_frame;
        ChunkNotFound(std::string message, int64_t frame_number, int64_t chunk_number, int64_t chunk_frame)
            : FrameExceptionBase(message, frame_number), chunk_number(chunk_number), chunk_frame(chunk_frame) { }
        virtual ~ChunkNotFound() noexcept {}
    };
 
 
    class DecklinkError : public ExceptionBase
    {
    public:
        DecklinkError(std::string message)
            : ExceptionBase(message) { }
        virtual ~DecklinkError() noexcept {}
    };
 
    class ErrorDecodingAudio : public FrameExceptionBase
    {
    public:
        ErrorDecodingAudio(std::string message, int64_t frame_number=-1)
            : FrameExceptionBase(message, frame_number) { }
        virtual ~ErrorDecodingAudio() noexcept {}
    };
 
    class ErrorEncodingAudio : public FrameExceptionBase
    {
    public:
        ErrorEncodingAudio(std::string message, int64_t frame_number=-1)
            : FrameExceptionBase(message, frame_number) { }
        virtual ~ErrorEncodingAudio() noexcept {}
    };
 
    class ErrorEncodingVideo : public FrameExceptionBase
    {
    public:
        ErrorEncodingVideo(std::string message, int64_t frame_number=-1)
            : FrameExceptionBase(message, frame_number) { }
        virtual ~ErrorEncodingVideo() noexcept {}
    };
 
    class InvalidChannels : public FileExceptionBase
    {
    public:
        InvalidChannels(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~InvalidChannels() noexcept {}
    };
 
    class InvalidCodec : public FileExceptionBase
    {
    public:
        InvalidCodec(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~InvalidCodec() noexcept {}
    };
 
    class InvalidFile : public FileExceptionBase
    {
    public:
        InvalidFile(std::string message, std::string file_path)
            : FileExceptionBase(message, file_path) { }
        virtual ~InvalidFile() noexcept {}
    };
 
    class InvalidFormat : public FileExceptionBase
    {
    public:
        InvalidFormat(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~InvalidFormat() noexcept {}
    };
 
    class InvalidJSON : public FileExceptionBase
    {
    public:
        InvalidJSON(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~InvalidJSON() noexcept {}
    };
 
    class InvalidOptions : public FileExceptionBase
    {
    public:
        InvalidOptions(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~InvalidOptions() noexcept {}
    };
 
    class InvalidSampleRate : public FileExceptionBase
    {
    public:
        InvalidSampleRate(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~InvalidSampleRate() noexcept {}
    };
 
    class InvalidJSONKey : public ExceptionBase
    {
    public:
        std::string json;
        InvalidJSONKey(std::string message, std::string json)
            : ExceptionBase(message), json(json) { }
        virtual ~InvalidJSONKey() noexcept {}
        std::string py_message() const override {
            std::string out_msg = m_message +
                " for JSON data " +
                (json.size() > 100 ? " (abbreviated): " : ": ")
                + json.substr(0, 99);
            return out_msg;
        }
    };
 
    class NoStreamsFound : public FileExceptionBase
    {
    public:
        NoStreamsFound(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~NoStreamsFound() noexcept {}
    };
 
    class OutOfBoundsFrame : public ExceptionBase
    {
    public:
        int64_t FrameRequested;
        int64_t MaxFrames;
        OutOfBoundsFrame(std::string message, int64_t frame_requested, int64_t max_frames)
            : ExceptionBase(message), FrameRequested(frame_requested), MaxFrames(max_frames) { }
        virtual ~OutOfBoundsFrame() noexcept {}
        std::string py_message() const override {
            std::string out_msg(m_message
                + " Frame requested: " + std::to_string(FrameRequested)
                + " Max frames: " + std::to_string(MaxFrames));
            return out_msg;
        }
    };
 
    class OutOfBoundsPoint : public ExceptionBase
    {
    public:
        int PointRequested;
        int MaxPoints;
        OutOfBoundsPoint(std::string message, int point_requested, int max_points)
            : ExceptionBase(message), PointRequested(point_requested), MaxPoints(max_points) { }
        virtual ~OutOfBoundsPoint() noexcept {}
        std::string py_message() const override {
            std::string out_msg(m_message
                + " Point requested: " + std::to_string(PointRequested)
                + " Max point: " + std::to_string(MaxPoints));
            return out_msg;
        }
    };
 
    class OutOfMemory : public FileExceptionBase
    {
    public:
        OutOfMemory(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~OutOfMemory() noexcept {}
    };
 
    class ReaderClosed : public FileExceptionBase
    {
    public:
        ReaderClosed(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~ReaderClosed() noexcept {}
    };
 
    class ResampleError : public FileExceptionBase
    {
    public:
        ResampleError(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~ResampleError() noexcept {}
    };
 
#define TMS_DEP_MSG "The library no longer throws this exception. It will be removed in a future release."
 
#ifndef SWIG
    class
    [[deprecated(TMS_DEP_MSG)]]
    TooManySeeks : public FileExceptionBase
    {
    public:
        [[deprecated(TMS_DEP_MSG)]]
        TooManySeeks(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~TooManySeeks() noexcept {}
    };
#endif
 
    class WriterClosed : public FileExceptionBase
    {
    public:
        WriterClosed(std::string message, std::string file_path="")
            : FileExceptionBase(message, file_path) { }
        virtual ~WriterClosed() noexcept {}
    };
}
 
#endif