Как переписать код на QT creator

#define HYPHENATOR_EXTERN
#include "hyphenator.h"
 
#include <vector>
#include <string>
#include <algorithm>
#include <cstddef>
#include <iostream>
 
struct pattern_t
{
    std::basic_string<unichar> str;
    std::vector<unsigned char> levels;
};
 
struct pattern_list_t
{
    std::vector<pattern_t*> list;
};
 
pattern_t* create_pattern(const unichar* str, isdigit_callback_t isdigit_callback, 
    ismarker_callback_t ismarker_callback, char2digit_callback_t char2digit_callback)
{
    if (!str || !isdigit_callback || !ismarker_callback || !char2digit_callback)
        return 0;
        
    pattern_t* p = new pattern_t;
    bool wait_digit = true;
    size_t i = 0;
    while (str[i])
    {
        unichar c = str[i];
        if (isdigit_callback(c))
        {
            p->levels.push_back(char2digit_callback(c));
            wait_digit = false;
        }
        else
        {
            if (!ismarker_callback(c) && wait_digit) p->levels.push_back(0);
            p->str.push_back(c);
            wait_digit = true;
        }
        ++i;
    }
    
    if (wait_digit) p->levels.push_back(0);
    return p;
}
 
void destroy_pattern(pattern_t* pattern)
{
    delete pattern;
}
 
pattern_list_t* create_pattern_list()
{
    pattern_list_t* pl = new pattern_list_t;
    return pl;  
}
 
void destroy_pattern_list(pattern_list_t* pattern_list)
{
    if (!pattern_list) return;
    std::vector<pattern_t*>::iterator i = pattern_list->list.begin();
    while (i != pattern_list->list.end())
    {
        destroy_pattern(*i);
        ++i;
    }
    delete pattern_list;
}
 
void add_patern(pattern_list_t* pattern_list, pattern_t* pattern)
{
    if (pattern_list && pattern && !pattern->str.empty())
        pattern_list->list.push_back(pattern);
}
 
static bool pattern_compare(const pattern_t* a, const pattern_t* b)
{
    bool first = a->str.size() < b->str.size();
    size_t min_size = first ? a->str.size() : b->str.size();
    for (size_t i = 0; i < min_size; ++i) 
    {
        if (a->str[i] < b->str[i]) 
            return true;
        else if (a->str[i] > b->str[i]) 
            return false;
    }
    return first;
}
 
void sort_pattern_list(pattern_list_t* pattern_list)
{
    if (!pattern_list) return;
    std::sort(pattern_list->list.begin(), pattern_list->list.end(), pattern_compare);
}
 
word_hyphenation_t* hyphenate_word(const unichar* word, const pattern_list_t* pattern_list, unichar marker)
{
    if (!word || !pattern_list) 
        return 0;
    
    std::basic_string<unichar> word_string;
    word_string.push_back(marker);
    word_string.append(word);
    word_string.push_back(marker);
 
    word_hyphenation_t* wh = new word_hyphenation_t;
    wh->mask = 0;
    wh->mask_size = 0;
    
    std::vector<unsigned char> levels;
    levels.assign(word_string.size(), 0);
    
    for (size_t i = 0; i < word_string.size()-2; ++i)
    {
        std::vector<pattern_t*>::const_iterator pattern_iter = pattern_list->list.begin();
        for (size_t count = 1; count <= word_string.size()-i; ++count)
        {
            pattern_t pattern_from_word;
            pattern_from_word.str = word_string.substr(i, count);
            if (pattern_compare(&pattern_from_word, *pattern_iter))
                continue;
            pattern_iter = std::lower_bound(pattern_iter, pattern_list->list.end(), &pattern_from_word, pattern_compare);
            if (pattern_iter == pattern_list->list.end())
                break;
            if (!pattern_compare(&pattern_from_word, *pattern_iter)) 
            {
                for (size_t level_i = 0; level_i < (*pattern_iter)->levels.size(); ++level_i)
                {
                    unsigned char l = (*pattern_iter)->levels[level_i];
                    if (l > levels[i+level_i]) 
                        levels[i+level_i] = l;
                }
            }
        }
    }
 
    wh->mask_size = levels.size()-2;
    wh->mask = new unsigned char[wh->mask_size];
    for (size_t i = 0; i < wh->mask_size; ++i)
    {
        if (levels[i+1] % 2 && i) 
            wh->mask[i] = 1;
        else 
            wh->mask[i] = 0;
    }
    
    return wh;
}
 
void destroy_word_hyphenation(word_hyphenation_t* wh)
{
    if (wh) delete [] wh->mask;
    delete wh;
}

#pragma once
 
struct pattern_t;
struct pattern_list_t;
 
struct word_hyphenation_t {
    unsigned char* mask;
    unsigned long mask_size;
};
 
//replace 'char' for unicode support
typedef char unichar;
 
//callbacks
typedef int (*isdigit_callback_t)(unichar c);
typedef int (*ismarker_callback_t)(unichar c);
typedef unsigned char (*char2digit_callback_t)(unichar c);
 
#ifdef HYPHENATOR_EXTERN
extern "C" {
#endif
    
struct pattern_t* create_pattern(const unichar* str, isdigit_callback_t isdigit_callback, 
                                 ismarker_callback_t ismarker_callback, char2digit_callback_t char2digit_callback);
 
void destroy_pattern(struct pattern_t* pattern);
 
struct pattern_list_t* create_pattern_list();
void destroy_pattern_list(struct pattern_list_t* pattern_list);
void add_patern(struct pattern_list_t* pattern_list, struct pattern_t* pattern);
void sort_pattern_list(struct pattern_list_t* pattern_list);
 
struct word_hyphenation_t* hyphenate_word(const unichar* word, const struct pattern_list_t* pattern_list, unichar marker);
void destroy_word_hyphenation(struct word_hyphenation_t* wh);
    
    
#ifdef HYPHENATOR_EXTERN
};
#endif