Mercurial > octave

annotate libinterp/corefcn/oct-map.cc @ 30564:796f54d4ddbf stable

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update Octave Project Developers copyright for the new year In files that have the "Octave Project Developers" copyright notice, update for 2021. In all .txi and .texi files except gpl.txi and gpl.texi in the doc/liboctave and doc/interpreter directories, change the copyright to "Octave Project Developers", the same as used for other source files. Update copyright notices for 2022 (not done since 2019). For gpl.txi and gpl.texi, change the copyright notice to be "Free Software Foundation, Inc." and leave the date at 2007 only because this file only contains the text of the GPL, not anything created by the Octave Project Developers. Add Paul Thomas to contributors.in.
author John W. Eaton <jwe@octave.org>
date Tue, 28 Dec 2021 18:22:40 -0500
parents adda9f3ac61f
children 83f9f8bda883
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) 1995-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 ////////////////////////////////////////////////////////////////////////
1278
606361d34c74 [project @ 1995-04-26 17:40:24 by jwe]
jwe
parents:
diff changeset
25
21724
aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents: 21580
diff changeset
26 #if defined (HAVE_CONFIG_H)
21301
40de9f8f23a6 Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents: 21200
diff changeset
27 # include "config.h"
1278
606361d34c74 [project @ 1995-04-26 17:40:24 by jwe]
jwe
parents:
diff changeset
28 #endif
606361d34c74 [project @ 1995-04-26 17:40:24 by jwe]
jwe
parents:
diff changeset
29
19269
65554f5847ac don't include oct-locbuf.h in header files unnecessarily
John W. Eaton <jwe@octave.org>
parents: 18538
diff changeset
30 #include "Array-util.h"
3932
2e2e32198722 [project @ 2002-05-07 18:10:44 by jwe]
jwe
parents: 3931
diff changeset
31 #include "error.h"
19269
65554f5847ac don't include oct-locbuf.h in header files unnecessarily
John W. Eaton <jwe@octave.org>
parents: 18538
diff changeset
32 #include "oct-locbuf.h"
1755
3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe]
jwe
parents: 1742
diff changeset
33 #include "str-vec.h"
3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe]
jwe
parents: 1742
diff changeset
34
1278
606361d34c74 [project @ 1995-04-26 17:40:24 by jwe]
jwe
parents:
diff changeset
35 #include "oct-map.h"
606361d34c74 [project @ 1995-04-26 17:40:24 by jwe]
jwe
parents:
diff changeset
36 #include "utils.h"
606361d34c74 [project @ 1995-04-26 17:40:24 by jwe]
jwe
parents:
diff changeset
37
21573
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
38 octave_fields::fields_rep *
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
39 octave_fields::nil_rep (void)
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
40 {
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
41 static fields_rep nr;
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
42 return &nr;
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
43 }
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
44
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
45 octave_fields::octave_fields (const string_vector& fields)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
46 : m_rep (new fields_rep)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
47 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
48 octave_idx_type n = fields.numel ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
49 for (octave_idx_type i = 0; i < n; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
50 (*m_rep)[fields(i)] = i;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
51 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
52
10766
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
53 octave_fields::octave_fields (const char * const *fields)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
54 : m_rep (new fields_rep)
10766
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
55 {
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
56 octave_idx_type n = 0;
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
57 while (*fields)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
58 (*m_rep)[std::string (*fields++)] = n++;
10766
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
59 }
f0304c545588 make map constructors from octave_fields public
Jaroslav Hajek <highegg@gmail.com>
parents: 10764
diff changeset
60
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
61 bool
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
62 octave_fields::isfield (const std::string& field) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
63 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
64 return m_rep->find (field) != m_rep->end ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
65 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
66
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
67 octave_idx_type
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
68 octave_fields::getfield (const std::string& field) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
69 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
70 auto p = m_rep->find (field);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
71 return (p != m_rep->end ()) ? p->second : -1;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
72 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
73
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
74 octave_idx_type
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
75 octave_fields::getfield (const std::string& field)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
76 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
77 auto p = m_rep->find (field);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
78 if (p != m_rep->end ())
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
79 return p->second;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
80 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
81 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
82 make_unique ();
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
83 octave_idx_type n = m_rep->size ();
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
84 return (*m_rep)[field] = n;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
85 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
86 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
87
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
88 octave_idx_type
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
89 octave_fields::rmfield (const std::string& field)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
90 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
91 auto p = m_rep->find (field);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
92 if (p == m_rep->end ())
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
93 return -1;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
94 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
95 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
96 octave_idx_type n = p->second;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
97 make_unique ();
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
98 m_rep->erase (field);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
99 for (auto& fld_idx : *m_rep)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
100 {
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
101 if (fld_idx.second >= n)
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
102 fld_idx.second--;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
103 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
104
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
105 return n;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
106 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
107 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
108
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
109 void
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
110 octave_fields::orderfields (Array<octave_idx_type>& perm)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
111 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
112 octave_idx_type n = m_rep->size ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
113 perm.clear (n, 1);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
114
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
115 make_unique ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
116 octave_idx_type i = 0;
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
117 for (auto& fld_idx : *m_rep)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
118 {
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
119 octave_idx_type j = fld_idx.second;
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
120 fld_idx.second = i;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
121 perm(i++) = j;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
122 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
123 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
124
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
125 bool
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
126 octave_fields::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
127 octave_idx_type *perm) const
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
128 {
26566
f8d380d04b01 Fix dead assignments found by clang static analysis (bug #55440).
Rik <rik@octave.org>
parents: 26376
diff changeset
129 bool retval;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
130
25337
3ff9192b676e use auto keyword to declare iterator variables where possible
John W. Eaton <jwe@octave.org>
parents: 25054
diff changeset
131 auto p = begin ();
3ff9192b676e use auto keyword to declare iterator variables where possible
John W. Eaton <jwe@octave.org>
parents: 25054
diff changeset
132 auto q = other.begin ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
133 for (; p != end () && q != other.end (); p++, q++)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
134 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
135 if (p->first == q->first)
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
136 perm[p->second] = q->second;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
137 else
26566
f8d380d04b01 Fix dead assignments found by clang static analysis (bug #55440).
Rik <rik@octave.org>
parents: 26376
diff changeset
138 return false;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
139 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
140
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
141 retval = (p == end () && q == other.end ());
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
142
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
143 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
144 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
145
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
146 bool
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
147 octave_fields::equal_up_to_order (const octave_fields& other,
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
148 Array<octave_idx_type>& perm) const
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
149 {
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
150 octave_idx_type n = nfields ();
20232
a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents: 19697
diff changeset
151 if (perm.numel () != n)
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
152 perm.clear (1, n);
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
153
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
154 return equal_up_to_order (other, perm.fortran_vec ());
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
155 }
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
156
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
157 string_vector
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
158 octave_fields::fieldnames (void) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
159 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
160 octave_idx_type n = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
161 string_vector retval(n);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
162
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
163 for (auto& fld_idx : *this)
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
164 retval.xelem (fld_idx.second) = fld_idx.first;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
165
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
166 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
167 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
168
23678
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
169 octave_scalar_map::octave_scalar_map
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
170 (const std::map<std::string, octave_value>& m)
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
171 {
29654
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
172 std::size_t sz = m.size ();
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
173 m_vals.resize (sz);
29654
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
174 std::size_t i = 0;
23678
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
175 for (const auto& k_v : m)
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
176 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
177 m_keys.getfield (k_v.first);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
178 m_vals[i++] = k_v.second;
23678
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
179 }
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
180 }
dcba41788495 new struct/map constructors
John W. Eaton <jwe@octave.org>
parents: 23577
diff changeset
181
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
182 octave_value
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
183 octave_scalar_map::getfield (const std::string& k) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
184 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
185 octave_idx_type idx = m_keys.getfield (k);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
186 return (idx >= 0) ? m_vals[idx] : octave_value ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
187 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
188
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
189 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
190 octave_scalar_map::setfield (const std::string& k, const octave_value& val)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
191 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
192 octave_idx_type idx = m_keys.getfield (k);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
193 if (idx < static_cast<octave_idx_type> (m_vals.size ()))
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
194 m_vals[idx] = val;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
195 else
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
196 m_vals.push_back (val);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
197 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
198
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
199 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
200 octave_scalar_map::rmfield (const std::string& k)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
201 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
202 octave_idx_type idx = m_keys.rmfield (k);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
203 if (idx >= 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
204 m_vals.erase (m_vals.begin () + idx);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
205 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
206
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
207 octave_scalar_map
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
208 octave_scalar_map::orderfields (void) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
209 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
210 Array<octave_idx_type> perm;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
211 return orderfields (perm);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
212 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
213
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
214 octave_scalar_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
215 octave_scalar_map::orderfields (Array<octave_idx_type>& perm) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
216 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
217 octave_scalar_map retval (m_keys);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
218 retval.m_keys.orderfields (perm);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
219
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
220 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
221 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
222 retval.m_vals[i] = m_vals[perm.xelem (i)];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
223
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
224 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
225 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
226
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
227 octave_scalar_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
228 octave_scalar_map::orderfields (const octave_scalar_map& other,
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
229 Array<octave_idx_type>& perm) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
230 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
231 if (m_keys.is_same (other.m_keys))
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
232 return *this;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
233 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
234 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
235 octave_scalar_map retval (other.m_keys);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
236 if (! other.m_keys.equal_up_to_order (m_keys, perm))
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
237 error ("orderfields: structs must have same fields up to order");
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
238
20962
3aa293be0e8d maint: Invert simple conditionals in if/else/error paradigm.
Rik <rik@octave.org>
parents: 20831
diff changeset
239 octave_idx_type nf = nfields ();
3aa293be0e8d maint: Invert simple conditionals in if/else/error paradigm.
Rik <rik@octave.org>
parents: 20831
diff changeset
240 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
241 retval.m_vals[i] = m_vals[perm.xelem (i)];
20962
3aa293be0e8d maint: Invert simple conditionals in if/else/error paradigm.
Rik <rik@octave.org>
parents: 20831
diff changeset
242
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
243 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
244 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
245 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
246
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
247 octave_value
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
248 octave_scalar_map::contents (const std::string& k) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
249 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
250 return getfield (k);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
251 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
252
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
253 octave_value&
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
254 octave_scalar_map::contents (const std::string& k)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
255 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
256 octave_idx_type idx = m_keys.getfield (k);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
257 if (idx >= static_cast<octave_idx_type> (m_vals.size ()))
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
258 m_vals.resize (idx+1);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
259 return m_vals[idx];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
260 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
261
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
262 octave_map::octave_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: 29655
diff changeset
263 : m_keys (m.m_keys), m_vals (), m_dimensions (1, 1)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
264 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
265 octave_idx_type nf = m.nfields ();
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
266 m_vals.reserve (nf);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
267 for (octave_idx_type i = 0; i < nf; i++)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
268 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
269 m_vals.push_back (Cell (m_dimensions));
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
270 m_vals[i].xelem (0) = m.m_vals[i];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
271 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
272 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
273
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
274 Cell
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
275 octave_map::getfield (const std::string& k) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
276 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
277 octave_idx_type idx = m_keys.getfield (k);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
278 return (idx >= 0) ? m_vals[idx] : Cell ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
279 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
280
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
281 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
282 octave_map::setfield (const std::string& k, const Cell& val)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
283 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
284 if (nfields () == 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
285 m_dimensions = val.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
286
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
287 if (val.dims () != m_dimensions)
20982
d27f66b4b8e6 maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20962
diff changeset
288 error ("octave_map::setfield: internal error");
d27f66b4b8e6 maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20962
diff changeset
289
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
290 octave_idx_type idx = m_keys.getfield (k);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
291 if (idx < static_cast<octave_idx_type> (m_vals.size ()))
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
292 m_vals[idx] = val;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
293 else
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
294 m_vals.push_back (val);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
295 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
296
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
297 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
298 octave_map::rmfield (const std::string& k)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
299 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
300 octave_idx_type idx = m_keys.rmfield (k);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
301 if (idx >= 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
302 m_vals.erase (m_vals.begin () + idx);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
303 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
304
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
305 octave_map
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
306 octave_map::orderfields (void) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
307 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
308 Array<octave_idx_type> perm;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
309 return orderfields (perm);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
310 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
311
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
312 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
313 octave_map::orderfields (Array<octave_idx_type>& perm) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
314 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
315 octave_map retval (m_keys);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
316 retval.m_keys.orderfields (perm);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
317
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
318 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
319 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
320 retval.m_vals[i] = m_vals[perm.xelem (i)];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
321
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
322 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
323 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
324
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
325 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
326 octave_map::orderfields (const octave_map& other,
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
327 Array<octave_idx_type>& perm) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
328 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
329 if (m_keys.is_same (other.m_keys))
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
330 return *this;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
331 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
332 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
333 octave_map retval (other.m_keys);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
334 if (! other.m_keys.equal_up_to_order (m_keys, perm))
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
335 error ("orderfields: structs must have same fields up to order");
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
336
20962
3aa293be0e8d maint: Invert simple conditionals in if/else/error paradigm.
Rik <rik@octave.org>
parents: 20831
diff changeset
337 octave_idx_type nf = nfields ();
3aa293be0e8d maint: Invert simple conditionals in if/else/error paradigm.
Rik <rik@octave.org>
parents: 20831
diff changeset
338 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
339 retval.m_vals[i] = m_vals[perm.xelem (i)];
20962
3aa293be0e8d maint: Invert simple conditionals in if/else/error paradigm.
Rik <rik@octave.org>
parents: 20831
diff changeset
340
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
341 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
342 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
343 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
344
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
345 Cell
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
346 octave_map::contents (const std::string& k) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
347 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
348 return getfield (k);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
349 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
350
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
351 Cell&
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
352 octave_map::contents (const std::string& k)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
353 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
354 octave_idx_type idx = m_keys.getfield (k);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
355 if (idx >= static_cast<octave_idx_type> (m_vals.size ()))
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
356 m_vals.push_back (Cell (m_dimensions)); // auto-set correct dims.
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
357 return m_vals[idx];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
358 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
359
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
360 void
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
361 octave_map::extract_scalar (octave_scalar_map& dest,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
362 octave_idx_type idx) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
363 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
364 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
365 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
366 dest.m_vals[i] = m_vals[i](idx);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
367 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
368
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
369 octave_scalar_map
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23450
diff changeset
370 octave_map::elem (octave_idx_type n) const
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
371 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
372 octave_scalar_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
373
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
374 // Optimize this so that there is just one check.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
375 extract_scalar (retval, compute_index (n, m_dimensions));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
376
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
377 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
378 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
379
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
380 octave_scalar_map
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23450
diff changeset
381 octave_map::elem (octave_idx_type i, octave_idx_type j) const
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
382 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
383 octave_scalar_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
384
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
385 // Optimize this so that there is just one check.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
386 extract_scalar (retval, compute_index (i, j, m_dimensions));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
387
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
388 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
389 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
390
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
391 octave_scalar_map
23487
af2f1f3dbe06 eliminate --enable-bounds-check configure option
John W. Eaton <jwe@octave.org>
parents: 23450
diff changeset
392 octave_map::elem (const Array<octave_idx_type>& ra_idx) const
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
393 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
394 octave_scalar_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
395
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
396 // Optimize this so that there is just one check.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
397 extract_scalar (retval, compute_index (ra_idx, m_dimensions));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
398
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
399 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
400 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
401
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
402 octave_scalar_map
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
403 octave_map::fast_elem_extract (octave_idx_type n) const
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
404 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
405 octave_scalar_map retval (m_keys);
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
406
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
407 extract_scalar (retval, n);
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
408
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
409 return retval;
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
410 }
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
411
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
412 bool
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
413 octave_map::fast_elem_insert (octave_idx_type n,
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
414 const octave_scalar_map& rhs)
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
415 {
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
416 bool retval = false;
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
417
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
418 octave_idx_type nf = nfields ();
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
419 if (rhs.m_keys.is_same (m_keys))
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
420 {
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
421 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
422 m_vals[i](n) = rhs.m_vals[i];
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
423
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
424 retval = true;
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
425 }
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
426 else
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
427 {
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
428 OCTAVE_LOCAL_BUFFER (octave_idx_type, perm, nf);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
429 if (m_keys.equal_up_to_order (rhs.m_keys, perm))
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
430 {
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
431 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
432 m_vals[i](n) = rhs.m_vals[perm[i]];
10760
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
433
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
434 retval = true;
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
435 }
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
436 }
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
437
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
438 return retval;
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
439 }
76079e505f9d optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents: 10755
diff changeset
440
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
441 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
442 octave_map::squeeze (void) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
443 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
444 octave_map retval (*this);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
445 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
446
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
447 retval.m_dimensions = m_dimensions.squeeze ();
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
448
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
449 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
450 retval.m_vals[i] = m_vals[i].squeeze ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
451
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
452 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
453
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
454 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
455 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
456
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
457 /*
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
458 ## test preservation of m_keys by squeeze
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
459 %!test
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
460 %! x(1,1,1,1).d = 10; x(3,5,1,7).a = "b"; x(2,4,1,7).f = 27;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
461 %! assert (fieldnames (squeeze (x)), {"d"; "a"; "f"});
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
462 */
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
463
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
464 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
465 octave_map::permute (const Array<int>& vec, bool inv) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
466 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
467 octave_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
468 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
469
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
470 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
471 retval.m_vals[i] = m_vals[i].permute (vec, inv);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
472
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
473 // FIXME:
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
474 // There is no dim_vector::permute for technical reasons.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
475 // We pick the dim vector from results if possible, otherwise use a dummy
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
476 // array to get it. Need (?) a better solution to this problem.
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
477 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
478 retval.m_dimensions = retval.m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
479 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
480 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
481 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
482 dummy = dummy.permute (vec, inv);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
483 retval.m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
484 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
485
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
486 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
487
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
488 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
489 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
490
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
491 /*
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
492 ## test preservation of key order by permute
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
493 %!test
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
494 %! x(1,1,1,1).d = 10; x(3,5,1,7).a = "b"; x(2,4,1,7).f = 27;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
495 %! assert (fieldnames (permute (x, [3, 4, 1, 2])), {"d"; "a"; "f"});
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
496 */
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
497
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
498 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
499 octave_map::transpose (void) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
500 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
501 assert (ndims () == 2);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
502
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
503 octave_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
504
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
505 retval.m_dimensions = dim_vector (m_dimensions (1), m_dimensions (0));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
506
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
507 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
508 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
509 retval.m_vals[i] = m_vals[i].transpose ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
510
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
511 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
512
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
513 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
514 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
515
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
516 /*
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
517 ## test preservation of key order by transpose
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
518 %!test
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
519 %! x(1,1).d = 10; x(3,5).a = "b"; x(2,4).f = 27;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
520 %! assert (fieldnames (transpose (x)), {"d"; "a"; "f"});
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
521 %! assert (fieldnames (x'), {"d"; "a"; "f"});
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
522 %! assert (fieldnames (x.'), {"d"; "a"; "f"});
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
523 */
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
524
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
525 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
526 octave_map::reshape (const dim_vector& dv) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
527 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
528 octave_map retval (m_keys);
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
529 retval.m_dimensions = dv;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
530
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
531 // When reshaping m_vals the Array constructor chops trailing singletons,
23832
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
532 // hence we need to do the same for the whole map.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
533 retval.m_dimensions.chop_trailing_singletons ();
23832
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
534
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
535 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
536 if (nf > 0)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
537 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
538 retval.m_vals.reserve (nf);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
539 for (octave_idx_type i = 0; i < nf; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
540 retval.m_vals[i] = m_vals[i].reshape (dv);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
541 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
542 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
543 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
544 // FIXME: Do it with a dummy array, to reuse error message.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
545 // Need (?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
546 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
547 dummy.reshape (dv);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
548 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
549
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
550 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
551
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
552 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
553 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
554
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
555 /*
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
556 ## test preservation of key order by reshape
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
557 %!test
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
558 %! x(1,1).d = 10; x(4,6).a = "b"; x(2,4).f = 27;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
559 %! assert (fieldnames (reshape (x, 3, 8)), {"d"; "a"; "f"});
23832
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
560
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
561 ## test chopping of trailing singletons
26946
04e5cb5e2cb3 update bug status in tests
John W. Eaton <jwe@octave.org>
parents: 26566
diff changeset
562 %!test <*51634>
23832
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
563 %! x(1,1).d = 10; x(4,6).a = "b"; x(2,4).f = 27;
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
564 %! reshape (x, 3, 8, 1, 1);
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
565
26946
04e5cb5e2cb3 update bug status in tests
John W. Eaton <jwe@octave.org>
parents: 26566
diff changeset
566 %!test <*46385>
28915
c40a367a84c0 maint: Use Octave convention of space after function name in libinterp/.
Rik <rik@octave.org>
parents: 27957
diff changeset
567 %! M = repmat (struct ('a', ones (100), 'b', true), 1, 2);
c40a367a84c0 maint: Use Octave convention of space after function name in libinterp/.
Rik <rik@octave.org>
parents: 27957
diff changeset
568 %! M = repmat (M, 1, 2);
23832
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
569 %! assert (size (M), [1, 4]);
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
570
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
571 libinterp/corefcn/oct-map.cc
3544f88a2bb5 Fix reshape of octave_map with trailing singletons (bug #51634, bug #45385, bug #43650).
Piotr Held <pjheld@gmail.com>
parents: 23678
diff changeset
572
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
573 */
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
574
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
575 void
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
576 octave_map::resize (const dim_vector& dv, bool fill)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
577 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
578 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
579 if (nf > 0)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
580 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
581 for (octave_idx_type i = 0; i < nf; i++)
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
582 {
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
583 if (fill)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
584 m_vals[i].resize (dv, Matrix ());
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
585 else
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
586 m_vals[i].resize (dv);
10743
cb3ed842bd30 make the new interface more backward compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10742
diff changeset
587 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
588 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
589 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
590 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
591 // FIXME: Do it with a dummy array, to reuse error message.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
592 // Need (?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
593 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
594 dummy.resize (dv);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
595 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
596
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
597 m_dimensions = dv;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
598 optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
599 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
600
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
601 void
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
602 octave_map::do_cat (int dim, octave_idx_type n,
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
603 const octave_scalar_map *map_list,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
604 octave_map& retval)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
605 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
606 octave_idx_type nf = retval.nfields ();
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
607 retval.m_vals.reserve (nf);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
608
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
609 dim_vector& rd = retval.m_dimensions;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
610 rd.resize (dim+1, 1);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
611 rd(0) = rd(1) = 1;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
612 rd(dim) = n;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
613
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
614 for (octave_idx_type j = 0; j < nf; j++)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
615 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
616 retval.m_vals.push_back (Cell (rd));
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
617 assert (retval.m_vals[j].numel () == n);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
618 for (octave_idx_type i = 0; i < n; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
619 retval.m_vals[j].xelem (i) = map_list[i].m_vals[j];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
620 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
621 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
622
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
623 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
624 octave_map::do_cat (int dim, octave_idx_type n, const octave_map *map_list,
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
625 octave_map& retval)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
626 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
627 octave_idx_type nf = retval.nfields ();
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
628 retval.m_vals.reserve (nf);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
629
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
630 OCTAVE_LOCAL_BUFFER (Array<octave_value>, field_list, n);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
631
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
632 for (octave_idx_type j = 0; j < nf; j++)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
633 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
634 for (octave_idx_type i = 0; i < n; i++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
635 field_list[i] = map_list[i].m_vals[j];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
636
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
637 retval.m_vals.push_back (Array<octave_value>::cat (dim, n, field_list));
10764
e141bcb1befd implement map concat optimizations for [] operator
Jaroslav Hajek <highegg@gmail.com>
parents: 10763
diff changeset
638 if (j == 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
639 retval.m_dimensions = retval.m_vals[j].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
640 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
641 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
642
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
643 // This is just a wrapper.
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
644 void permute_to_correct_order1 (const octave_scalar_map& ref,
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
645 const octave_scalar_map& src,
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
646 octave_scalar_map& dest,
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
647 Array<octave_idx_type>& perm)
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
648 {
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
649 dest = src.orderfields (ref, perm);
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
650 }
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
651
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
652 // In non-scalar case, we also promote empty structs without fields.
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
653 void permute_to_correct_order1 (const octave_map& ref, const octave_map& src,
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
654 octave_map& dest, Array<octave_idx_type>& perm)
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
655 {
23577
80c42f4cca13 maint: Deprecate is_empty and replace with isempty.
Rik <rik@octave.org>
parents: 23487
diff changeset
656 if (src.nfields () == 0 && src.isempty ())
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
657 dest = octave_map (src.dims (), ref.keys ());
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
658 else
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
659 dest = src.orderfields (ref, perm);
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
660 }
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
661
21139
538b57866b90 consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents: 20982
diff changeset
662 template <typename map>
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
663 static void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
664 permute_to_correct_order (octave_idx_type n, octave_idx_type nf,
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
665 octave_idx_type idx, const map *map_list,
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
666 map *new_map_list)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
667 {
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
668 new_map_list[idx] = map_list[idx];
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
669
11570
57632dea2446 attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
670 Array<octave_idx_type> perm (dim_vector (1, nf));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
671
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
672 try
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
673 {
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
674 for (octave_idx_type i = 0; i < n; i++)
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
675 {
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
676 if (i == idx)
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
677 continue;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
678
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
679 permute_to_correct_order1 (map_list[idx], map_list[i],
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
680 new_map_list[i], perm);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
681 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
682 }
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
683 catch (octave::execution_exception& ee)
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
684 {
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
685 error (ee, "cat: field names mismatch in concatenating structs");
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
686 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
687 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
688
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
689 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
690 octave_map::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: 10649
diff changeset
691 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
692 octave_map retval;
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
693
10763
b397b8edd8c5 fix off-by-1 dim in scalar map horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents: 10760
diff changeset
694 // Allow dim = -1, -2 for compatibility, though it makes no difference here.
b397b8edd8c5 fix off-by-1 dim in scalar map horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents: 10760
diff changeset
695 if (dim == -1 || dim == -2)
b397b8edd8c5 fix off-by-1 dim in scalar map horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents: 10760
diff changeset
696 dim = -dim - 1;
b397b8edd8c5 fix off-by-1 dim in scalar map horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents: 10760
diff changeset
697 else if (dim < 0)
20650
a6a452346c42 use error and error_with_id directly in libinterp code
John W. Eaton <jwe@octave.org>
parents: 20558
diff changeset
698 error ("cat: invalid dimension");
10763
b397b8edd8c5 fix off-by-1 dim in scalar map horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents: 10760
diff changeset
699
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
700 if (n == 1)
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
701 retval = map_list[0];
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
702 else if (n > 1)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
703 {
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
704 octave_idx_type idx, nf = 0;
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
705 for (idx = 0; idx < n; idx++)
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
706 {
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
707 nf = map_list[idx].nfields ();
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
708 if (nf > 0)
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
709 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
710 retval.m_keys = map_list[idx].m_keys;
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
711 break;
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
712 }
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
713 }
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
714
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
715 if (nf > 0)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
716 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
717 // Try the fast case.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
718 bool all_same = true;
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
719 for (octave_idx_type i = 0; i < n; i++)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
720 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
721 all_same = map_list[idx].m_keys.is_same (map_list[i].m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
722 if (! all_same)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
723 break;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
724 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
725
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
726 if (all_same)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
727 do_cat (dim, n, map_list, retval);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
728 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
729 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
730 // permute all structures to common order.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
731 OCTAVE_LOCAL_BUFFER (octave_scalar_map, new_map_list, n);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
732
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
733 permute_to_correct_order (n, nf, idx, map_list, new_map_list);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
734
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
735 do_cat (dim, n, new_map_list, retval);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
736 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
737
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
738 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
739 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
740 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
741 dim_vector& rd = retval.m_dimensions;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
742 rd.resize (dim+1, 1);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
743 rd(0) = rd(1) = 1;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
744 rd(dim) = n;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
745 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
746
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
747 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
748 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
749
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
750 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
751 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
752
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
753 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
754 octave_map::cat (int dim, octave_idx_type n, const octave_map *map_list)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
755 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
756 octave_map retval;
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
757
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
758 // Allow dim = -1, -2 for compatibility, though it makes no difference here.
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
759 if (dim == -1 || dim == -2)
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
760 dim = -dim - 1;
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
761 else if (dim < 0)
20650
a6a452346c42 use error and error_with_id directly in libinterp code
John W. Eaton <jwe@octave.org>
parents: 20558
diff changeset
762 error ("cat: invalid dimension");
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
763
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
764 if (n == 1)
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
765 retval = map_list[0];
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
766 else if (n > 1)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
767 {
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
768 octave_idx_type idx, nf = 0;
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
769
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
770 for (idx = 0; idx < n; idx++)
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
771 {
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
772 nf = map_list[idx].nfields ();
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
773 if (nf > 0)
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
774 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
775 retval.m_keys = map_list[idx].m_keys;
10937
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
776 break;
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
777 }
f42e8c6196c3 tweaks in concatenation of empty structs
Jaroslav Hajek <highegg@gmail.com>
parents: 10766
diff changeset
778 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
779
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
780 // Try the fast case.
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
781 bool all_same = true;
13968
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
782
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
783 if (nf > 0)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
784 {
13968
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
785 for (octave_idx_type i = 0; i < n; i++)
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
786 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
787 all_same = map_list[idx].m_keys.is_same (map_list[i].m_keys);
13968
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
788
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
789 if (! all_same)
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
790 break;
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
791 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
792 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
793
13968
241f68fb48c3 octave_map::cat: avoid indexing beyond end of array
John W. Eaton <jwe@octave.org>
parents: 13754
diff changeset
794 if (all_same && nf > 0)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
795 do_cat (dim, n, map_list, retval);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
796 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
797 {
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
798 if (nf > 0)
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
799 {
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
800 // permute all structures to correct order.
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
801 OCTAVE_LOCAL_BUFFER (octave_map, new_map_list, n);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
802
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
803 permute_to_correct_order (n, nf, idx, map_list, new_map_list);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
804
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
805 do_cat (dim, n, new_map_list, retval);
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
806 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
807 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
808 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
809 dim_vector dv = map_list[0].m_dimensions;
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
810
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
811 for (octave_idx_type i = 1; i < n; i++)
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
812 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
813 if (! dv.concat (map_list[i].m_dimensions, dim))
20831
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
814 error ("dimension mismatch in struct concatenation");
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
815 }
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
816
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
817 retval.m_dimensions = dv;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
818 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
819 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
820
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
821 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
822 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
823
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
824 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
825 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
826
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
827 /*
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
828 ## test preservation of key order by concatenation
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
829 %!test
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
830 %! x(1, 1).d = 10; x(4, 6).a = "b"; x(2, 4).f = 27;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
831 %! y(1, 6).f = 11; y(1, 6).a = "c"; y(1, 6).d = 33;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
832 %! assert (fieldnames ([x; y]), {"d"; "a"; "f"});
13754
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
833
e652ff4d1522 don't crash when concatenating structs with no fields
John W. Eaton <jwe@octave.org>
parents: 11586
diff changeset
834 %!test
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
835 %! s = struct ();
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
836 %! sr = [s,s];
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
837 %! sc = [s;s];
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
838 %! sm = [s,s;s,s];
18538
fcd87f68af4f Deprecate nfields and replace with numfields.
Rik <rik@octave.org>
parents: 18402
diff changeset
839 %! assert (numfields (sr), 0);
fcd87f68af4f Deprecate nfields and replace with numfields.
Rik <rik@octave.org>
parents: 18402
diff changeset
840 %! assert (numfields (sc), 0);
fcd87f68af4f Deprecate nfields and replace with numfields.
Rik <rik@octave.org>
parents: 18402
diff changeset
841 %! assert (numfields (sm), 0);
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
842 %! assert (size (sr), [1, 2]);
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
843 %! assert (size (sc), [2, 1]);
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
844 %! assert (size (sm), [2, 2]);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
845 */
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
846
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
847 octave_map
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
848 octave_map::index (const octave::idx_vector& i, bool resize_ok) const
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
849 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
850 octave_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
851 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
852
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
853 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
854 retval.m_vals[k] = m_vals[k].index (i, resize_ok);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
855
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
856 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
857 retval.m_dimensions = retval.m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
858 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
859 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
860 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
861 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
862 dummy = dummy.index (i, resize_ok);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
863 retval.m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
864 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
865
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
866 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
867
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
868 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
869 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
870
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
871 octave_map
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
872 octave_map::index (const octave::idx_vector& i, const octave::idx_vector& j,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
873 bool resize_ok) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
874 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
875 octave_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
876 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
877
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
878 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
879 retval.m_vals[k] = m_vals[k].index (i, j, resize_ok);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
880
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
881 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
882 retval.m_dimensions = retval.m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
883 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
884 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
885 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
886 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
887 dummy = dummy.index (i, j, resize_ok);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
888 retval.m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
889 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
890
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
891 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
892
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
893 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
894 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
895
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
896 octave_map
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
897 octave_map::index (const Array<octave::idx_vector>& ia, bool resize_ok) const
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
898 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
899 octave_map retval (m_keys);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
900 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
901
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
902 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
903 retval.m_vals[k] = m_vals[k].index (ia, resize_ok);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
904
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
905 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
906 retval.m_dimensions = retval.m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
907 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
908 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
909 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
910 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
911 dummy = dummy.index (ia, resize_ok);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
912 retval.m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
913 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
914
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
915 retval.optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
916
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
917 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
918 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
919
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
920 octave_map
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
921 octave_map::index (const octave_value_list& idx, bool resize_ok) const
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
922 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
923 octave_idx_type n_idx = idx.length ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
924 octave_map retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
925
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
926 // If we catch an indexing error in index_vector, we flag an error in
27956
2310164737b3 fix many spelling errors (bug #57613)
John W. Eaton <jwe@octave.org>
parents: 26566
diff changeset
927 // index k. Ensure it is the right value before each idx_vector call.
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
928 // Same variable as used in the for loop in the default case.
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
929
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
930 octave_idx_type k = 0;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
931
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
932 try
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
933 {
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
934 switch (n_idx)
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
935 {
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
936 case 1:
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
937 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
938 octave::idx_vector i = idx(0).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
939
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
940 retval = index (i, resize_ok);
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
941 }
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
942 break;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
943
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
944 case 2:
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
945 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
946 octave::idx_vector i = idx(0).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
947
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
948 k = 1;
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
949 octave::idx_vector j = idx(1).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
950
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
951 retval = index (i, j, resize_ok);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
952 }
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
953 break;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
954
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
955 default:
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
956 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
957 Array<octave::idx_vector> ia (dim_vector (n_idx, 1));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
958
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
959 for (k = 0; k < n_idx; k++)
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
960 ia(k) = idx(k).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
961
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
962 retval = index (ia, resize_ok);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
963 }
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
964 break;
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
965 }
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
966 }
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
967 catch (octave::index_exception& ie)
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
968 {
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
969 // Rethrow to allow more info to be reported later.
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
970 ie.set_pos_if_unset (n_idx, k+1);
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
971 throw;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
972 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
973
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
974 return retval;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
975 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
976
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
977 // Perhaps one day these will be optimized. Right now, they just call index.
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
978 octave_map
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
979 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
980 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
981 return index (octave::idx_vector::colon, k);
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
982 }
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
983
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
984 octave_map
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
985 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
986 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
987 static Array<octave::idx_vector> ia (dim_vector (3, 1), octave::idx_vector::colon);
10755
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
988
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
989 ia(2) = k;
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
990 return index (ia);
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
991 }
6ba7937a6fa4 more array-like methods in octave_map
Jaroslav Hajek <highegg@gmail.com>
parents: 10753
diff changeset
992
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
993 void
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
994 octave_map::assign (const octave::idx_vector& i, const octave_map& rhs)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
995 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
996 if (rhs.m_keys.is_same (m_keys))
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
997 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
998 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
999
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1000 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1001 m_vals[k].assign (i, rhs.m_vals[k], Matrix ());
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1002
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1003 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1004 m_dimensions = m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1005 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1006 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
1007 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1008 Array<char> dummy (m_dimensions), rhs_dummy (rhs.m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1009 dummy.assign (i, rhs_dummy);;
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1010 m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1011 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1012
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1013 optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1014 }
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1015 else if (nfields () == 0)
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1016 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1017 octave_map tmp (m_dimensions, rhs.m_keys);
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1018 tmp.assign (i, rhs);
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1019 *this = tmp;
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1020 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1021 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1022 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1023 Array<octave_idx_type> perm;
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1024 octave_map rhs1;
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1025
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1026 try
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1027 {
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1028 rhs1 = rhs.orderfields (*this, perm);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1029 }
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1030 catch (octave::execution_exception& ee)
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1031 {
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1032 error (ee, "incompatible fields in struct assignment");
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1033 }
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1034
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1035 assert (rhs1.m_keys.is_same (m_keys));
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1036 assign (i, rhs1);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1037 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1038 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1039
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1040 void
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1041 octave_map::assign (const octave::idx_vector& i, const octave::idx_vector& j,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1042 const octave_map& rhs)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1043 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1044 if (rhs.m_keys.is_same (m_keys))
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1045 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1046 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1047
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1048 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1049 m_vals[k].assign (i, j, rhs.m_vals[k], Matrix ());
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1050
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1051 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1052 m_dimensions = m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1053 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1054 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
1055 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1056 Array<char> dummy (m_dimensions), rhs_dummy (rhs.m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1057 dummy.assign (i, j, rhs_dummy);;
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1058 m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1059 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1060
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1061 optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1062 }
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1063 else if (nfields () == 0)
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1064 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1065 octave_map tmp (m_dimensions, rhs.m_keys);
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1066 tmp.assign (i, j, rhs);
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1067 *this = tmp;
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1068 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1069 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1070 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1071 Array<octave_idx_type> perm;
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1072 octave_map rhs1;
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1073
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1074 try
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1075 {
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1076 rhs1 = rhs.orderfields (*this, perm);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1077 }
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1078 catch (octave::execution_exception& ee)
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1079 {
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1080 error (ee, "incompatible fields in struct assignment");
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1081 }
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1082
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1083 assert (rhs1.m_keys.is_same (m_keys));
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1084 assign (i, j, rhs1);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1085 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1086 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1087
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1088 void
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1089 octave_map::assign (const Array<octave::idx_vector>& ia,
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1090 const octave_map& rhs)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1091 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1092 if (rhs.m_keys.is_same (m_keys))
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1093 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1094 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1095
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1096 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1097 m_vals[k].assign (ia, rhs.m_vals[k], Matrix ());
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1098
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1099 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1100 m_dimensions = m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1101 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1102 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
1103 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1104 Array<char> dummy (m_dimensions), rhs_dummy (rhs.m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1105 dummy.assign (ia, rhs_dummy);;
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1106 m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1107 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1108
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1109 optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1110 }
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1111 else if (nfields () == 0)
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1112 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1113 octave_map tmp (m_dimensions, rhs.m_keys);
10753
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1114 tmp.assign (ia, rhs);
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1115 *this = tmp;
bee1b1a2e29a yield compatible dims from cell2struct + more fixes. build & tests OK
Jaroslav Hajek <highegg@gmail.com>
parents: 10750
diff changeset
1116 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1117 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1118 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1119 Array<octave_idx_type> perm;
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1120 octave_map rhs1;
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1121
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1122 try
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1123 {
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1124 rhs1 = rhs.orderfields (*this, perm);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1125 }
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1126 catch (octave::execution_exception& ee)
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1127 {
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1128 error (ee, "incompatible fields in struct assignment");
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1129 }
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1130
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1131 assert (rhs1.m_keys.is_same (m_keys));
20741
a5ab31b52ae8 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20650
diff changeset
1132 assign (ia, rhs1);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1133 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1134 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1135
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1136 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1137 octave_map::assign (const octave_value_list& idx, const octave_map& rhs)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1138 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1139 octave_idx_type n_idx = idx.length ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1140
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1141 // If we catch an indexing error in index_vector, we flag an error in
27956
2310164737b3 fix many spelling errors (bug #57613)
John W. Eaton <jwe@octave.org>
parents: 26566
diff changeset
1142 // index k. Ensure it is the right value before each idx_vector call.
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1143 // Same variable as used in the for loop in the default case.
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1144
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1145 octave_idx_type k = 0;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1146
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1147 try
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1148 {
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1149 switch (n_idx)
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1150 {
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1151 case 1:
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1152 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1153 octave::idx_vector i = idx(0).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1154
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
1155 assign (i, rhs);
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1156 }
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1157 break;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1158
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1159 case 2:
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1160 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1161 octave::idx_vector i = idx(0).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1162
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
1163 k = 1;
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1164 octave::idx_vector j = idx(1).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1165
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1166 assign (i, j, rhs);
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1167 }
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1168 break;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1169
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1170 default:
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1171 {
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1172 Array<octave::idx_vector> ia (dim_vector (n_idx, 1));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1173
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1174 for (k = 0; k < n_idx; k++)
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
1175 ia(k) = idx(k).index_vector ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1176
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
1177 assign (ia, rhs);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1178 }
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1179 break;
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1180 }
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1181 }
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1182 catch (octave::index_exception& ie)
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1183 {
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1184 // Rethrow to allow more info to be reported later.
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1185 ie.set_pos_if_unset (n_idx, k+1);
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1186 throw;
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1187 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1188 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1189
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1190 void
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1191 octave_map::assign (const octave_value_list& idx, const std::string& k,
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1192 const Cell& rhs)
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1193 {
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1194 Cell tmp;
25337
3ff9192b676e use auto keyword to declare iterator variables where possible
John W. Eaton <jwe@octave.org>
parents: 25054
diff changeset
1195 auto p = seek (k);
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23449
diff changeset
1196 Cell& ref = (p != end () ? contents (p) : tmp);
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1197
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1198 if (&ref == &tmp)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1199 ref = Cell (m_dimensions);
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1200
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1201 ref.assign (idx, rhs);
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
1202
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1203 if (ref.dims () != m_dimensions)
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1204 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1205 m_dimensions = ref.dims ();
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1206
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1207 octave_idx_type nf = nfields ();
10750
f75e827649a5 struct rewrite: 4 failures remaining
Jaroslav Hajek <highegg@gmail.com>
parents: 10749
diff changeset
1208 for (octave_idx_type i = 0; i < nf; i++)
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1209 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1210 if (&m_vals[i] != &ref)
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1211 m_vals[i].resize (m_dimensions, Matrix ());
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1212 }
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1213
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1214 optimize_dimensions ();
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1215 }
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1216
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
1217 if (&ref == &tmp)
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1218 setfield (k, tmp);
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1219 }
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1220
14568
82449d607d20 correctly fill struct arrays for assignments that cause resizing (bug #33178)
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
1221 /*
82449d607d20 correctly fill struct arrays for assignments that cause resizing (bug #33178)
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
1222 %!test
82449d607d20 correctly fill struct arrays for assignments that cause resizing (bug #33178)
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
1223 %! rhs.b = 1;
82449d607d20 correctly fill struct arrays for assignments that cause resizing (bug #33178)
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
1224 %! a(3) = rhs;
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21574
diff changeset
1225 %! assert ({a.b}, {[], [], 1});
14568
82449d607d20 correctly fill struct arrays for assignments that cause resizing (bug #33178)
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
1226 */
82449d607d20 correctly fill struct arrays for assignments that cause resizing (bug #33178)
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
1227
10749
df1a3e0ebbff important fixes for struct rewrite(1)
Jaroslav Hajek <highegg@gmail.com>
parents: 10746
diff changeset
1228 void
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1229 octave_map::delete_elements (const octave::idx_vector& i)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1230 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1231 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1232 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1233 m_vals[k].delete_elements (i);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1234
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1235 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1236 m_dimensions = m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1237 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1238 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
1239 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1240 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1241 dummy.delete_elements (i);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1242 m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1243 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1244
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1245 optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1246 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1247
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1248 void
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1249 octave_map::delete_elements (int dim, const octave::idx_vector& i)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1250 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1251 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1252 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1253 m_vals[k].delete_elements (dim, i);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1254
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1255 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1256 m_dimensions = m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1257 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1258 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
1259 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1260 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1261 dummy.delete_elements (dim, i);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1262 m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1263 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1264
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1265 optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1266 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1267
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1268 void
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1269 octave_map::delete_elements (const Array<octave::idx_vector>& ia)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1270 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1271 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1272 for (octave_idx_type k = 0; k < nf; k++)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1273 m_vals[k].delete_elements (ia);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1274
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1275 if (nf > 0)
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1276 m_dimensions = m_vals[0].dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1277 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1278 {
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
1279 // Use dummy array. FIXME: Need(?) a better solution.
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1280 Array<char> dummy (m_dimensions);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1281 dummy.delete_elements (ia);
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1282 m_dimensions = dummy.dims ();
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1283 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1284
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1285 optimize_dimensions ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1286 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1287
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1288 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1289 octave_map::delete_elements (const octave_value_list& idx)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1290 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1291 octave_idx_type n_idx = idx.length ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1292
29569
29a1f8fd8ee6 move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29359
diff changeset
1293 Array<octave::idx_vector> ia (dim_vector (n_idx, 1));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1294
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1295 for (octave_idx_type i = 0; i < n_idx; i++)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1296 {
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1297 try
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1298 {
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1299 ia(i) = idx(i).index_vector ();
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1300 }
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1301 catch (octave::index_exception& ie)
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1302 {
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1303 // Rethrow to allow more info to be reported later.
29163
8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents: 28915
diff changeset
1304 ie.set_pos_if_unset (n_idx, i+1);
20542
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1305 throw;
dd6345fd8a97 use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents: 20232
diff changeset
1306 }
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1307 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1308
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20542
diff changeset
1309 delete_elements (ia);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1310 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1311
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1312 /*
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1313 ## test preservation of key order by indexing
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1314 %!test
14429
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1315 %! x(1, 1).d = 10; x(4, 6).a = "b"; x(2, 4).f = 27;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1316 %! assert (fieldnames (x([1, 2], [2:5])), {"d"; "a"; "f"});
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1317 */
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1318
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1319 octave_map
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1320 octave_map::concat (const octave_map& rb, const Array<octave_idx_type>& ra_idx)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1321 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1322 if (nfields () == rb.nfields ())
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1323 {
25343
4d7790d9793f use cbegin, crbegin, cend, and crend and auto decls where possible
John W. Eaton <jwe@octave.org>
parents: 25342
diff changeset
1324 for (auto pa = cbegin (); pa != cend (); pa++)
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1325 {
25343
4d7790d9793f use cbegin, crbegin, cend, and crend and auto decls where possible
John W. Eaton <jwe@octave.org>
parents: 25342
diff changeset
1326 auto pb = rb.seek (key (pa));
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1327
25343
4d7790d9793f use cbegin, crbegin, cend, and crend and auto decls where possible
John W. Eaton <jwe@octave.org>
parents: 25342
diff changeset
1328 if (pb == rb.cend ())
20831
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1329 error ("field name mismatch in structure concatenation");
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11570
diff changeset
1330
14861
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
1331 contents(pa).insert (rb.contents (pb), ra_idx);
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1332 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1333 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1334 else
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1335 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1336 dim_vector dv = dims ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1337
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1338 if (dv.all_zero ())
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1339 *this = rb;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1340 else if (! rb.dims ().all_zero ())
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1341 error ("invalid structure concatenation");
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1342 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1343
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1344 return *this;
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1345 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1346
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1347 void
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1348 octave_map::optimize_dimensions (void)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1349 {
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1350 octave_idx_type nf = nfields ();
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1351
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1352 for (octave_idx_type i = 0; i < nf; i++)
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1353 {
29922
adda9f3ac61f use m_ prefix for data members in octave_map classes
John W. Eaton <jwe@octave.org>
parents: 29655
diff changeset
1354 if (! m_vals[i].optimize_dimensions (m_dimensions))
20831
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1355 error ("internal error: dimension mismatch across fields in struct");
10742
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1356 }
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1357
604e13a89c7f initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents: 10649
diff changeset
1358 }