Mercurial > octave

comparison libinterp/corefcn/oct-map.h @ 29922:adda9f3ac61f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use m_ prefix for data members in octave_map classes * oct-map.h, oct-map.cc: Use m_ prefix for class data members.
author John W. Eaton <jwe@octave.org>
date Tue, 27 Jul 2021 09:53:16 -0400
parents 29a1f8fd8ee6
children 796f54d4ddbf
comparison
equal deleted inserted replaced
29921:6b7ac07ffa85 29922:adda9f3ac61f
43 octave_fields 43 octave_fields
44 { 44 {
45 class fields_rep : public std::map<std::string, octave_idx_type> 45 class fields_rep : public std::map<std::string, octave_idx_type>
46 { 46 {
47 public: 47 public:
48 fields_rep (void) : std::map<std::string, octave_idx_type> (), count (1) { } 48 fields_rep (void) : std::map<std::string, octave_idx_type> (), m_count (1) { }
49 fields_rep (const fields_rep& other) 49 fields_rep (const fields_rep& other)
50 : std::map<std::string, octave_idx_type> (other), count (1) { } 50 : std::map<std::string, octave_idx_type> (other), m_count (1) { }
51 51
52 octave::refcount<octave_idx_type> count; 52 octave::refcount<octave_idx_type> m_count;
53 53
54 private: 54 private:
55 fields_rep& operator = (const fields_rep&); // no assignment! 55 fields_rep& operator = (const fields_rep&); // no assignment!
56 }; 56 };
57 57
58 fields_rep *rep; 58 fields_rep *m_rep;
59 59
60 static fields_rep *nil_rep (void); 60 static fields_rep *nil_rep (void);
61 61
62 public: 62 public:
63 63
64 octave_fields (void) : rep (nil_rep ()) { rep->count++; } 64 octave_fields (void) : m_rep (nil_rep ()) { m_rep->m_count++; }
65 octave_fields (const string_vector&); 65 octave_fields (const string_vector&);
66 octave_fields (const char * const *); 66 octave_fields (const char * const *);
67 67
68 ~octave_fields (void) 68 ~octave_fields (void)
69 { 69 {
70 if (--rep->count == 0) 70 if (--m_rep->m_count == 0)
71 delete rep; 71 delete m_rep;
72 } 72 }
73 73
74 void make_unique (void) 74 void make_unique (void)
75 { 75 {
76 if (rep->count > 1) 76 if (m_rep->m_count > 1)
77 { 77 {
78 fields_rep *r = new fields_rep (*rep); 78 fields_rep *r = new fields_rep (*m_rep);
79 79
80 if (--rep->count == 0) 80 if (--m_rep->m_count == 0)
81 delete rep; 81 delete m_rep;
82 82
83 rep = r; 83 m_rep = r;
84 } 84 }
85 } 85 }
86 86
87 octave_fields (const octave_fields& o) : rep (o.rep) { rep->count++; } 87 octave_fields (const octave_fields& o) : m_rep (o.m_rep) { m_rep->m_count++; }
88 88
89 octave_fields& 89 octave_fields&
90 operator = (const octave_fields& o) 90 operator = (const octave_fields& o)
91 { 91 {
92 if (&o != this) 92 if (&o != this)
93 { 93 {
94 o.rep->count++; 94 o.m_rep->m_count++;
95 if (--rep->count == 0) 95 if (--m_rep->m_count == 0)
96 delete rep; 96 delete m_rep;
97 rep = o.rep; 97 m_rep = o.m_rep;
98 } 98 }
99 99
100 return *this; 100 return *this;
101 } 101 }
102 102
103 // constant iteration support. non-const iteration intentionally unsupported. 103 // constant iteration support. non-const iteration intentionally unsupported.
104 104
105 typedef std::map<std::string, octave_idx_type>::const_iterator const_iterator; 105 typedef std::map<std::string, octave_idx_type>::const_iterator const_iterator;
106 typedef const_iterator iterator; 106 typedef const_iterator iterator;
107 107
108 const_iterator begin (void) const { return rep->begin (); } 108 const_iterator begin (void) const { return m_rep->begin (); }
109 const_iterator end (void) const { return rep->end (); } 109 const_iterator end (void) const { return m_rep->end (); }
110 110
111 const_iterator cbegin (void) const { return rep->cbegin (); } 111 const_iterator cbegin (void) const { return m_rep->cbegin (); }
112 const_iterator cend (void) const { return rep->cend (); } 112 const_iterator cend (void) const { return m_rep->cend (); }
113 113
114 std::string key (const_iterator p) const { return p->first; } 114 std::string key (const_iterator p) const { return p->first; }
115 octave_idx_type index (const_iterator p) const { return p->second; } 115 octave_idx_type index (const_iterator p) const { return p->second; }
116 116
117 const_iterator seek (const std::string& k) const 117 const_iterator seek (const std::string& k) const
118 { return rep->find (k); } 118 { return m_rep->find (k); }
119 119
120 // high-level methods. 120 // high-level methods.
121 121
122 // number of fields. 122 // number of fields.
123 octave_idx_type nfields (void) const { return rep->size (); } 123 octave_idx_type nfields (void) const { return m_rep->size (); }
124 124
125 // check whether a field exists. 125 // check whether a field exists.
126 bool isfield (const std::string& name) const; 126 bool isfield (const std::string& name) const;
127 127
128 // get index of field. return -1 if not exist 128 // get index of field. return -1 if not exist
144 144
145 bool equal_up_to_order (const octave_fields& other, 145 bool equal_up_to_order (const octave_fields& other,
146 Array<octave_idx_type>& perm) const; 146 Array<octave_idx_type>& perm) const;
147 147
148 bool is_same (const octave_fields& other) const 148 bool is_same (const octave_fields& other) const
149 { return rep == other.rep; } 149 { return m_rep == other.m_rep; }
150 150
151 // Returns the fields as a vector of strings. 151 // Returns the fields as a vector of strings.
152 string_vector fieldnames (void) const; 152 string_vector fieldnames (void) const;
153 153
154 void clear (void) 154 void clear (void)
161 octave_scalar_map 161 octave_scalar_map
162 { 162 {
163 public: 163 public:
164 164
165 octave_scalar_map (const octave_fields& k) 165 octave_scalar_map (const octave_fields& k)
166 : xkeys (k), xvals (k.nfields ()) { } 166 : m_keys (k), m_vals (k.nfields ()) { }
167 167
168 octave_scalar_map (void) : xkeys (), xvals () { } 168 octave_scalar_map (void) : m_keys (), m_vals () { }
169 169
170 octave_scalar_map (const string_vector& k) 170 octave_scalar_map (const string_vector& k)
171 : xkeys (k), xvals (k.numel ()) { } 171 : m_keys (k), m_vals (k.numel ()) { }
172 172
173 octave_scalar_map (const octave_scalar_map& m) 173 octave_scalar_map (const octave_scalar_map& m)
174 : xkeys (m.xkeys), xvals (m.xvals) { } 174 : m_keys (m.m_keys), m_vals (m.m_vals) { }
175 175
176 octave_scalar_map (const std::map<std::string, octave_value>& m); 176 octave_scalar_map (const std::map<std::string, octave_value>& m);
177 177
178 octave_scalar_map& operator = (const octave_scalar_map& m) 178 octave_scalar_map& operator = (const octave_scalar_map& m)
179 { 179 {
180 xkeys = m.xkeys; 180 m_keys = m.m_keys;
181 xvals = m.xvals; 181 m_vals = m.m_vals;
182 182
183 return *this; 183 return *this;
184 } 184 }
185 185
186 // iteration support. 186 // iteration support.
187 // note that both const and non-const iterators are the same. 187 // note that both const and non-const iterators are the same.
188 // The const/non-const distinction is made by the key & contents method. 188 // The const/non-const distinction is made by the key & contents method.
189 typedef octave_fields::const_iterator const_iterator; 189 typedef octave_fields::const_iterator const_iterator;
190 typedef const_iterator iterator; 190 typedef const_iterator iterator;
191 191
192 const_iterator begin (void) const { return xkeys.begin (); } 192 const_iterator begin (void) const { return m_keys.begin (); }
193 const_iterator end (void) const { return xkeys.end (); } 193 const_iterator end (void) const { return m_keys.end (); }
194 194
195 const_iterator cbegin (void) const { return xkeys.cbegin (); } 195 const_iterator cbegin (void) const { return m_keys.cbegin (); }
196 const_iterator cend (void) const { return xkeys.cend (); } 196 const_iterator cend (void) const { return m_keys.cend (); }
197 197
198 const_iterator seek (const std::string& k) const { return xkeys.seek (k); } 198 const_iterator seek (const std::string& k) const { return m_keys.seek (k); }
199 199
200 std::string key (const_iterator p) const 200 std::string key (const_iterator p) const
201 { return xkeys.key (p); } 201 { return m_keys.key (p); }
202 octave_idx_type index (const_iterator p) const 202 octave_idx_type index (const_iterator p) const
203 { return xkeys.index (p); } 203 { return m_keys.index (p); }
204 204
205 const octave_value& contents (const_iterator p) const 205 const octave_value& contents (const_iterator p) const
206 { return xvals[xkeys.index (p)]; } 206 { return m_vals[m_keys.index (p)]; }
207 207
208 octave_value& contents (iterator p) 208 octave_value& contents (iterator p)
209 { return xvals[xkeys.index (p)]; } 209 { return m_vals[m_keys.index (p)]; }
210 210
211 const octave_value& contents (octave_idx_type i) const 211 const octave_value& contents (octave_idx_type i) const
212 { return xvals[i]; } 212 { return m_vals[i]; }
213 213
214 octave_value& contents (octave_idx_type i) 214 octave_value& contents (octave_idx_type i)
215 { return xvals[i]; } 215 { return m_vals[i]; }
216 216
217 // number of fields. 217 // number of fields.
218 octave_idx_type nfields (void) const { return xkeys.nfields (); } 218 octave_idx_type nfields (void) const { return m_keys.nfields (); }
219 219
220 // check whether a field exists. 220 // check whether a field exists.
221 bool isfield (const std::string& name) const 221 bool isfield (const std::string& name) const
222 { return xkeys.isfield (name); } 222 { return m_keys.isfield (name); }
223 223
224 bool contains (const std::string& name) const 224 bool contains (const std::string& name) const
225 { return isfield (name); } 225 { return isfield (name); }
226 226
227 string_vector fieldnames (void) const 227 string_vector fieldnames (void) const
228 { return xkeys.fieldnames (); } 228 { return m_keys.fieldnames (); }
229 229
230 string_vector keys (void) const 230 string_vector keys (void) const
231 { return fieldnames (); } 231 { return fieldnames (); }
232 232
233 // get contents of a given field. empty value if not exist. 233 // get contents of a given field. empty value if not exist.
252 octave_value contents (const std::string& k) const; 252 octave_value contents (const std::string& k) const;
253 octave_value& contents (const std::string& k); 253 octave_value& contents (const std::string& k);
254 254
255 void clear (void) 255 void clear (void)
256 { 256 {
257 xkeys.clear (); 257 m_keys.clear ();
258 xvals.clear (); 258 m_vals.clear ();
259 } 259 }
260 260
261 friend class octave_map; 261 friend class octave_map;
262 262
263 private: 263 private:
264 264
265 octave_fields xkeys; 265 octave_fields m_keys;
266 std::vector<octave_value> xvals; 266 std::vector<octave_value> m_vals;
267 267
268 }; 268 };
269 269
270 template <> 270 template <>
271 inline octave_scalar_map 271 inline octave_scalar_map
276 octave_map 276 octave_map
277 { 277 {
278 public: 278 public:
279 279
280 octave_map (const octave_fields& k) 280 octave_map (const octave_fields& k)
281 : xkeys (k), xvals (k.nfields ()), dimensions () { } 281 : m_keys (k), m_vals (k.nfields ()), m_dimensions () { }
282 282
283 octave_map (const dim_vector& dv, const octave_fields& k) 283 octave_map (const dim_vector& dv, const octave_fields& k)
284 : xkeys (k), xvals (k.nfields (), Cell (dv)), dimensions (dv) { } 284 : m_keys (k), m_vals (k.nfields (), Cell (dv)), m_dimensions (dv) { }
285 285
286 typedef octave_scalar_map element_type; 286 typedef octave_scalar_map element_type;
287 287
288 octave_map (void) : xkeys (), xvals (), dimensions () { } 288 octave_map (void) : m_keys (), m_vals (), m_dimensions () { }
289 289
290 octave_map (const dim_vector& dv) : xkeys (), xvals (), dimensions (dv) { } 290 octave_map (const dim_vector& dv) : m_keys (), m_vals (), m_dimensions (dv) { }
291 291
292 octave_map (const string_vector& k) 292 octave_map (const string_vector& k)
293 : xkeys (k), xvals (k.numel (), Cell (1, 1)), dimensions (1, 1) { } 293 : m_keys (k), m_vals (k.numel (), Cell (1, 1)), m_dimensions (1, 1) { }
294 294
295 octave_map (const dim_vector& dv, const string_vector& k) 295 octave_map (const dim_vector& dv, const string_vector& k)
296 : xkeys (k), xvals (k.numel (), Cell (dv)), dimensions (dv) { } 296 : m_keys (k), m_vals (k.numel (), Cell (dv)), m_dimensions (dv) { }
297 297
298 octave_map (const octave_map& m) 298 octave_map (const octave_map& m)
299 : xkeys (m.xkeys), xvals (m.xvals), dimensions (m.dimensions) { } 299 : m_keys (m.m_keys), m_vals (m.m_vals), m_dimensions (m.m_dimensions) { }
300 300
301 octave_map (const octave_scalar_map& m); 301 octave_map (const octave_scalar_map& m);
302 302
303 octave_map& operator = (const octave_map& m) 303 octave_map& operator = (const octave_map& m)
304 { 304 {
305 xkeys = m.xkeys; 305 m_keys = m.m_keys;
306 xvals = m.xvals; 306 m_vals = m.m_vals;
307 dimensions = m.dimensions; 307 m_dimensions = m.m_dimensions;
308 308
309 return *this; 309 return *this;
310 } 310 }
311 311
312 // iteration support. 312 // iteration support.
313 // note that both const and non-const iterators are the same. 313 // note that both const and non-const iterators are the same.
314 // The const/non-const distinction is made by the key & contents method. 314 // The const/non-const distinction is made by the key & contents method.
315 typedef octave_fields::const_iterator const_iterator; 315 typedef octave_fields::const_iterator const_iterator;
316 typedef const_iterator iterator; 316 typedef const_iterator iterator;
317 317
318 const_iterator begin (void) const { return xkeys.begin (); } 318 const_iterator begin (void) const { return m_keys.begin (); }
319 const_iterator end (void) const { return xkeys.end (); } 319 const_iterator end (void) const { return m_keys.end (); }
320 320
321 const_iterator cbegin (void) const { return xkeys.cbegin (); } 321 const_iterator cbegin (void) const { return m_keys.cbegin (); }
322 const_iterator cend (void) const { return xkeys.cend (); } 322 const_iterator cend (void) const { return m_keys.cend (); }
323 323
324 const_iterator seek (const std::string& k) const { return xkeys.seek (k); } 324 const_iterator seek (const std::string& k) const { return m_keys.seek (k); }
325 325
326 std::string key (const_iterator p) const 326 std::string key (const_iterator p) const
327 { return xkeys.key (p); } 327 { return m_keys.key (p); }
328 octave_idx_type index (const_iterator p) const 328 octave_idx_type index (const_iterator p) const
329 { return xkeys.index (p); } 329 { return m_keys.index (p); }
330 330
331 const Cell& contents (const_iterator p) const 331 const Cell& contents (const_iterator p) const
332 { return xvals[xkeys.index (p)]; } 332 { return m_vals[m_keys.index (p)]; }
333 333
334 Cell& contents (iterator p) 334 Cell& contents (iterator p)
335 { return xvals[xkeys.index (p)]; } 335 { return m_vals[m_keys.index (p)]; }
336 336
337 const Cell& contents (octave_idx_type i) const 337 const Cell& contents (octave_idx_type i) const
338 { return xvals[i]; } 338 { return m_vals[i]; }
339 339
340 Cell& contents (octave_idx_type i) 340 Cell& contents (octave_idx_type i)
341 { return xvals[i]; } 341 { return m_vals[i]; }
342 342
343 // number of fields. 343 // number of fields.
344 octave_idx_type nfields (void) const { return xkeys.nfields (); } 344 octave_idx_type nfields (void) const { return m_keys.nfields (); }
345 345
346 // check whether a field exists. 346 // check whether a field exists.
347 bool isfield (const std::string& name) const 347 bool isfield (const std::string& name) const
348 { return xkeys.isfield (name); } 348 { return m_keys.isfield (name); }
349 349
350 bool contains (const std::string& name) const 350 bool contains (const std::string& name) const
351 { return isfield (name); } 351 { return isfield (name); }
352 352
353 string_vector fieldnames (void) const 353 string_vector fieldnames (void) const
354 { return xkeys.fieldnames (); } 354 { return m_keys.fieldnames (); }
355 355
356 string_vector keys (void) const 356 string_vector keys (void) const
357 { return fieldnames (); } 357 { return fieldnames (); }
358 358
359 // get contents of a given field. empty value if not exist. 359 // get contents of a given field. empty value if not exist.
360 Cell getfield (const std::string& key) const; 360 Cell getfield (const std::string& key) const;
361 361
362 // set contents of a given field. add if not exist. checks for 362 // set contents of a given field. add if not exist. checks for
363 // correct dimensions. 363 // correct m_dimensions.
364 void setfield (const std::string& key, const Cell& val); 364 void setfield (const std::string& key, const Cell& val);
365 void assign (const std::string& k, const Cell& val) 365 void assign (const std::string& k, const Cell& val)
366 { setfield (k, val); } 366 { setfield (k, val); }
367 367
368 // remove a given field. do nothing if not exist. 368 // remove a given field. do nothing if not exist.
379 Cell contents (const std::string& k) const; 379 Cell contents (const std::string& k) const;
380 Cell& contents (const std::string& k); 380 Cell& contents (const std::string& k);
381 381
382 void clear (void) 382 void clear (void)
383 { 383 {
384 xkeys.clear (); 384 m_keys.clear ();
385 xvals.clear (); 385 m_vals.clear ();
386 } 386 }
387 387
388 // The Array-like methods. 388 // The Array-like methods.
389 octave_idx_type numel (void) const { return dimensions.numel (); } 389 octave_idx_type numel (void) const { return m_dimensions.numel (); }
390 octave_idx_type length (void) const { return numel (); } 390 octave_idx_type length (void) const { return numel (); }
391 bool isempty (void) const { return dimensions.any_zero (); } 391 bool isempty (void) const { return m_dimensions.any_zero (); }
392 392
393 octave_idx_type rows (void) const { return dimensions(0); } 393 octave_idx_type rows (void) const { return m_dimensions(0); }
394 octave_idx_type cols (void) const { return dimensions(1); } 394 octave_idx_type cols (void) const { return m_dimensions(1); }
395 octave_idx_type columns (void) const { return dimensions(1); } 395 octave_idx_type columns (void) const { return m_dimensions(1); }
396 396
397 // Extract a scalar substructure. 397 // Extract a scalar substructure.
398 // FIXME: actually check something. 398 // FIXME: actually check something.
399 octave_scalar_map checkelem (octave_idx_type n) const 399 octave_scalar_map checkelem (octave_idx_type n) const
400 { return elem (n); } 400 { return elem (n); }
425 425
426 octave_map squeeze (void) const; 426 octave_map squeeze (void) const;
427 427
428 octave_map permute (const Array<int>& vec, bool inv = false) const; 428 octave_map permute (const Array<int>& vec, bool inv = false) const;
429 429
430 dim_vector dims (void) const { return dimensions; } 430 dim_vector dims (void) const { return m_dimensions; }
431 431
432 int ndims (void) const { return dimensions.ndims (); } 432 int ndims (void) const { return m_dimensions.ndims (); }
433 433
434 octave_map transpose (void) const; 434 octave_map transpose (void) const;
435 435
436 octave_map reshape (const dim_vector& dv) const; 436 octave_map reshape (const dim_vector& dv) const;
437 437
485 // element assignment, no bounds check 485 // element assignment, no bounds check
486 bool fast_elem_insert (octave_idx_type n, const octave_scalar_map& rhs); 486 bool fast_elem_insert (octave_idx_type n, const octave_scalar_map& rhs);
487 487
488 private: 488 private:
489 489
490 octave_fields xkeys; 490 octave_fields m_keys;
491 std::vector<Cell> xvals; 491 std::vector<Cell> m_vals;
492 dim_vector dimensions; 492 dim_vector m_dimensions;
493 493
494 void optimize_dimensions (void); 494 void optimize_dimensions (void);
495 void extract_scalar (octave_scalar_map& dest, 495 void extract_scalar (octave_scalar_map& dest,
496 octave_idx_type index) const; 496 octave_idx_type index) const;
497 static void do_cat (int dim, octave_idx_type n, 497 static void do_cat (int dim, octave_idx_type n,