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 indicates success using try_code iff it returns a VkResult,
        /// else it returns the result of the function.
        ///
        /// while it would simplify writing this function to avoid
        /// non-VkResult functions it simplifies some of the upper layers of
        /// try_foo functions to allow them anyway (eg,
        /// vkGetBufferMemoryRequirements is otherwise usable with try_query
        /// if we ignore the VkResult requirement)
        template <
            typename FuncT,
            typename ...Args
        >
        static auto
        try_func (FuncT &&func, Args &&...args)
        {
            if constexpr (std::is_same_v<
                              typename func_traits<FuncT>::return_type,
                              VkResult
                          >)
            {
                try_code (func (std::forward<Args> (args)...));
                return;
            }
            else
                return 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 = std::vector,
            typename FuncT,
            typename ...Args
        >
        static auto
        try_array (FuncT &&func, Args &&...args)
        {
            uint32_t expected = 0;
            try_func (func, args..., &expected, nullptr);

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

            ValueT values[expected];
            uint32_t found = 0;
            try_func (func, args..., &found, values + 0);
            CHECK_EQ (expected, found);

            return ContainerT<ValueT> {
                values + 0,
                values + found
            };
        }
    };


    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