fort.hpp

Go to the documentation of this file.

/*
libfort
 
MIT License
 
Copyright (c) 2017 - 2026 Seleznev Anton
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#ifndef LIBFORT_HPP
#define LIBFORT_HPP
 
#include <iomanip>
#include <memory>
#include <sstream>
#include <string>
#include <stdexcept>
#include <type_traits>
 
#include "fort.h"
 
namespace fort
{
 
enum class text_align {
    left   = FT_ALIGNED_LEFT,
    center = FT_ALIGNED_CENTER,
    right  = FT_ALIGNED_RIGHT
};
 
enum class row_type {
    common = FT_ROW_COMMON,
    header = FT_ROW_HEADER
};
 
enum class add_strategy {
    replace = FT_STRATEGY_REPLACE,
    insert  = FT_STRATEGY_INSERT
};
 
enum class color {
    default_color  = FT_COLOR_DEFAULT,
    black          = FT_COLOR_BLACK,
    red            = FT_COLOR_RED,
    green          = FT_COLOR_GREEN,
    yellow         = FT_COLOR_YELLOW,
    blue           = FT_COLOR_BLUE,
    magenta        = FT_COLOR_MAGENTA,
    cyan           = FT_COLOR_CYAN,
    light_gray     = FT_COLOR_LIGHT_GRAY,
    dark_gray      = FT_COLOR_DARK_GRAY,
    light_red      = FT_COLOR_LIGHT_RED,
    light_green    = FT_COLOR_LIGHT_GREEN,
    light_yellow   = FT_COLOR_LIGHT_YELLOW,
    light_blue     = FT_COLOR_LIGHT_BLUE,
    light_magenta  = FT_COLOR_LIGHT_MAGENTA,
    light_cyan     = FT_COLOR_LIGHT_CYAN,
    light_whyte    = FT_COLOR_LIGHT_WHYTE
};
 
enum class text_style {
    default_style = FT_TSTYLE_DEFAULT,
    bold          = FT_TSTYLE_BOLD,
    dim           = FT_TSTYLE_DIM,
    italic        = FT_TSTYLE_ITALIC,
    underlined    = FT_TSTYLE_UNDERLINED,
    blink         = FT_TSTYLE_BLINK,
    inverted      = FT_TSTYLE_INVERTED,
    hidden        = FT_TSTYLE_HIDDEN
};
 
 
enum class table_type {
    character,
#ifdef FT_HAVE_UTF8
    utf8
#endif /* FT_HAVE_UTF8 */
};
 
class table_manipulator
{
public:
    explicit table_manipulator(int i)
        : value(i)
    {
    }
    template <table_type TT>
    friend class table;
private:
    int value;
};
 
const table_manipulator header(0);
 
const table_manipulator endr(1);
 
const table_manipulator separator(2);
 
// Utility functions for internal library usage.
namespace detail
{
template <typename T>
constexpr bool is_stream_manipulator_impl() noexcept
{
    using Tdec = typename std::decay<T>::type;
    // Manipulators for integral types
    return std::is_same<Tdec, typename std::decay<decltype(std::dec)>::type>::value
           || std::is_same<Tdec, typename std::decay<decltype(std::hex)>::type>::value
           || std::is_same<Tdec, typename std::decay<decltype(std::oct)>::type>::value
           // Floating-point manipulators
           || std::is_same<Tdec, typename std::decay<decltype(std::fixed)>::type>::value
           || std::is_same<Tdec, typename std::decay<decltype(std::scientific)>::type>::value
           // Misc
           || std::is_same<Tdec, typename std::decay<decltype(std::setbase(0))>::type>::value
           || std::is_same<Tdec, typename std::decay<decltype(std::setfill('\0'))>::type>::value
           || std::is_same<Tdec, typename std::decay<decltype(std::setprecision(0))>::type>::value
           || std::is_same<Tdec, typename std::decay<decltype(std::setw(0))>::type>::value;
}
}
 
template <typename T>
constexpr bool is_stream_manipulator() noexcept
{
    return detail::is_stream_manipulator_impl<T>();
}
 
template <typename table>
class property_owner
{
public:
 
    property_owner(std::size_t row_idx, std::size_t coll_idx, table *tbl, bool def = false)
        : ps_row_idx_(row_idx), ps_coll_idx_(coll_idx),
          ps_table_(tbl), set_default_properties_(def) {}
 
    bool set_cell_min_width(unsigned value)
    {
        return set_property(FT_CPROP_MIN_WIDTH, value);
    }
 
    bool set_cell_text_align(fort::text_align value)
    {
        return set_property(FT_CPROP_TEXT_ALIGN, static_cast<int>(value));
    }
 
    bool set_cell_top_padding(unsigned value)
    {
        return set_property(FT_CPROP_TOP_PADDING, value);
    }
 
    bool set_cell_bottom_padding(unsigned value)
    {
        return set_property(FT_CPROP_BOTTOM_PADDING, value);
    }
 
    bool set_cell_left_padding(unsigned value)
    {
        return set_property(FT_CPROP_LEFT_PADDING, value);
    }
 
    bool set_cell_right_padding(unsigned value)
    {
        return set_property(FT_CPROP_RIGHT_PADDING, value);
    }
 
    bool set_cell_row_type(fort::row_type value)
    {
        return set_property(FT_CPROP_ROW_TYPE, static_cast<int>(value));
    }
 
    bool set_cell_empty_str_height(unsigned value)
    {
        return set_property(FT_CPROP_EMPTY_STR_HEIGHT, value);
    }
 
    bool set_cell_content_fg_color(fort::color value)
    {
        return set_property(FT_CPROP_CONT_FG_COLOR, static_cast<int>(value));
    }
 
    bool set_cell_bg_color(fort::color value)
    {
        return set_property(FT_CPROP_CELL_BG_COLOR, static_cast<int>(value));
    }
 
    bool set_cell_content_bg_color(fort::color value)
    {
        return set_property(FT_CPROP_CONT_BG_COLOR, static_cast<int>(value));
    }
 
    bool set_cell_text_style(fort::text_style value)
    {
        return set_property(FT_CPROP_CELL_TEXT_STYLE, static_cast<int>(value));
    }
 
    bool set_cell_content_text_style(fort::text_style value)
    {
        return set_property(FT_CPROP_CONT_TEXT_STYLE, static_cast<int>(value));
    }
 
protected:
    std::size_t ps_row_idx_;
    std::size_t ps_coll_idx_;
    table *ps_table_;
    bool set_default_properties_;
 
    bool set_property(uint32_t property, int value)
    {
        int status;
        if (set_default_properties_) {
            status = ft_set_default_cell_prop(property, value);
        } else {
            status = ft_set_cell_prop(ps_table_->table_, ps_row_idx_, ps_coll_idx_, property, value);
        }
        return FT_IS_SUCCESS(status);
    }
};
 
 
template <table_type TT = table_type::character>
class table: public property_owner<table<TT>>
{
    using table_t = table<TT>;
    using property_owner_t = property_owner<table_t>;
 
public:
 
    table()
        : property_owner_t(FT_ANY_ROW, FT_ANY_COLUMN, this),
          table_(ft_create_table())
    {
        if (table_ == NULL)
            throw std::bad_alloc();
    }
 
    ~table()
    {
        ft_destroy_table(table_);
    }
 
    table(const table &tbl)
        : property_owner_t(FT_ANY_ROW, FT_ANY_COLUMN, this), table_(NULL)
    {
        if (tbl.table_) {
            std::unique_ptr<ft_table_t, decltype(&ft_destroy_table)>
                table_copy(ft_copy_table(tbl.table_), &ft_destroy_table);
            if (!table_copy)
                throw std::runtime_error("Error during table copy");
 
            stream_.str(std::string());
            if (tbl.stream_.tellp() >= 0) {
                stream_.str(tbl.stream_.str());
                stream_.seekp(0, std::ios_base::end);
            }
            stream_.copyfmt(tbl.stream_);
            table_ = table_copy.release();
        }
    }
 
    table(table &&tbl)
        : property_owner_t(FT_ANY_ROW, FT_ANY_COLUMN, this), table_(tbl.table_)
    {
        if (tbl.stream_.tellp() >= 0) {
            stream_.str(tbl.stream_.str());
            stream_.seekp(0, std::ios_base::end);
            tbl.stream_.str(std::string());
        }
        stream_.copyfmt(tbl.stream_);
        tbl.table_ = 0;
    }
 
    table &operator=(const table &tbl)
    {
        if (&tbl == this)
            return *this;
 
        if (tbl.table_) {
            std::unique_ptr<ft_table_t, decltype(&ft_destroy_table)>
                table_copy(ft_copy_table(tbl.table_), &ft_destroy_table);
            if (!table_copy)
                throw std::runtime_error("Error during table copy");
 
            stream_.str(std::string());
            if (tbl.stream_.tellp() >= 0) {
                stream_.str(tbl.stream_.str());
                stream_.seekp(0, std::ios_base::end);
            }
            stream_.copyfmt(tbl.stream_);
            ft_destroy_table(table_);
            table_ = table_copy.release();
        }
        return *this;
    }
 
    table &operator=(table &&tbl)
    {
        if (&tbl == this)
            return *this;
 
        if (tbl.table_) {
            stream_.str(std::string());
            if (tbl.stream_.tellp() >= 0) {
                stream_.str(tbl.stream_.str());
                stream_.seekp(0, std::ios_base::end);
                tbl.stream_.str(std::string());
            }
            stream_.copyfmt(tbl.stream_);
            ft_destroy_table(table_);
            table_ = tbl.table_;
            tbl.table_ = NULL;
        }
        return *this;
    }
 
    std::string to_string() const
    {
        const char *str = c_str();
        if (str == NULL)
            throw std::runtime_error("Error during table to string conversion");
        return str;
    }
 
    const char *c_str() const
    {
#ifdef FT_HAVE_UTF8
        return (TT == table_type::character)
               ? ft_to_string(table_)
               : (const char *)ft_to_u8string(table_);
#else
        return ft_to_string(table_);
#endif
    }
 
    template <typename T>
    table &operator<<(const T &arg)
    {
        constexpr bool is_manip = fort::is_stream_manipulator<typename std::decay<T>::type>();
        stream_ << arg;
        if (stream_.tellp() >= 0 && !is_manip) {
#ifdef FT_HAVE_UTF8
            if (TT == table_type::character) {
                ft_nwrite(table_, 1, stream_.str().c_str());
            } else {
                ft_u8nwrite(table_, 1, (const void *)stream_.str().c_str());
            }
#else
            ft_nwrite(table_, 1, stream_.str().c_str());
#endif
 
            stream_.str(std::string());
        }
        return *this;
    }
 
    table &operator<<(const table_manipulator &arg)
    {
        if (arg.value == header.value)
            ft_set_cell_prop(table_, FT_CUR_ROW, FT_ANY_ROW, FT_CPROP_ROW_TYPE, FT_ROW_HEADER);
        else if (arg.value == endr.value)
            ft_ln(table_);
        else if (arg.value == separator.value)
            ft_add_separator(table_);
        return *this;
    }
 
    bool write(const char *str)
    {
#ifdef FT_HAVE_UTF8
        if (TT == table_type::character) {
            return FT_IS_SUCCESS(ft_write(table_, str));
        } else {
            return FT_IS_SUCCESS(ft_u8write(table_, (const void *)str));
        }
#else
        return FT_IS_SUCCESS(ft_write(table_, str));
#endif
    }
 
    bool write_ln(const char *str)
    {
#ifdef FT_HAVE_UTF8
        if (TT == table_type::character) {
            return FT_IS_SUCCESS(ft_write_ln(table_, str));
        } else {
            return FT_IS_SUCCESS(ft_u8write_ln(table_, str));
        }
#else
        return FT_IS_SUCCESS(ft_write_ln(table_, str));
#endif
    }
 
    bool write(const std::string &str)
    {
        return write(str.c_str());
    }
 
    bool write_ln(const std::string &str)
    {
        return write_ln(str.c_str());
    }
 
#ifdef __cpp_variadic_templates
    template <typename T, typename ...Ts>
    bool write(const T &str, const Ts &...strings)
    {
        return write(str) && write(strings...);
    }
 
    template <typename T, typename ...Ts>
    bool write_ln(const T &str, const Ts &...strings)
    {
        return write(str) && write_ln(strings...);
    }
#else /* __cpp_variadic_templates */
 
    template <typename T_0, typename T_1>
    bool write(const T_0 &arg_0, const T_1 &arg_1)
    {
        return write(arg_0) && write(arg_1);
    }
 
    template <typename T_0, typename T_1, typename T_2>
    bool write(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2)
    {
        return write(arg_0) && write(arg_1, arg_2);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3>
    bool write(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3)
    {
        return write(arg_0) && write(arg_1, arg_2, arg_3);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4>
    bool write(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4)
    {
        return write(arg_0) && write(arg_1, arg_2, arg_3, arg_4);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4, typename T_5>
    bool write(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4, const T_5 &arg_5)
    {
        return write(arg_0) && write(arg_1, arg_2, arg_3, arg_4, arg_5);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4, typename T_5, typename T_6>
    bool write(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4, const T_5 &arg_5, const T_6 &arg_6)
    {
        return write(arg_0) && write(arg_1, arg_2, arg_3, arg_4, arg_5, arg_6);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4, typename T_5, typename T_6, typename T_7>
    bool write(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4, const T_5 &arg_5, const T_6 &arg_6, const T_7 &arg_7)
    {
        return write(arg_0) && write(arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7);
    }
 
 
    template <typename T_0, typename T_1>
    bool write_ln(const T_0 &arg_0, const T_1 &arg_1)
    {
        return write(arg_0) && write_ln(arg_1);
    }
 
    template <typename T_0, typename T_1, typename T_2>
    bool write_ln(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2)
    {
        return write(arg_0) && write_ln(arg_1, arg_2);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3>
    bool write_ln(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3)
    {
        return write(arg_0) && write_ln(arg_1, arg_2, arg_3);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4>
    bool write_ln(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4)
    {
        return write(arg_0) && write_ln(arg_1, arg_2, arg_3, arg_4);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4, typename T_5>
    bool write_ln(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4, const T_5 &arg_5)
    {
        return write(arg_0) && write_ln(arg_1, arg_2, arg_3, arg_4, arg_5);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4, typename T_5, typename T_6>
    bool write_ln(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4, const T_5 &arg_5, const T_6 &arg_6)
    {
        return write(arg_0) && write_ln(arg_1, arg_2, arg_3, arg_4, arg_5, arg_6);
    }
 
    template <typename T_0, typename T_1, typename T_2, typename T_3, typename T_4, typename T_5, typename T_6, typename T_7>
    bool write_ln(const T_0 &arg_0, const T_1 &arg_1, const T_2 &arg_2, const T_3 &arg_3, const T_4 &arg_4, const T_5 &arg_5, const T_6 &arg_6, const T_7 &arg_7)
    {
        return write(arg_0) && write_ln(arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7);
    }
 
#endif /* __cpp_variadic_templates */
 
    template <typename InputIt>
    bool range_write(InputIt first, InputIt last)
    {
        while (first != last) {
            *this << *first;
            ++first;
        }
        return true;
    }
 
    template <typename InputIt>
    bool range_write_ln(InputIt first, InputIt last)
    {
        while (first != last) {
            *this << *first;
            ++first;
        }
        ft_ln(table_);
        return true;
    }
 
    bool set_border_style(const struct ft_border_style *style)
    {
        return FT_IS_SUCCESS(ft_set_border_style(table_, style));
    }
 
    void set_cur_cell(size_t row_i, size_t col_i)
    {
        ft_set_cur_cell(table_, row_i, col_i);
    }
 
 
    bool set_left_margin(unsigned value)
    {
        return FT_IS_SUCCESS(ft_set_tbl_prop(table_, FT_TPROP_LEFT_MARGIN, value));
    }
 
    bool set_top_margin(unsigned value)
    {
        return FT_IS_SUCCESS(ft_set_tbl_prop(table_, FT_TPROP_TOP_MARGIN, value));
    }
 
    bool set_right_margin(unsigned value)
    {
        return FT_IS_SUCCESS(ft_set_tbl_prop(table_, FT_TPROP_RIGHT_MARGIN, value));
    }
 
    bool set_bottom_margin(unsigned value)
    {
        return FT_IS_SUCCESS(ft_set_tbl_prop(table_, FT_TPROP_BOTTOM_MARGIN, value));
    }
 
    bool set_adding_strategy(fort::add_strategy value)
    {
        return FT_IS_SUCCESS(ft_set_tbl_prop(table_,
                                             FT_TPROP_ADDING_STRATEGY,
                                             static_cast<int>(value)));
    }
private:
    ft_table_t *table_;
    mutable std::stringstream stream_;
    friend class property_owner<table>;
 
 
public:
 
    /* Iterators */
    /* todo: implement chains like table[0][0] = table [0][1] = "somethings" */
 
    class table_cell: public property_owner_t
    {
        using property_owner_t::ps_coll_idx_;
        using property_owner_t::ps_row_idx_;
        using property_owner_t::ps_table_;
        using property_owner_t::set_default_properties_;
    public:
        table_cell(std::size_t row_idx, std::size_t coll_idx, table &tbl)
            : property_owner_t(row_idx, coll_idx, &tbl) {}
 
        table_cell &operator=(const char *str)
        {
            ft_set_cur_cell(ps_table_->table_, ps_row_idx_, ps_coll_idx_);
            ps_table_->write(str);
            return *this;
        }
 
        table_cell &operator=(const std::string &str)
        {
            return operator=(str.c_str());
        }
 
        bool set_cell_span(size_t hor_span)
        {
            if (set_default_properties_)
                return false;
 
            return FT_IS_SUCCESS(ft_set_cell_span(ps_table_->table_, ps_row_idx_, ps_coll_idx_, hor_span));
        }
    };
 
    class table_row: public property_owner_t
    {
        using property_owner_t::ps_row_idx_;
        using property_owner_t::ps_table_;
    public:
        table_row(std::size_t row_idx, table &tbl)
            : property_owner_t(row_idx, FT_ANY_COLUMN, &tbl) {}
 
        class table_cell
            operator[](std::size_t coll_idx)
        {
            return table_cell(ps_row_idx_, coll_idx, *ps_table_);
        }
 
        void erase()
        {
            if (FT_IS_ERROR(ft_erase_range(ps_table_->table_,
                                           property_owner_t::ps_row_idx_, 0,
                                           property_owner_t::ps_row_idx_, FT_MAX_COL_INDEX))) {
                throw std::runtime_error("Failed to erase row");
            }
        }
    };
 
    class table_column: public property_owner_t
    {
        using property_owner_t::ps_coll_idx_;
        using property_owner_t::ps_table_;
    public:
        table_column(std::size_t col_idx, table &tbl)
            : property_owner_t(FT_ANY_ROW, col_idx, &tbl) {}
 
        void erase()
        {
            if (FT_IS_ERROR(ft_erase_range(ps_table_->table_,
                                           0, ps_coll_idx_,
                                           FT_MAX_ROW_INDEX, ps_coll_idx_))) {
                throw std::runtime_error("Failed to erase column");
            }
        }
    };
 
    class cell_range: public property_owner_t
    {
        using property_owner_t::ps_coll_idx_;
        using property_owner_t::ps_row_idx_;
        using property_owner_t::ps_table_;
    public:
        cell_range(size_t top_left_row, size_t top_left_col,
                   size_t bottom_right_row, size_t bottom_right_col,
                   table &tbl)
            : property_owner_t(top_left_row, top_left_col, &tbl),
              bottom_right_row_(bottom_right_row),
              bottom_right_col_(bottom_right_col)
        {}
 
        void erase()
        {
            if (FT_IS_ERROR(ft_erase_range(ps_table_->table_,
                                           ps_row_idx_, ps_coll_idx_,
                                           bottom_right_row_, bottom_right_col_))) {
                throw std::runtime_error("Failed to erase column");
            }
        }
 
    private:
        std::size_t bottom_right_row_;
        std::size_t bottom_right_col_;
    };
 
 
    class default_properties: public property_owner_t
    {
    public:
        default_properties(table *tbl)
            : property_owner_t(FT_ANY_ROW, FT_ANY_COLUMN, tbl, true) {}
    };
 
    class table_row
        operator[](std::size_t row_idx)
    {
        return table_row(row_idx, *this);
    }
 
 
    class table_cell
        cell(std::size_t row_idx, std::size_t col_idx)
    {
        return (*this)[row_idx][col_idx];
    }
 
    size_t
    cur_col() const noexcept
    {
        return ft_cur_col(table_);
    }
 
    size_t
    cur_row() const noexcept
    {
        return ft_cur_row(table_);
    }
 
    bool
    is_empty() const noexcept
    {
        return ft_is_empty(table_);
    }
 
    std::size_t
    row_count() const noexcept
    {
        return ft_row_count(table_);
    }
 
    std::size_t
    col_count() const noexcept
    {
        return ft_col_count(table_);
    }
 
    class table_cell
        cur_cell()
    {
        return cell(cur_row(), cur_col());
    }
 
    class table_row
        row(std::size_t row_idx)
    {
        return table_row(row_idx, *this);
    }
 
    class table_column
        column(std::size_t col_idx)
    {
        return table_column(col_idx, *this);
    }
 
    class cell_range
        range(std::size_t top_left_row, std::size_t top_left_col,
              std::size_t bottom_right_row, std::size_t bottom_right_col)
    {
        return cell_range(top_left_row, top_left_col,
                          bottom_right_row, bottom_right_col,
                          *this);
    }
 
    static class default_properties
        default_props()
    {
        return default_properties(NULL);
    }
};
 
using char_table = table<table_type::character>;
 
#ifdef FT_HAVE_UTF8
using utf8_table = table<table_type::utf8>;
#endif
 
inline bool set_default_border_style(struct ft_border_style *style)
{
    return FT_IS_SUCCESS(ft_set_default_border_style(style));
}
 
 
} // namespace fort
 
#endif // LIBFORT_HPP