fstpackage / fstcore
1
// Generated by using Rcpp::compileAttributes() -> do not edit by hand
2
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
3

4
#ifndef RCPP_fstcore_RCPPEXPORTS_H_GEN_
5
#define RCPP_fstcore_RCPPEXPORTS_H_GEN_
6

7
#include <Rcpp.h>
8

9
namespace fstcore {
10

11
    using namespace Rcpp;
12

13
    namespace {
14 0
        void validateSignature(const char* sig) {
15 0
            Rcpp::Function require = Rcpp::Environment::base_env()["require"];
16 0
            require("fstcore", Rcpp::Named("quietly") = true);
17
            typedef int(*Ptr_validate)(const char*);
18
            static Ptr_validate p_validate = (Ptr_validate)
19 0
                R_GetCCallable("fstcore", "_fstcore_RcppExport_validate");
20 0
            if (!p_validate(sig)) {
21
                throw Rcpp::function_not_exported(
22 0
                    "C++ function with signature '" + std::string(sig) + "' not found in fstcore");
23
            }
24
        }
25
    }
26

27
    inline int fstlib_version() {
28
        typedef SEXP(*Ptr_fstlib_version)();
29
        static Ptr_fstlib_version p_fstlib_version = NULL;
30
        if (p_fstlib_version == NULL) {
31
            validateSignature("int(*fstlib_version)()");
32
            p_fstlib_version = (Ptr_fstlib_version)R_GetCCallable("fstcore", "_fstcore_fstlib_version");
33
        }
34
        RObject rcpp_result_gen;
35
        {
36
            rcpp_result_gen = p_fstlib_version();
37
        }
38
        if (rcpp_result_gen.inherits("interrupted-error"))
39
            throw Rcpp::internal::InterruptedException();
40
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
41
            throw Rcpp::LongjumpException(rcpp_result_gen);
42
        if (rcpp_result_gen.inherits("try-error"))
43
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
44
        return Rcpp::as<int >(rcpp_result_gen);
45
    }
46

47
    inline SEXP fststore(Rcpp::String fileName, SEXP table, SEXP compression, SEXP uniformEncoding) {
48
        typedef SEXP(*Ptr_fststore)(SEXP,SEXP,SEXP,SEXP);
49
        static Ptr_fststore p_fststore = NULL;
50
        if (p_fststore == NULL) {
51
            validateSignature("SEXP(*fststore)(Rcpp::String,SEXP,SEXP,SEXP)");
52
            p_fststore = (Ptr_fststore)R_GetCCallable("fstcore", "_fstcore_fststore");
53
        }
54
        RObject rcpp_result_gen;
55
        {
56
            rcpp_result_gen = p_fststore(Shield<SEXP>(Rcpp::wrap(fileName)), Shield<SEXP>(Rcpp::wrap(table)), Shield<SEXP>(Rcpp::wrap(compression)), Shield<SEXP>(Rcpp::wrap(uniformEncoding)));
57
        }
58
        if (rcpp_result_gen.inherits("interrupted-error"))
59
            throw Rcpp::internal::InterruptedException();
60
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
61
            throw Rcpp::LongjumpException(rcpp_result_gen);
62
        if (rcpp_result_gen.inherits("try-error"))
63
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
64
        return Rcpp::as<SEXP >(rcpp_result_gen);
65
    }
66

67
    inline SEXP fstmetadata(Rcpp::String fileName) {
68
        typedef SEXP(*Ptr_fstmetadata)(SEXP);
69
        static Ptr_fstmetadata p_fstmetadata = NULL;
70
        if (p_fstmetadata == NULL) {
71
            validateSignature("SEXP(*fstmetadata)(Rcpp::String)");
72
            p_fstmetadata = (Ptr_fstmetadata)R_GetCCallable("fstcore", "_fstcore_fstmetadata");
73
        }
74
        RObject rcpp_result_gen;
75
        {
76
            rcpp_result_gen = p_fstmetadata(Shield<SEXP>(Rcpp::wrap(fileName)));
77
        }
78
        if (rcpp_result_gen.inherits("interrupted-error"))
79
            throw Rcpp::internal::InterruptedException();
80
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
81
            throw Rcpp::LongjumpException(rcpp_result_gen);
82
        if (rcpp_result_gen.inherits("try-error"))
83
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
84
        return Rcpp::as<SEXP >(rcpp_result_gen);
85
    }
86

87
    inline SEXP fstretrieve(Rcpp::String fileName, SEXP columnSelection, SEXP startRow, SEXP endRow) {
88
        typedef SEXP(*Ptr_fstretrieve)(SEXP,SEXP,SEXP,SEXP);
89
        static Ptr_fstretrieve p_fstretrieve = NULL;
90
        if (p_fstretrieve == NULL) {
91
            validateSignature("SEXP(*fstretrieve)(Rcpp::String,SEXP,SEXP,SEXP)");
92
            p_fstretrieve = (Ptr_fstretrieve)R_GetCCallable("fstcore", "_fstcore_fstretrieve");
93
        }
94
        RObject rcpp_result_gen;
95
        {
96
            rcpp_result_gen = p_fstretrieve(Shield<SEXP>(Rcpp::wrap(fileName)), Shield<SEXP>(Rcpp::wrap(columnSelection)), Shield<SEXP>(Rcpp::wrap(startRow)), Shield<SEXP>(Rcpp::wrap(endRow)));
97
        }
98
        if (rcpp_result_gen.inherits("interrupted-error"))
99
            throw Rcpp::internal::InterruptedException();
100
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
101
            throw Rcpp::LongjumpException(rcpp_result_gen);
102
        if (rcpp_result_gen.inherits("try-error"))
103
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
104
        return Rcpp::as<SEXP >(rcpp_result_gen);
105
    }
106

107
    inline SEXP fsthasher(SEXP rawVec, SEXP seed, SEXP blockHash) {
108
        typedef SEXP(*Ptr_fsthasher)(SEXP,SEXP,SEXP);
109
        static Ptr_fsthasher p_fsthasher = NULL;
110
        if (p_fsthasher == NULL) {
111
            validateSignature("SEXP(*fsthasher)(SEXP,SEXP,SEXP)");
112
            p_fsthasher = (Ptr_fsthasher)R_GetCCallable("fstcore", "_fstcore_fsthasher");
113
        }
114
        RObject rcpp_result_gen;
115
        {
116
            rcpp_result_gen = p_fsthasher(Shield<SEXP>(Rcpp::wrap(rawVec)), Shield<SEXP>(Rcpp::wrap(seed)), Shield<SEXP>(Rcpp::wrap(blockHash)));
117
        }
118
        if (rcpp_result_gen.inherits("interrupted-error"))
119
            throw Rcpp::internal::InterruptedException();
120
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
121
            throw Rcpp::LongjumpException(rcpp_result_gen);
122
        if (rcpp_result_gen.inherits("try-error"))
123
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
124
        return Rcpp::as<SEXP >(rcpp_result_gen);
125
    }
126

127
    inline SEXP fstcomp(SEXP rawVec, SEXP compressor, SEXP compression, SEXP hash) {
128
        typedef SEXP(*Ptr_fstcomp)(SEXP,SEXP,SEXP,SEXP);
129
        static Ptr_fstcomp p_fstcomp = NULL;
130
        if (p_fstcomp == NULL) {
131
            validateSignature("SEXP(*fstcomp)(SEXP,SEXP,SEXP,SEXP)");
132
            p_fstcomp = (Ptr_fstcomp)R_GetCCallable("fstcore", "_fstcore_fstcomp");
133
        }
134
        RObject rcpp_result_gen;
135
        {
136
            rcpp_result_gen = p_fstcomp(Shield<SEXP>(Rcpp::wrap(rawVec)), Shield<SEXP>(Rcpp::wrap(compressor)), Shield<SEXP>(Rcpp::wrap(compression)), Shield<SEXP>(Rcpp::wrap(hash)));
137
        }
138
        if (rcpp_result_gen.inherits("interrupted-error"))
139
            throw Rcpp::internal::InterruptedException();
140
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
141
            throw Rcpp::LongjumpException(rcpp_result_gen);
142
        if (rcpp_result_gen.inherits("try-error"))
143
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
144
        return Rcpp::as<SEXP >(rcpp_result_gen);
145
    }
146

147
    inline SEXP fstdecomp(SEXP rawVec) {
148
        typedef SEXP(*Ptr_fstdecomp)(SEXP);
149
        static Ptr_fstdecomp p_fstdecomp = NULL;
150
        if (p_fstdecomp == NULL) {
151
            validateSignature("SEXP(*fstdecomp)(SEXP)");
152
            p_fstdecomp = (Ptr_fstdecomp)R_GetCCallable("fstcore", "_fstcore_fstdecomp");
153
        }
154
        RObject rcpp_result_gen;
155
        {
156
            rcpp_result_gen = p_fstdecomp(Shield<SEXP>(Rcpp::wrap(rawVec)));
157
        }
158
        if (rcpp_result_gen.inherits("interrupted-error"))
159
            throw Rcpp::internal::InterruptedException();
160
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
161
            throw Rcpp::LongjumpException(rcpp_result_gen);
162
        if (rcpp_result_gen.inherits("try-error"))
163
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
164
        return Rcpp::as<SEXP >(rcpp_result_gen);
165
    }
166

167
    inline SEXP getnrofthreads() {
168
        typedef SEXP(*Ptr_getnrofthreads)();
169
        static Ptr_getnrofthreads p_getnrofthreads = NULL;
170
        if (p_getnrofthreads == NULL) {
171
            validateSignature("SEXP(*getnrofthreads)()");
172
            p_getnrofthreads = (Ptr_getnrofthreads)R_GetCCallable("fstcore", "_fstcore_getnrofthreads");
173
        }
174
        RObject rcpp_result_gen;
175
        {
176
            rcpp_result_gen = p_getnrofthreads();
177
        }
178
        if (rcpp_result_gen.inherits("interrupted-error"))
179
            throw Rcpp::internal::InterruptedException();
180
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
181
            throw Rcpp::LongjumpException(rcpp_result_gen);
182
        if (rcpp_result_gen.inherits("try-error"))
183
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
184
        return Rcpp::as<SEXP >(rcpp_result_gen);
185
    }
186

187
    inline int setnrofthreads(SEXP nrOfThreads) {
188
        typedef SEXP(*Ptr_setnrofthreads)(SEXP);
189
        static Ptr_setnrofthreads p_setnrofthreads = NULL;
190
        if (p_setnrofthreads == NULL) {
191
            validateSignature("int(*setnrofthreads)(SEXP)");
192
            p_setnrofthreads = (Ptr_setnrofthreads)R_GetCCallable("fstcore", "_fstcore_setnrofthreads");
193
        }
194
        RObject rcpp_result_gen;
195
        {
196
            rcpp_result_gen = p_setnrofthreads(Shield<SEXP>(Rcpp::wrap(nrOfThreads)));
197
        }
198
        if (rcpp_result_gen.inherits("interrupted-error"))
199
            throw Rcpp::internal::InterruptedException();
200
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
201
            throw Rcpp::LongjumpException(rcpp_result_gen);
202
        if (rcpp_result_gen.inherits("try-error"))
203
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
204
        return Rcpp::as<int >(rcpp_result_gen);
205
    }
206

207
    inline SEXP hasopenmp() {
208
        typedef SEXP(*Ptr_hasopenmp)();
209
        static Ptr_hasopenmp p_hasopenmp = NULL;
210
        if (p_hasopenmp == NULL) {
211
            validateSignature("SEXP(*hasopenmp)()");
212
            p_hasopenmp = (Ptr_hasopenmp)R_GetCCallable("fstcore", "_fstcore_hasopenmp");
213
        }
214
        RObject rcpp_result_gen;
215
        {
216
            rcpp_result_gen = p_hasopenmp();
217
        }
218
        if (rcpp_result_gen.inherits("interrupted-error"))
219
            throw Rcpp::internal::InterruptedException();
220
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
221
            throw Rcpp::LongjumpException(rcpp_result_gen);
222
        if (rcpp_result_gen.inherits("try-error"))
223
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
224
        return Rcpp::as<SEXP >(rcpp_result_gen);
225
    }
226

227
    inline void restore_after_fork(bool restore) {
228
        typedef SEXP(*Ptr_restore_after_fork)(SEXP);
229
        static Ptr_restore_after_fork p_restore_after_fork = NULL;
230
        if (p_restore_after_fork == NULL) {
231
            validateSignature("void(*restore_after_fork)(bool)");
232
            p_restore_after_fork = (Ptr_restore_after_fork)R_GetCCallable("fstcore", "_fstcore_restore_after_fork");
233
        }
234
        RObject rcpp_result_gen;
235
        {
236
            rcpp_result_gen = p_restore_after_fork(Shield<SEXP>(Rcpp::wrap(restore)));
237
        }
238
        if (rcpp_result_gen.inherits("interrupted-error"))
239
            throw Rcpp::internal::InterruptedException();
240
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
241
            throw Rcpp::LongjumpException(rcpp_result_gen);
242
        if (rcpp_result_gen.inherits("try-error"))
243
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
244
    }
245

246
    inline bool is_forked() {
247
        typedef SEXP(*Ptr_is_forked)();
248
        static Ptr_is_forked p_is_forked = NULL;
249
        if (p_is_forked == NULL) {
250
            validateSignature("bool(*is_forked)()");
251
            p_is_forked = (Ptr_is_forked)R_GetCCallable("fstcore", "_fstcore_is_forked");
252
        }
253
        RObject rcpp_result_gen;
254
        {
255
            rcpp_result_gen = p_is_forked();
256
        }
257
        if (rcpp_result_gen.inherits("interrupted-error"))
258
            throw Rcpp::internal::InterruptedException();
259
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
260
            throw Rcpp::LongjumpException(rcpp_result_gen);
261
        if (rcpp_result_gen.inherits("try-error"))
262
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
263
        return Rcpp::as<bool >(rcpp_result_gen);
264
    }
265

266
}
267

268
#endif // RCPP_fstcore_RCPPEXPORTS_H_GEN_

Read our documentation on viewing source code .

Loading