mlt-ffi 0.1.35

Diplomat FFI bindings for mlt-core
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#ifndef MltEncoderOptions_HPP
#define MltEncoderOptions_HPP

#include "MltEncoderOptions.d.hpp"

#include "MltWireVersion.hpp"
#include "diplomat_runtime.hpp"
#include <cstdlib>
#include <functional>
#include <memory>
#include <optional>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

namespace diplomat {
namespace capi {
extern "C" {

diplomat::capi::MltEncoderOptions* MltEncoderOptions_new(void);

void MltEncoderOptions_set_tessellate(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_attempt_spatial_morton_sort(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_attempt_spatial_hilbert_sort(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_attempt_id_sort(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_fsst(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_fastpfor(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_shared_dict(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_wire_version(diplomat::capi::MltEncoderOptions* self,
                                        diplomat::capi::MltWireVersion version);

void MltEncoderOptions_set_allow_triangles_only(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_delta2(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_float_dict(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_float_alp(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_packed_dict_codes(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_rans_vertices(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_set_allow_row_shapes(diplomat::capi::MltEncoderOptions* self, bool enabled);

void MltEncoderOptions_destroy(MltEncoderOptions* self);

} // extern "C"
} // namespace capi
} // namespace diplomat

inline std::unique_ptr<MltEncoderOptions> MltEncoderOptions::new_() {
    auto result = diplomat::capi::MltEncoderOptions_new();
    return std::unique_ptr<MltEncoderOptions>(MltEncoderOptions::FromFFI(result));
}

inline void MltEncoderOptions::set_tessellate(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_tessellate(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_attempt_spatial_morton_sort(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_attempt_spatial_morton_sort(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_attempt_spatial_hilbert_sort(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_attempt_spatial_hilbert_sort(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_attempt_id_sort(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_attempt_id_sort(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_fsst(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_fsst(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_fastpfor(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_fastpfor(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_shared_dict(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_shared_dict(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_wire_version(MltWireVersion version) {
    diplomat::capi::MltEncoderOptions_set_wire_version(this->AsFFI(), version.AsFFI());
}

inline void MltEncoderOptions::set_allow_triangles_only(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_triangles_only(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_delta2(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_delta2(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_float_dict(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_float_dict(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_float_alp(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_float_alp(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_packed_dict_codes(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_packed_dict_codes(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_rans_vertices(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_rans_vertices(this->AsFFI(), enabled);
}

inline void MltEncoderOptions::set_allow_row_shapes(bool enabled) {
    diplomat::capi::MltEncoderOptions_set_allow_row_shapes(this->AsFFI(), enabled);
}

inline const diplomat::capi::MltEncoderOptions* MltEncoderOptions::AsFFI() const {
    return reinterpret_cast<const diplomat::capi::MltEncoderOptions*>(this);
}

inline diplomat::capi::MltEncoderOptions* MltEncoderOptions::AsFFI() {
    return reinterpret_cast<diplomat::capi::MltEncoderOptions*>(this);
}

inline const MltEncoderOptions* MltEncoderOptions::FromFFI(const diplomat::capi::MltEncoderOptions* ptr) {
    return reinterpret_cast<const MltEncoderOptions*>(ptr);
}

inline MltEncoderOptions* MltEncoderOptions::FromFFI(diplomat::capi::MltEncoderOptions* ptr) {
    return reinterpret_cast<MltEncoderOptions*>(ptr);
}

inline void MltEncoderOptions::operator delete(void* ptr) {
    diplomat::capi::MltEncoderOptions_destroy(reinterpret_cast<diplomat::capi::MltEncoderOptions*>(ptr));
}

#endif // MltEncoderOptions_HPP