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
|
// ListOf.h: Rcpp R/C++ interface class library -- templated List container
//
// Copyright (C) 2014 Dirk Eddelbuettel, Romain Francois and Kevin Ushey
//
// This file is part of Rcpp.
//
// Rcpp is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// Rcpp is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rcpp. If not, see <http://www.gnu.org/licenses/>.
#ifndef Rcpp_vector_ListOf_h_
#define Rcpp_vector_ListOf_h_
namespace Rcpp {
template <typename T>
class ListOf
: public NamesProxyPolicy<T>
, public AttributeProxyPolicy<T>
, public RObjectMethods<T>
{
public:
typedef typename traits::r_vector_iterator<VECSXP>::type iterator;
typedef typename traits::r_vector_const_iterator<VECSXP>::type const_iterator;
ListOf(): list(R_NilValue) {}
ListOf(SEXP data_): list(data_) {
std::transform(list.begin(), list.end(), list.begin(), as<T>);
}
template <typename U>
ListOf(const U& data_): list(data_) {
std::transform(list.begin(), list.end(), list.begin(), as<T>);
}
ListOf(const ListOf& other): list(other.list) {}
ListOf& operator=(const ListOf& other) {
if (this != &other) {
list = other.list;
}
return *this;
}
template <typename U>
ListOf& operator=(const U& other) {
list = as<List>(other);
return *this;
}
// subsetting operators
ChildVector<T> operator[](R_xlen_t i) {
return ChildVector<T>(list[i], list, i);
}
const ChildVector<T> operator[](R_xlen_t i) const {
return ChildVector<T>(list[i], list, i);
}
ChildVector<T> operator[](const std::string& str) {
return ChildVector<T>(list[str], list, list.findName(str));
}
const ChildVector<T> operator[](const std::string& str) const {
return ChildVector<T>(list[str], list, list.findName(str));
}
// iteration operators pass down to list
inline iterator begin() {
return list.begin();
}
inline iterator end() {
return list.end();
}
inline const_iterator begin() const {
return list.begin();
}
inline const_iterator end() const {
return list.end();
}
inline R_xlen_t size() const {
return list.size() ;
}
inline List get() const {
return list;
}
// conversion operators
operator SEXP() const { return wrap(list); }
operator List() const { return list; }
private:
List list;
}; // ListOf<T>
// sapply, lapply wrappers
namespace sugar {
template <int RTYPE, bool NA, typename T, typename Function>
class Lapply;
template <int RTYPE, bool NA, typename T, typename Function, bool NO_CONVERSION>
class Sapply;
}
template <typename T, typename Function>
List lapply(const ListOf<T>& t, Function fun) {
return lapply(t.get(), fun);
}
template <typename T, typename Function>
T sapply(const ListOf<T>& t, Function fun) {
return sapply(t.get(), fun);
}
} // Rcpp
#endif
|
