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
            RNGScope RCPP_rngScope_gen;
37
            rcpp_result_gen = p_fstlib_version();
38
        }
39
        if (rcpp_result_gen.inherits("interrupted-error"))
40
            throw Rcpp::internal::InterruptedException();
41
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
42
            throw Rcpp::LongjumpException(rcpp_result_gen);
43
        if (rcpp_result_gen.inherits("try-error"))
44
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
45
        return Rcpp::as<int >(rcpp_result_gen);
46
    }
47

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

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

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

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

132
    inline SEXP fstcomp(SEXP rawVec, SEXP compressor, SEXP compression, SEXP hash) {
133
        typedef SEXP(*Ptr_fstcomp)(SEXP,SEXP,SEXP,SEXP);
134
        static Ptr_fstcomp p_fstcomp = NULL;
135
        if (p_fstcomp == NULL) {
136
            validateSignature("SEXP(*fstcomp)(SEXP,SEXP,SEXP,SEXP)");
137
            p_fstcomp = (Ptr_fstcomp)R_GetCCallable("fstcore", "_fstcore_fstcomp");
138
        }
139
        RObject rcpp_result_gen;
140
        {
141
            RNGScope RCPP_rngScope_gen;
142
            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)));
143
        }
144
        if (rcpp_result_gen.inherits("interrupted-error"))
145
            throw Rcpp::internal::InterruptedException();
146
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
147
            throw Rcpp::LongjumpException(rcpp_result_gen);
148
        if (rcpp_result_gen.inherits("try-error"))
149
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
150
        return Rcpp::as<SEXP >(rcpp_result_gen);
151
    }
152

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

174
    inline SEXP getnrofthreads() {
175
        typedef SEXP(*Ptr_getnrofthreads)();
176
        static Ptr_getnrofthreads p_getnrofthreads = NULL;
177
        if (p_getnrofthreads == NULL) {
178
            validateSignature("SEXP(*getnrofthreads)()");
179
            p_getnrofthreads = (Ptr_getnrofthreads)R_GetCCallable("fstcore", "_fstcore_getnrofthreads");
180
        }
181
        RObject rcpp_result_gen;
182
        {
183
            RNGScope RCPP_rngScope_gen;
184
            rcpp_result_gen = p_getnrofthreads();
185
        }
186
        if (rcpp_result_gen.inherits("interrupted-error"))
187
            throw Rcpp::internal::InterruptedException();
188
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
189
            throw Rcpp::LongjumpException(rcpp_result_gen);
190
        if (rcpp_result_gen.inherits("try-error"))
191
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
192
        return Rcpp::as<SEXP >(rcpp_result_gen);
193
    }
194

195
    inline int setnrofthreads(SEXP nrOfThreads) {
196
        typedef SEXP(*Ptr_setnrofthreads)(SEXP);
197
        static Ptr_setnrofthreads p_setnrofthreads = NULL;
198
        if (p_setnrofthreads == NULL) {
199
            validateSignature("int(*setnrofthreads)(SEXP)");
200
            p_setnrofthreads = (Ptr_setnrofthreads)R_GetCCallable("fstcore", "_fstcore_setnrofthreads");
201
        }
202
        RObject rcpp_result_gen;
203
        {
204
            RNGScope RCPP_rngScope_gen;
205
            rcpp_result_gen = p_setnrofthreads(Shield<SEXP>(Rcpp::wrap(nrOfThreads)));
206
        }
207
        if (rcpp_result_gen.inherits("interrupted-error"))
208
            throw Rcpp::internal::InterruptedException();
209
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
210
            throw Rcpp::LongjumpException(rcpp_result_gen);
211
        if (rcpp_result_gen.inherits("try-error"))
212
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
213
        return Rcpp::as<int >(rcpp_result_gen);
214
    }
215

216
    inline SEXP hasopenmp() {
217
        typedef SEXP(*Ptr_hasopenmp)();
218
        static Ptr_hasopenmp p_hasopenmp = NULL;
219
        if (p_hasopenmp == NULL) {
220
            validateSignature("SEXP(*hasopenmp)()");
221
            p_hasopenmp = (Ptr_hasopenmp)R_GetCCallable("fstcore", "_fstcore_hasopenmp");
222
        }
223
        RObject rcpp_result_gen;
224
        {
225
            RNGScope RCPP_rngScope_gen;
226
            rcpp_result_gen = p_hasopenmp();
227
        }
228
        if (rcpp_result_gen.inherits("interrupted-error"))
229
            throw Rcpp::internal::InterruptedException();
230
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
231
            throw Rcpp::LongjumpException(rcpp_result_gen);
232
        if (rcpp_result_gen.inherits("try-error"))
233
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
234
        return Rcpp::as<SEXP >(rcpp_result_gen);
235
    }
236

237
    inline void restore_after_fork(bool restore) {
238
        typedef SEXP(*Ptr_restore_after_fork)(SEXP);
239
        static Ptr_restore_after_fork p_restore_after_fork = NULL;
240
        if (p_restore_after_fork == NULL) {
241
            validateSignature("void(*restore_after_fork)(bool)");
242
            p_restore_after_fork = (Ptr_restore_after_fork)R_GetCCallable("fstcore", "_fstcore_restore_after_fork");
243
        }
244
        RObject rcpp_result_gen;
245
        {
246
            RNGScope RCPP_rngScope_gen;
247
            rcpp_result_gen = p_restore_after_fork(Shield<SEXP>(Rcpp::wrap(restore)));
248
        }
249
        if (rcpp_result_gen.inherits("interrupted-error"))
250
            throw Rcpp::internal::InterruptedException();
251
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
252
            throw Rcpp::LongjumpException(rcpp_result_gen);
253
        if (rcpp_result_gen.inherits("try-error"))
254
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
255
    }
256

257
}
258

259
#endif // RCPP_fstcore_RCPPEXPORTS_H_GEN_

Read our documentation on viewing source code .

Loading