libcruft-vk/except.hpp

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Copyright:
 *      2016-2017, Danny Robson <danny@nerdcruft.net>
 */

#ifndef CRUFT_VK_EXCEPT_HPP
#define CRUFT_VK_EXCEPT_HPP

#include "./vk.hpp"

#include <cruft/util/debug.hpp>
#include <cruft/util/types/traits.hpp>

#include <exception>
#include <functional>
#include <type_traits>


namespace cruft::vk {
    class error : public std::exception {
    public:
        static void try_code (VkResult);
        static void throw_code [[noreturn]] (VkResult);


        /// invokes a supplied function with the given arguments and tests
        /// that it returns indicating success using try_code.
        template <
            typename FuncT,
            typename ...Args
        >
        static void
        try_func (FuncT &&func, Args &&...args)
        {
            static_assert(std::is_same_v<
                typename func_traits<FuncT>::return_type,
                VkResult
            >);

            try_code (std::invoke (func, std::forward<Args> (args)...));
        }


        /// requests a ValueT using a invokable FuncT with arguments
        /// [Args..., &ValueT] and returns the result after testing for
        /// success.
        template <typename ValueT, typename FuncT, typename ...Args>
        static ValueT
        try_query (FuncT &&func, Args &&...args)
        {
            ValueT value;
            try_func (func, std::forward<Args> (args)..., &value);
            return value;
        }


        template <
            template <typename...> class ContainerT,
            typename FuncT,
            typename ...Args
        >
        static auto
        try_array (FuncT &&func, Args &&...args)
        {
            uint32_t expected = 0;
            try_func (func, args..., &expected, nullptr);

            using ResultT = std::remove_pointer_t<
                std::tuple_element_t<
                    sizeof...(Args) + 1,
                    typename func_traits<FuncT>::argument_types
                >
            >;

            ContainerT<ResultT> values (expected);
            uint32_t found = 0;
            try_func (func, args..., &found, std::data (values));
            CHECK_EQ (expected, found);
            return values;
        }
    };


    class invalid_argument : public error {
    public:
        invalid_argument (const char *_what) noexcept:
            m_what (_what)
        { ; }

        const char*
        what (void) const noexcept override
        {
            return m_what;
        }

    private:
        const char *m_what;
    };


    template <VkResult>
    class error_code : public error {
    public:
        const char* what (void) const noexcept override;
    };
}

#endif