Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/vis15/src/lib/include/diderot/dynseq-inst.hxx
ViewVC logotype

Annotation of /branches/vis15/src/lib/include/diderot/dynseq-inst.hxx

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5116 - (view) (download) (as text)

1 : jhr 3981 /*! \file dynseq-inst.hxx
2 :     *
3 :     * \author John Reppy
4 :     */
5 :    
6 :     /*
7 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
8 :     *
9 :     * COPYRIGHT (c) 2016 The University of Chicago
10 :     * All rights reserved.
11 :     */
12 :    
13 :     #ifndef _DIDEROT_DYNSEQ_INST_HXX_
14 :     #define _DIDEROT_DYNSEQ_INST_HXX_
15 :    
16 :     #ifndef _DIDEROT_DYNSEQ_HXX_
17 :     # error dynseq-inst.hxx should not be directly included
18 :     #endif
19 :    
20 :     namespace diderot {
21 :    
22 : jhr 3982 //! construct a sequence for a range lo..hi (integer types only)
23 :     template <typename T>
24 :     dynseq<T>::dynseq (T const &lo, T const &hi)
25 : jhr 4351 : _seq(std::make_shared<std::vector<T>>(std::vector<T>()))
26 : jhr 3982 {
27 : jhr 4351 if (lo <= hi) {
28 :     this->_seq->reserve (hi - lo + 1);
29 :     for (T i = lo; i <= hi; ++i) {
30 :     this->_seq->push_back(i);
31 :     }
32 :     }
33 : jhr 3982 }
34 :    
35 :     //! copy constructor with additional space reserved
36 :     template <typename T>
37 :     dynseq<T>::dynseq (const dynseq &seq, uint32_t n)
38 : jhr 4412 : _seq(std::make_shared<std::vector<T>>(std::vector<T>(*(seq._seq))))
39 : jhr 3982 {
40 : jhr 4533 this->_seq->reserve (n);
41 : jhr 3982 }
42 :    
43 : jhr 4032 //! return the contents of a nrrd as a dynamic sequence
44 :     //! \param wrld the world; used to report errors
45 :     //! \param nin the source nrrd to copy
46 :     //! \param sts error status; set to true if there was an error
47 : jhr 3988 template <typename T>
48 : jhr 4071 bool dynseq<T>::load (world_base *wrld, const Nrrd *nin)
49 : jhr 4032 {
50 : jhr 4526 uint32_t nValuesPerElem = dynseq<T>::traits::values_per_elem;
51 : jhr 4351 size_t baseSz = sizeof(typename dynseq<T>::traits::base_type);
52 :     size_t elemSz = baseSz * nValuesPerElem;
53 : jhr 4032
54 : jhr 4526 if (wrld->check_seq_nrrd (nin, nValuesPerElem)) {
55 : jhr 4351 return true;
56 :     }
57 : jhr 4032
58 : jhr 4351 // if (dynseq<T>::traits::check_type(nin->type)) {
59 :     // wrld->error ("element type mismatch in nrrd file");
60 :     // sts = true;
61 :     // return dynseq<T>();
62 :     // }
63 : jhr 4032
64 :     // get the number of elements
65 : jhr 4526 size_t nElems;
66 : jhr 4533 if (nValuesPerElem == 1) {
67 :     nElems = nin->axis[0].size;
68 :     }
69 :     else {
70 :     nElems = nin->axis[1].size;
71 :     }
72 : jhr 4032
73 :     // allocate the result sequence object
74 : jhr 4351 this->_seq->resize(nElems);
75 : jhr 4032
76 :     // initialize the sequence from the nrrd
77 : jhr 4351 typename dynseq<T>::traits::base_type *dst =
78 :     reinterpret_cast<typename dynseq<T>::traits::base_type *>(this->data());
79 : jhr 4032
80 : jhr 4351 if (__details::nrrd_type_info[nin->type].sizeb != baseSz) {
81 :     // this is the slow path; we have to convert values as they are copied from the nrrd
82 :     __details::load_fn_ptr<typename dynseq<T>::traits::base_type> loadFn =
83 :     dynseq<T>::traits::load_fn_tbl[nin->type];
84 :     char *src = (char *)nin->data;
85 :     size_t srcElemSz = __details::nrrd_type_info[nin->type].sizeb;
86 :     for (size_t i = 0; i < nElems * nValuesPerElem; i++) {
87 :     *dst++ = loadFn(src);
88 :     src += srcElemSz;
89 :     }
90 :     }
91 :     else {
92 :     // this is the fast path, where we can just do a bulk memcpy
93 : jhr 4398 std::memcpy (dst, nin->data, nElems * elemSz);
94 : jhr 4351 }
95 : jhr 4032
96 : jhr 4351 return false;
97 : jhr 4032
98 :     }
99 :    
100 :     template <typename T>
101 : jhr 4071 bool dynseq<T>::load (world_base *wrld, std::string const &file)
102 : jhr 3988 {
103 : jhr 4351 Nrrd *nin = wrld->load_nrrd_file (file);
104 :     if (nin == nullptr) { // there was an error, so we return the empty sequence
105 :     return true;
106 :     }
107 :     else {
108 :     this->load (wrld, nin);
109 :     nrrdNuke(nin);
110 :     return false;
111 :     }
112 : jhr 3988 }
113 :    
114 : jhr 4071 template <typename T>
115 : jhr 5108 dynseq<T> &dynseq<T>::operator= (std::initializer_list<T> il)
116 :     {
117 :     std::shared_ptr<std::vector<T>> _seq;
118 :    
119 :     this->_seq->clear();
120 :     this->_seq->reserve(il.size());
121 : jhr 5113 for (auto it = il.begin(); it != il.end(); ++it) {
122 :     this->_seq->push_back (*it);
123 :     }
124 : jhr 5108 return *this;
125 :     }
126 :    
127 :     template <typename T>
128 : jhr 4071 dynseq<T> &dynseq<T>::prepend (T const &x)
129 :     {
130 : jhr 4351 this->_seq->insert (this->_seq->begin(), x);
131 :     return *this;
132 : jhr 4071 }
133 :    
134 :     template <typename T>
135 : jhr 4412 dynseq<T> &dynseq<T>::prepend (const void *datap)
136 :     {
137 :     this->_seq->insert (this->_seq->begin(), T());
138 : jhr 4533 std::memcpy (this->_seq->data(), datap, sizeof(T));
139 : jhr 4412 return *this;
140 :     }
141 :    
142 :     template <typename T>
143 : jhr 4071 dynseq<T> &dynseq<T>::append (T const &x)
144 :     {
145 : jhr 4351 this->_seq->push_back(x);
146 :     return *this;
147 : jhr 4071 }
148 :    
149 :     template <typename T>
150 : jhr 4412 dynseq<T> &dynseq<T>::append (const void *datap)
151 :     {
152 :     size_t nbytes = this->_seq->size() * sizeof(T); // before adding space for element!
153 :     this->_seq->push_back(T());
154 : jhr 4533 std::memcpy (reinterpret_cast<char *>(this->_seq->data())+nbytes, datap, sizeof(T));
155 : jhr 4412 return *this;
156 :     }
157 :    
158 :     template <typename T>
159 : jhr 4071 dynseq<T> &dynseq<T>::concat (dynseq<T> const &seq)
160 :     {
161 : jhr 4351 this->_seq->reserve (this->length() + seq.length());
162 :     for (auto it = seq.cbegin(); it != seq.cend(); ++it) {
163 :     this->_seq->push_back (*it);
164 :     }
165 :     return *this;
166 : jhr 4071 }
167 :    
168 :     template <typename T>
169 :     char *dynseq<T>::copy_to (char *cp)
170 :     {
171 : jhr 4351 size_t nbytes = this->_seq->size() * sizeof(T);
172 : jhr 4398 std::memcpy (cp, this->_seq->data(), nbytes);
173 : jhr 4351 return cp + nbytes;
174 : jhr 4071 }
175 :    
176 : jhr 4530 // printer for dynamic sequences
177 :     template <typename T>
178 :     static std::ostream& operator<< (std::ostream &outs, dynseq<T> const &seq)
179 :     {
180 : jhr 4533 outs << "{";
181 :     size_t n = seq.length();
182 :     if (n > 0) {
183 :     outs << seq[0];
184 :     for (size_t i = 1; i < n; i++) {
185 :     outs << "," << seq[i];
186 :     }
187 :     }
188 :     outs << "}";
189 :     return outs;
190 : jhr 4530 }
191 :    
192 : jhr 3981 } // namespace diderot
193 :    
194 :     #endif // !_DIDEROT_DYNSEQ_INST_HXX_

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0