Mercurial > octave

annotate libinterp/corefcn/oct-map.h @ 31231:a026fb2be108

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
sparse-xpow.cc: Return empty matrix for empty input (bug #63080)
author Arun Giridhar <arungiridhar@gmail.com>
date Mon, 19 Sep 2022 07:05:31 -0400
parents 796f54d4ddbf
children aac27ad79be6
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
27923
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
2 //
30564
796f54d4ddbf update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents: 29922
diff changeset
3 // Copyright (C) 1994-2022 The Octave Project Developers
27923
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
4 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
7 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
9 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
14 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
19 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
23 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
24 ////////////////////////////////////////////////////////////////////////
746
46f6f6a4f5c6 [project @ 1994-09-30 15:05:10 by jwe]
jwe
parents:
diff changeset
25
20791
f7084eae3318 maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents: 20232
diff changeset
26 #if ! defined (octave_oct_map_h)
746
46f6f6a4f5c6 [project @ 1994-09-30 15:05:10 by jwe]
jwe
parents:
diff changeset
27 #define octave_oct_map_h 1
46f6f6a4f5c6 [project @ 1994-09-30 15:05:10 by jwe]
jwe
parents:
diff changeset
28
21244
1473547f50f5 include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents: 21139
diff changeset
29 #include "octave-config.h"
1473547f50f5 include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents: 21139
diff changeset
30
6059
8fd77759707c [project @ 2006-10-18 02:21:22 by jwe]
jwe
parents: 5925
diff changeset
31 #include <algorithm>
4219
23d06c9e1edd [project @ 2002-12-06 21:29:17 by jwe]
jwe
parents: 4200
diff changeset
32 #include <map>
746
46f6f6a4f5c6 [project @ 1994-09-30 15:05:10 by jwe]
jwe
parents:
diff changeset
33
23721
b2d55b52ee51 new class to manage help system and associated variables
John W. Eaton <jwe@octave.org>
parents: 23678
diff changeset
34 #include "oct-refcount.h"
b2d55b52ee51 new class to manage help system and associated variables
John W. Eaton <jwe@octave.org>
parents: 23678
diff changeset
35
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4435
diff changeset
36 #include "Cell.h"
20940
48b2ad5ee801 maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents: 20791
diff changeset
37 #include "ovl.h"
746
46f6f6a4f5c6 [project @ 1994-09-30 15:05:10 by jwe]
jwe
parents:
diff changeset
38
1755
3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe]
jwe
parents: 1737
diff changeset
39 class string_vector;
3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe]
jwe
parents: 1737
diff changeset
40
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
41 // A class holding a map field->index. Supports reference-counting.
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
42 class OCTINTERP_API
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
43 octave_fields
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
44 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
45 class fields_rep : public std::map<std::string, octave_idx_type>
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
46 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
47 public:
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
48 fields_rep (void) : std::map<std::string, octave_idx_type> (), m_count (1) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
49 fields_rep (const fields_rep& other)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
50 : std::map<std::string, octave_idx_type> (other), m_count (1) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
51
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
52 octave::refcount<octave_idx_type> m_count;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
53
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
54 private:
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
55 fields_rep& operator = (const fields_rep&); // no assignment!
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
56 };
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
57
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
58 fields_rep *m_rep;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
59
21573
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
60 static fields_rep *nil_rep (void);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
61
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
62 public:
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
63
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
64 octave_fields (void) : m_rep (nil_rep ()) { m_rep->m_count++; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
65 octave_fields (const string_vector&);
10766
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
66 octave_fields (const char * const *);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
67
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
68 ~octave_fields (void)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
69 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
70 if (--m_rep->m_count == 0)
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
71 delete m_rep;
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
72 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
73
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
74 void make_unique (void)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
75 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
76 if (m_rep->m_count > 1)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
77 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
78 fields_rep *r = new fields_rep (*m_rep);
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 12155
diff changeset
79
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
80 if (--m_rep->m_count == 0)
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
81 delete m_rep;
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 12155
diff changeset
82
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
83 m_rep = r;
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
84 }
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
85 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
86
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
87 octave_fields (const octave_fields& o) : m_rep (o.m_rep) { m_rep->m_count++; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
88
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
89 octave_fields&
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
90 operator = (const octave_fields& o)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
91 {
26391
3774259dd114 oct-map.h: Fix static analyzer detected issues (bug #55347).
Rik <rik@octave.org>
parents: 26376
diff changeset
92 if (&o != this)
3774259dd114 oct-map.h: Fix static analyzer detected issues (bug #55347).
Rik <rik@octave.org>
parents: 26376
diff changeset
93 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
94 o.m_rep->m_count++;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
95 if (--m_rep->m_count == 0)
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
96 delete m_rep;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
97 m_rep = o.m_rep;
26391
3774259dd114 oct-map.h: Fix static analyzer detected issues (bug #55347).
Rik <rik@octave.org>
parents: 26376
diff changeset
98 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
99
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
100 return *this;
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
101 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
102
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
103 // constant iteration support. non-const iteration intentionally unsupported.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
104
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
105 typedef std::map<std::string, octave_idx_type>::const_iterator const_iterator;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
106 typedef const_iterator iterator;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
107
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
108 const_iterator begin (void) const { return m_rep->begin (); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
109 const_iterator end (void) const { return m_rep->end (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
110
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
111 const_iterator cbegin (void) const { return m_rep->cbegin (); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
112 const_iterator cend (void) const { return m_rep->cend (); }
25343
4d7790d9793f use cbegin, crbegin, cend, and crend and auto decls where possible
John W. Eaton <jwe@octave.org>
parents: 25054
diff changeset
113
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
114 std::string key (const_iterator p) const { return p->first; }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
115 octave_idx_type index (const_iterator p) const { return p->second; }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
116
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
117 const_iterator seek (const std::string& k) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
118 { return m_rep->find (k); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
119
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
120 // high-level methods.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
121
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
122 // number of fields.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
123 octave_idx_type nfields (void) const { return m_rep->size (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
124
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
125 // check whether a field exists.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
126 bool isfield (const std::string& name) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
127
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
128 // get index of field. return -1 if not exist
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
129 octave_idx_type getfield (const std::string& name) const;
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
130 // get index of field. add if not exist
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
131 octave_idx_type getfield (const std::string& name);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
132 // remove field and return the index. -1 if didn't exist.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
133 octave_idx_type rmfield (const std::string& name);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
134
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
135 // order the fields of this map.
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
136 // creates a permutation used to order the fields.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
137 void orderfields (Array<octave_idx_type>& perm);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
138
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
139 // compares two instances for equality up to order of fields.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
140 // returns a permutation needed to bring the fields of *other*
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
141 // into the order of *this*.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
142 bool equal_up_to_order (const octave_fields& other,
23449
c763214a8260 maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents: 23220
diff changeset
143 octave_idx_type *perm) const;
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
144
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
145 bool equal_up_to_order (const octave_fields& other,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
146 Array<octave_idx_type>& perm) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
147
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
148 bool is_same (const octave_fields& other) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
149 { return m_rep == other.m_rep; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
150
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
151 // Returns the fields as a vector of strings.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
152 string_vector fieldnames (void) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
153
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
154 void clear (void)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
155 {
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
156 *this = octave_fields ();
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
157 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
158 };
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
159
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
160 class OCTINTERP_API
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
161 octave_scalar_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
162 {
10766
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
163 public:
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
164
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
165 octave_scalar_map (const octave_fields& k)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
166 : m_keys (k), m_vals (k.nfields ()) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
167
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
168 octave_scalar_map (void) : m_keys (), m_vals () { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
169
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
170 octave_scalar_map (const string_vector& k)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
171 : m_keys (k), m_vals (k.numel ()) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
172
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
173 octave_scalar_map (const octave_scalar_map& m)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
174 : m_keys (m.m_keys), m_vals (m.m_vals) { }
23678
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
175
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
176 octave_scalar_map (const std::map<std::string, octave_value>& m);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
177
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
178 octave_scalar_map& operator = (const octave_scalar_map& m)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
179 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
180 m_keys = m.m_keys;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
181 m_vals = m.m_vals;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
182
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
183 return *this;
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
184 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
185
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
186 // iteration support.
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
187 // note that both const and non-const iterators are the same.
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
188 // The const/non-const distinction is made by the key & contents method.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
189 typedef octave_fields::const_iterator const_iterator;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
190 typedef const_iterator iterator;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
191
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
192 const_iterator begin (void) const { return m_keys.begin (); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
193 const_iterator end (void) const { return m_keys.end (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
194
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
195 const_iterator cbegin (void) const { return m_keys.cbegin (); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
196 const_iterator cend (void) const { return m_keys.cend (); }
25343
4d7790d9793f use cbegin, crbegin, cend, and crend and auto decls where possible
John W. Eaton <jwe@octave.org>
parents: 25054
diff changeset
197
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
198 const_iterator seek (const std::string& k) const { return m_keys.seek (k); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
199
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
200 std::string key (const_iterator p) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
201 { return m_keys.key (p); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
202 octave_idx_type index (const_iterator p) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
203 { return m_keys.index (p); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
204
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
205 const octave_value& contents (const_iterator p) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
206 { return m_vals[m_keys.index (p)]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
207
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
208 octave_value& contents (iterator p)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
209 { return m_vals[m_keys.index (p)]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
210
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
211 const octave_value& contents (octave_idx_type i) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
212 { return m_vals[i]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
213
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
214 octave_value& contents (octave_idx_type i)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
215 { return m_vals[i]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
216
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
217 // number of fields.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
218 octave_idx_type nfields (void) const { return m_keys.nfields (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
219
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
220 // check whether a field exists.
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
221 bool isfield (const std::string& name) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
222 { return m_keys.isfield (name); }
10746
93422177b697 more octave_map compatibility
Jaroslav Hajek <highegg@gmail.com>
parents: 10744
diff changeset
223
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
224 bool contains (const std::string& name) const
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
225 { return isfield (name); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
226
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
227 string_vector fieldnames (void) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
228 { return m_keys.fieldnames (); }
10746
93422177b697 more octave_map compatibility
Jaroslav Hajek <highegg@gmail.com>
parents: 10744
diff changeset
229
93422177b697 more octave_map compatibility
Jaroslav Hajek <highegg@gmail.com>
parents: 10744
diff changeset
230 string_vector keys (void) const
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
231 { return fieldnames (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
232
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
233 // get contents of a given field. empty value if not exist.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
234 octave_value getfield (const std::string& key) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
235
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
236 // set contents of a given field. add if not exist.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
237 void setfield (const std::string& key, const octave_value& val);
10761
12dfe91e9fab more bkw compatibility for octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10760
diff changeset
238 void assign (const std::string& k, const octave_value& val)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
239 { setfield (k, val); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
240
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
241 // remove a given field. do nothing if not exist.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
242 void rmfield (const std::string& key);
10746
93422177b697 more octave_map compatibility
Jaroslav Hajek <highegg@gmail.com>
parents: 10744
diff changeset
243 void del (const std::string& k) { rmfield (k); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
244
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
245 // return a copy with fields ordered, optionally along with permutation.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
246 octave_scalar_map orderfields (void) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
247 octave_scalar_map orderfields (Array<octave_idx_type>& perm) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
248 octave_scalar_map orderfields (const octave_scalar_map& other,
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
249 Array<octave_idx_type>& perm) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
250
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
251 // aka getfield/setfield, but the latter returns a reference.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
252 octave_value contents (const std::string& k) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
253 octave_value& contents (const std::string& k);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
254
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
255 void clear (void)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
256 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
257 m_keys.clear ();
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
258 m_vals.clear ();
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
259 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
260
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
261 friend class octave_map;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
262
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
263 private:
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
264
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
265 octave_fields m_keys;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
266 std::vector<octave_value> m_vals;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
267
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
268 };
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
269
21139
538b57866b90 consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
270 template <>
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
271 inline octave_scalar_map
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
272 octave_value_extract<octave_scalar_map> (const octave_value& v)
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
273 { return v.scalar_map_value (); }
10757
1cc44f3ec814 templated extractors for maps and cells
Jaroslav Hajek <highegg@gmail.com>
parents: 10756
diff changeset
274
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
275 class OCTINTERP_API
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
276 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
277 {
10766
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
278 public:
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
279
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
280 octave_map (const octave_fields& k)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
281 : m_keys (k), m_vals (k.nfields ()), m_dimensions () { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
282
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10749
diff changeset
283 octave_map (const dim_vector& dv, const octave_fields& k)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
284 : m_keys (k), m_vals (k.nfields (), Cell (dv)), m_dimensions (dv) { }
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10749
diff changeset
285
10756
d808eb829d48 optimize num2cell on structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
286 typedef octave_scalar_map element_type;
d808eb829d48 optimize num2cell on structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
287
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
288 octave_map (void) : m_keys (), m_vals (), m_dimensions () { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
289
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
290 octave_map (const dim_vector& dv) : m_keys (), m_vals (), m_dimensions (dv) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
291
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
292 octave_map (const string_vector& k)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
293 : m_keys (k), m_vals (k.numel (), Cell (1, 1)), m_dimensions (1, 1) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
294
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
295 octave_map (const dim_vector& dv, const string_vector& k)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
296 : m_keys (k), m_vals (k.numel (), Cell (dv)), m_dimensions (dv) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
297
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
298 octave_map (const octave_map& m)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
299 : m_keys (m.m_keys), m_vals (m.m_vals), m_dimensions (m.m_dimensions) { }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
300
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
301 octave_map (const octave_scalar_map& m);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
302
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
303 octave_map& operator = (const octave_map& m)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
304 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
305 m_keys = m.m_keys;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
306 m_vals = m.m_vals;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
307 m_dimensions = m.m_dimensions;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
308
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
309 return *this;
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
310 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
311
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
312 // iteration support.
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
313 // note that both const and non-const iterators are the same.
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
314 // The const/non-const distinction is made by the key & contents method.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
315 typedef octave_fields::const_iterator const_iterator;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
316 typedef const_iterator iterator;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
317
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
318 const_iterator begin (void) const { return m_keys.begin (); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
319 const_iterator end (void) const { return m_keys.end (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
320
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
321 const_iterator cbegin (void) const { return m_keys.cbegin (); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
322 const_iterator cend (void) const { return m_keys.cend (); }
25343
4d7790d9793f use cbegin, crbegin, cend, and crend and auto decls where possible
John W. Eaton <jwe@octave.org>
parents: 25054
diff changeset
323
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
324 const_iterator seek (const std::string& k) const { return m_keys.seek (k); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
325
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
326 std::string key (const_iterator p) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
327 { return m_keys.key (p); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
328 octave_idx_type index (const_iterator p) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
329 { return m_keys.index (p); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
330
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
331 const Cell& contents (const_iterator p) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
332 { return m_vals[m_keys.index (p)]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
333
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
334 Cell& contents (iterator p)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
335 { return m_vals[m_keys.index (p)]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
336
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
337 const Cell& contents (octave_idx_type i) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
338 { return m_vals[i]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
339
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
340 Cell& contents (octave_idx_type i)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
341 { return m_vals[i]; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
342
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
343 // number of fields.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
344 octave_idx_type nfields (void) const { return m_keys.nfields (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
345
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
346 // check whether a field exists.
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
347 bool isfield (const std::string& name) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
348 { return m_keys.isfield (name); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
349
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
350 bool contains (const std::string& name) const
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
351 { return isfield (name); }
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
352
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
353 string_vector fieldnames (void) const
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
354 { return m_keys.fieldnames (); }
10746
93422177b697 more octave_map compatibility
Jaroslav Hajek <highegg@gmail.com>
parents: 10744
diff changeset
355
93422177b697 more octave_map compatibility
Jaroslav Hajek <highegg@gmail.com>
parents: 10744
diff changeset
356 string_vector keys (void) const
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
357 { return fieldnames (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
358
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
359 // get contents of a given field. empty value if not exist.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
360 Cell getfield (const std::string& key) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
361
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21660
diff changeset
362 // set contents of a given field. add if not exist. checks for
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
363 // correct m_dimensions.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
364 void setfield (const std::string& key, const Cell& val);
10761
12dfe91e9fab more bkw compatibility for octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10760
diff changeset
365 void assign (const std::string& k, const Cell& val)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
366 { setfield (k, val); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
367
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
368 // remove a given field. do nothing if not exist.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
369 void rmfield (const std::string& key);
10744
4716e2e17118 fix octave_map::extract_scalar
Jaroslav Hajek <highegg@gmail.com>
parents: 10743
diff changeset
370 void del (const std::string& k) { rmfield (k); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
371
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
372 // return a copy with fields ordered, optionally along with permutation.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
373 octave_map orderfields (void) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
374 octave_map orderfields (Array<octave_idx_type>& perm) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
375 octave_map orderfields (const octave_map& other,
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
376 Array<octave_idx_type>& perm) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
377
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
378 // aka getfield/setfield, but the latter returns a reference.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
379 Cell contents (const std::string& k) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
380 Cell& contents (const std::string& k);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
381
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
382 void clear (void)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
383 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
384 m_keys.clear ();
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
385 m_vals.clear ();
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
386 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
387
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
388 // The Array-like methods.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
389 octave_idx_type numel (void) const { return m_dimensions.numel (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
390 octave_idx_type length (void) const { return numel (); }
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
391 bool isempty (void) const { return m_dimensions.any_zero (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
392
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
393 octave_idx_type rows (void) const { return m_dimensions(0); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
394 octave_idx_type cols (void) const { return m_dimensions(1); }
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
395 octave_idx_type columns (void) const { return m_dimensions(1); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
396
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
397 // Extract a scalar substructure.
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
398 // FIXME: actually check something.
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
399 octave_scalar_map checkelem (octave_idx_type n) const
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
400 { return elem (n); }
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
401
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
402 // FIXME: actually check something.
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
403 octave_scalar_map checkelem (octave_idx_type i, octave_idx_type j) const
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
404 { return elem (i, j); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
405
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
406 // FIXME: actually check something.
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
407 octave_scalar_map checkelem (const Array<octave_idx_type>& ra_idx) const
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
408 { return elem (ra_idx); }
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
409
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
410 octave_scalar_map elem (octave_idx_type n) const;
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
411
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
412 octave_scalar_map elem (octave_idx_type i, octave_idx_type j) const;
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
413
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
414 octave_scalar_map elem (const Array<octave_idx_type>& ra_idx) const;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
415
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
416 octave_scalar_map operator () (octave_idx_type n) const
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
417 { return elem (n); }
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
418
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
419 octave_scalar_map operator () (octave_idx_type i, octave_idx_type j) const
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
420 { return elem (i, j); }
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
421
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
422 octave_scalar_map
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
423 operator () (const Array<octave_idx_type>& ra_idx) const
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23449
diff changeset
424 { return elem (ra_idx); }
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
425
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
426 octave_map squeeze (void) const;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
427
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
428 octave_map permute (const Array<int>& vec, bool inv = false) const;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
429
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
430 dim_vector dims (void) const { return m_dimensions; }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
431
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
432 int ndims (void) const { return m_dimensions.ndims (); }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
433
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
434 octave_map transpose (void) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
435
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
436 octave_map reshape (const dim_vector& dv) const;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
437
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
438 void resize (const dim_vector& dv, bool fill = false);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
439
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
440 static octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
441 cat (int dim, octave_idx_type n, const octave_scalar_map *map_list);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
442
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
443 static octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
444 cat (int dim, octave_idx_type n, const octave_map *map_list);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
445
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
446 octave_map index (const octave::idx_vector& i, bool resize_ok = false) const;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
447
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
448 octave_map index (const octave::idx_vector& i, const octave::idx_vector& j,
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
449 bool resize_ok = false) const;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
450
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
451 octave_map index (const Array<octave::idx_vector>& ia,
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
452 bool resize_ok = false) const;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
453
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
454 octave_map index (const octave_value_list&, bool resize_ok = false) const;
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
455
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
456 octave_map column (octave_idx_type k) const;
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
457 octave_map page (octave_idx_type k) const;
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
458
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
459 void assign (const octave::idx_vector& i, const octave_map& rhs);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
460
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
461 void assign (const octave::idx_vector& i, const octave::idx_vector& j,
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
462 const octave_map& rhs);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
463
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
464 void assign (const Array<octave::idx_vector>& ia, const octave_map& rhs);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
465
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
466 void assign (const octave_value_list&, const octave_map& rhs);
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
467
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10747
diff changeset
468 void assign (const octave_value_list& idx, const std::string& k,
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10747
diff changeset
469 const Cell& rhs);
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10747
diff changeset
470
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
471 void delete_elements (const octave::idx_vector& i);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
472
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
473 void delete_elements (int dim, const octave::idx_vector& i);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
474
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
475 void delete_elements (const Array<octave::idx_vector>& ia);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
476
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
477 void delete_elements (const octave_value_list&);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
478
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
479 octave_map concat (const octave_map& rb,
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
480 const Array<octave_idx_type>& ra_idx);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
481
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
482 // like checkelem, but no check.
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
483 octave_scalar_map fast_elem_extract (octave_idx_type n) const;
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
484
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
485 // element assignment, no bounds check
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
486 bool fast_elem_insert (octave_idx_type n, const octave_scalar_map& rhs);
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10757
diff changeset
487
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
488 private:
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
489
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
490 octave_fields m_keys;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
491 std::vector<Cell> m_vals;
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29569
diff changeset
492 dim_vector m_dimensions;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
493
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
494 void optimize_dimensions (void);
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
495 void extract_scalar (octave_scalar_map& dest,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
496 octave_idx_type index) const;
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
497 static void do_cat (int dim, octave_idx_type n,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
498 const octave_scalar_map *map_list, octave_map& retval);
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
499 static void do_cat (int dim, octave_idx_type n,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
500 const octave_map *map_list, octave_map& retval);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
501 };
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10333
diff changeset
502
21139
538b57866b90 consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
503 template <>
10757
1cc44f3ec814 templated extractors for maps and cells
Jaroslav Hajek <highegg@gmail.com>
parents: 10756
diff changeset
504 inline octave_map octave_value_extract<octave_map> (const octave_value& v)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
505 { return v.map_value (); }
10757
1cc44f3ec814 templated extractors for maps and cells
Jaroslav Hajek <highegg@gmail.com>
parents: 10756
diff changeset
506
746
46f6f6a4f5c6 [project @ 1994-09-30 15:05:10 by jwe]
jwe
parents:
diff changeset
507 #endif