Mercurial > hg > octave-nkf
annotate src/oct-map.cc @ 10160:cd96d29c5efa
remove Emacs local-variable settings from source files in src directory
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Wed, 20 Jan 2010 20:39:26 -0500 |
| parents | b4fdfee405b5 |
| children | 57a59eae83cc |
| rev | line source |
|---|---|
| 1278 | 1 /* |
| 2 | |
| 8920 | 3 Copyright (C) 1995, 1996, 1997, 2002, 2003, 2004, 2005, 2006, 2007, |
| 4 2008, 2009 John W. Eaton | |
| 1278 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 1278 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 1278 | 21 |
| 22 */ | |
| 23 | |
| 24 #ifdef HAVE_CONFIG_H | |
| 25 #include <config.h> | |
| 26 #endif | |
| 27 | |
| 3932 | 28 #include "error.h" |
| 1755 | 29 #include "str-vec.h" |
| 30 | |
| 1278 | 31 #include "oct-map.h" |
| 32 #include "utils.h" | |
| 33 | |
| 6959 | 34 Octave_map::Octave_map (const dim_vector& dv, const Cell& key_vals) |
| 5880 | 35 : map (), key_list (), dimensions (dv) |
| 36 { | |
| 37 Cell c (dv); | |
| 38 | |
| 6959 | 39 if (key_vals.is_cellstr ()) |
| 5880 | 40 { |
| 6959 | 41 for (octave_idx_type i = 0; i < key_vals.numel (); i++) |
| 6946 | 42 { |
| 6959 | 43 std::string k = key_vals(i).string_value (); |
| 6946 | 44 map[k] = c; |
| 45 key_list.push_back (k); | |
| 46 } | |
| 5880 | 47 } |
| 6946 | 48 else |
| 49 error ("Octave_map: expecting keys to be cellstr"); | |
| 5880 | 50 } |
| 51 | |
| 7046 | 52 Octave_map |
| 53 Octave_map::squeeze (void) const | |
| 54 { | |
| 55 Octave_map retval (dims ().squeeze ()); | |
| 56 | |
| 57 for (const_iterator pa = begin (); pa != end (); pa++) | |
| 58 { | |
| 59 Cell tmp = contents (pa).squeeze (); | |
| 60 | |
| 61 if (error_state) | |
| 62 break; | |
| 63 | |
| 64 retval.assign (key (pa), tmp); | |
| 65 } | |
| 66 | |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
67 // Preserve order of keys. |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
68 retval.key_list = key_list; |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
69 |
| 7046 | 70 return retval; |
| 71 } | |
| 72 | |
|
9392
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
73 /* |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
74 %!# test preservation of keys by squeeze |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
75 %!test |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
76 %! x(1,1,1,1).d = 10; x(3,5,1,7).a = "b"; x(2,4,1,7).f = 27; |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
77 %! assert (fieldnames (squeeze (x)), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
78 */ |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
79 |
| 7046 | 80 Octave_map |
| 81 Octave_map::permute (const Array<int>& vec, bool inv) const | |
| 82 { | |
| 83 Octave_map retval (dims ()); | |
| 84 | |
| 85 for (const_iterator pa = begin (); pa != end (); pa++) | |
| 86 { | |
| 87 Cell tmp = contents (pa).permute (vec, inv); | |
| 88 | |
| 89 if (error_state) | |
| 90 break; | |
| 91 | |
| 92 retval.assign (key (pa), tmp); | |
| 93 } | |
| 94 | |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
95 // Preserve order of keys. |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
96 retval.key_list = key_list; |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
97 |
| 7046 | 98 return retval; |
| 99 } | |
| 100 | |
|
9392
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
101 /* |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
102 %!# test preservation of key order by permute |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
103 %!test |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
104 %! x(1,1,1,1).d = 10; x(3,5,1,7).a = "b"; x(2,4,1,7).f = 27; |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
105 %! assert (fieldnames (permute (x, [3, 4, 1, 2])), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
106 */ |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
107 |
| 5328 | 108 Cell& |
| 109 Octave_map::contents (const std::string& k) | |
| 110 { | |
| 5880 | 111 maybe_add_to_key_list (k); |
| 112 | |
| 5328 | 113 return map[k]; |
| 114 } | |
| 115 | |
| 4513 | 116 Cell |
| 4675 | 117 Octave_map::contents (const std::string& k) const |
| 4197 | 118 { |
| 4587 | 119 const_iterator p = seek (k); |
| 4197 | 120 |
| 4513 | 121 return p != end () ? p->second : Cell (); |
| 4197 | 122 } |
| 123 | |
| 5156 | 124 int |
| 125 Octave_map::intfield (const std::string& k, int def_val) const | |
| 126 { | |
| 127 int retval = def_val; | |
| 128 | |
| 129 Cell c = contents (k); | |
| 130 | |
| 131 if (! c.is_empty ()) | |
| 132 retval = c(0).int_value (); | |
| 133 | |
| 134 return retval; | |
| 135 } | |
| 136 | |
| 137 std::string | |
| 138 Octave_map::stringfield (const std::string& k, | |
| 139 const std::string& def_val) const | |
| 140 { | |
| 141 std::string retval = def_val; | |
| 142 | |
| 143 Cell c = contents (k); | |
| 144 | |
| 145 if (! c.is_empty ()) | |
| 146 retval = c(0).string_value (); | |
| 147 | |
| 148 return retval; | |
| 149 } | |
| 150 | |
| 1755 | 151 string_vector |
| 3933 | 152 Octave_map::keys (void) const |
| 1278 | 153 { |
| 6639 | 154 assert (nfields () == key_list.size ()); |
| 5881 | 155 |
| 5880 | 156 return string_vector (key_list); |
| 1278 | 157 } |
| 158 | |
| 4567 | 159 Octave_map |
| 5571 | 160 Octave_map::transpose (void) const |
| 161 { | |
| 162 assert (ndims () == 2); | |
| 5593 | 163 |
| 5571 | 164 dim_vector dv = dims (); |
| 165 | |
| 5593 | 166 octave_idx_type nr = dv(0); |
| 167 octave_idx_type nc = dv(1); | |
| 168 | |
| 169 dim_vector new_dims (nc, nr); | |
| 170 | |
| 171 Octave_map retval (new_dims); | |
| 5571 | 172 |
| 173 for (const_iterator p = begin (); p != end (); p++) | |
| 174 retval.assign (key(p), Cell (contents(p).transpose ())); | |
| 175 | |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
176 // Preserve order of keys. |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
177 retval.key_list = key_list; |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
178 |
| 5571 | 179 return retval; |
| 180 } | |
| 181 | |
|
9392
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
182 /* |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
183 %!# test preservation of key order by transpose |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
184 %!test |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
185 %! x(1,1).d = 10; x(3,5).a = "b"; x(2,4).f = 27; |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
186 %! assert (fieldnames (transpose (x)), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
187 %! assert (fieldnames (x'), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
188 %! assert (fieldnames (x.'), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
189 */ |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
190 |
| 5571 | 191 Octave_map |
| 4567 | 192 Octave_map::reshape (const dim_vector& new_dims) const |
| 193 { | |
| 194 Octave_map retval; | |
| 195 | |
| 196 if (new_dims != dims ()) | |
| 197 { | |
| 198 for (const_iterator p = begin (); p != end (); p++) | |
| 4675 | 199 retval.assign (key(p), contents(p).reshape (new_dims)); |
| 4567 | 200 |
| 4936 | 201 retval.dimensions = new_dims; |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
202 |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
203 // Preserve order of keys. |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
204 retval.key_list = key_list; |
| 4567 | 205 } |
| 4936 | 206 else |
| 207 retval = *this; | |
| 4567 | 208 |
| 209 return retval; | |
| 210 } | |
| 211 | |
|
9392
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
212 /* |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
213 %!# test preservation of key order by reshape |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
214 %!test |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
215 %! x(1,1).d = 10; x(4,6).a = "b"; x(2,4).f = 27; |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
216 %! assert (fieldnames (reshape (x, 3, 8)), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
217 */ |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
218 |
| 5781 | 219 void |
| 220 Octave_map::resize (const dim_vector& dv, bool fill) | |
| 4936 | 221 { |
| 222 if (dv != dims ()) | |
| 223 { | |
| 6639 | 224 if (nfields () == 0) |
| 6609 | 225 dimensions = dv; |
| 226 else | |
| 4936 | 227 { |
| 6609 | 228 for (const_iterator p = begin (); p != end (); p++) |
| 229 { | |
| 230 Cell tmp = contents(p); | |
| 5781 | 231 |
| 6609 | 232 if (fill) |
|
9380
182b7088af1c
oct-map.cc: fix thinko in previous change
John W. Eaton <jwe@octave.org>
parents:
9379
diff
changeset
|
233 tmp.resize (dv, Cell::resize_fill_value ()); |
| 6609 | 234 else |
|
9380
182b7088af1c
oct-map.cc: fix thinko in previous change
John W. Eaton <jwe@octave.org>
parents:
9379
diff
changeset
|
235 tmp.resize (dv); |
| 5781 | 236 |
| 6609 | 237 dimensions = dv; |
| 5781 | 238 |
| 6609 | 239 assign (key(p), tmp); |
| 240 } | |
| 4936 | 241 } |
| 242 } | |
| 243 } | |
| 244 | |
| 4915 | 245 Octave_map |
| 5275 | 246 Octave_map::concat (const Octave_map& rb, const Array<octave_idx_type>& ra_idx) |
| 4806 | 247 { |
| 4937 | 248 Octave_map retval; |
| 4936 | 249 |
| 6639 | 250 if (nfields () == rb.nfields ()) |
| 4936 | 251 { |
| 5881 | 252 for (const_iterator pa = begin (); pa != end (); pa++) |
| 4936 | 253 { |
| 5881 | 254 const_iterator pb = rb.seek (key(pa)); |
| 4937 | 255 |
| 5003 | 256 if (pb == rb.end ()) |
| 4937 | 257 { |
| 258 error ("field name mismatch in structure concatenation"); | |
| 259 break; | |
| 260 } | |
| 4936 | 261 |
| 5073 | 262 retval.assign (key(pa), |
| 263 contents(pa).insert (rb.contents(pb), ra_idx)); | |
| 4937 | 264 } |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
265 |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
266 // Preserve order of keys. |
|
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
267 retval.key_list = key_list; |
| 4936 | 268 } |
| 4937 | 269 else |
|
7959
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
270 { |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
271 dim_vector dv = dims (); |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
272 |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
273 if (dv.all_zero ()) |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
274 retval = rb; |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
275 else |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
276 { |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
277 dv = rb.dims (); |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
278 |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
279 if (dv.all_zero ()) |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
280 retval = *this; |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
281 else |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
282 error ("invalid structure concatenation"); |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
283 } |
|
a73b80cd1f10
allow empty matrix by cell (or struct) concatentation
John W. Eaton <jwe@octave.org>
parents:
7046
diff
changeset
|
284 } |
| 4937 | 285 |
| 4915 | 286 return retval; |
| 4806 | 287 } |
| 288 | |
|
9392
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
289 /* |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
290 %!# test preservation of key order by concatenation |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
291 %!test |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
292 %! x(1, 1).d = 10; x(4, 6).a = "b"; x(2, 4).f = 27; |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
293 %! y(1, 6).f = 11; y(1, 6).a = "c"; y(1, 6).d = 33; |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
294 %! assert (fieldnames ([x; y]), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
295 */ |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
296 |
| 6609 | 297 static bool |
| 298 keys_ok (const Octave_map& a, const Octave_map& b, string_vector& keys) | |
| 4197 | 299 { |
| 6609 | 300 bool retval = false; |
| 301 | |
| 302 keys = string_vector (); | |
| 4197 | 303 |
| 6639 | 304 if (a.nfields () == 0) |
| 6609 | 305 { |
| 306 keys = b.keys (); | |
| 307 retval = true; | |
| 308 } | |
| 309 else | |
| 310 { | |
|
8503
8ba2ee57c594
remove qsort in favor of sort
Jaroslav Hajek <highegg@gmail.com>
parents:
8294
diff
changeset
|
311 string_vector a_keys = a.keys().sort (); |
|
8ba2ee57c594
remove qsort in favor of sort
Jaroslav Hajek <highegg@gmail.com>
parents:
8294
diff
changeset
|
312 string_vector b_keys = b.keys().sort (); |
| 4197 | 313 |
| 6609 | 314 octave_idx_type a_len = a_keys.length (); |
| 315 octave_idx_type b_len = b_keys.length (); | |
| 316 | |
| 317 if (a_len == b_len) | |
| 4197 | 318 { |
| 6609 | 319 for (octave_idx_type i = 0; i < a_len; i++) |
| 320 { | |
| 321 if (a_keys[i] != b_keys[i]) | |
| 322 goto done; | |
| 323 } | |
| 4197 | 324 |
| 6609 | 325 keys = a_keys; |
| 326 retval = true; | |
| 327 } | |
| 4197 | 328 } |
| 6609 | 329 |
| 330 done: | |
| 4197 | 331 return retval; |
| 332 } | |
| 333 | |
| 334 Octave_map& | |
| 5592 | 335 Octave_map::maybe_delete_elements (const octave_value_list& idx) |
| 336 { | |
| 337 string_vector t_keys = keys(); | |
| 338 octave_idx_type len = t_keys.length (); | |
| 339 | |
| 340 if (len > 0) | |
| 341 { | |
| 342 for (octave_idx_type i = 0; i < len; i++) | |
| 343 { | |
| 344 std::string k = t_keys[i]; | |
| 345 | |
|
8175
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
7959
diff
changeset
|
346 map[k] = contents(k).delete_elements (idx); |
| 5592 | 347 |
| 348 if (error_state) | |
| 349 break; | |
| 350 } | |
| 351 | |
| 352 if (!error_state) | |
| 353 dimensions = contents(t_keys[0]).dims(); | |
| 354 } | |
| 355 | |
| 356 return *this; | |
| 357 } | |
| 358 | |
| 359 Octave_map& | |
| 4513 | 360 Octave_map::assign (const octave_value_list& idx, const Octave_map& rhs) |
| 4197 | 361 { |
| 6609 | 362 string_vector t_keys; |
| 4197 | 363 |
| 6609 | 364 if (keys_ok (*this, rhs, t_keys)) |
| 4197 | 365 { |
| 5275 | 366 octave_idx_type len = t_keys.length (); |
| 4197 | 367 |
| 6609 | 368 if (len == 0) |
| 4197 | 369 { |
| 6609 | 370 Cell tmp_lhs (dims ()); |
| 371 Cell tmp_rhs (rhs.dims ()); | |
| 372 | |
| 373 tmp_lhs.assign (idx, tmp_rhs, Matrix ()); | |
| 4197 | 374 |
| 6609 | 375 if (! error_state) |
| 376 resize (tmp_lhs.dims ()); | |
| 377 else | |
| 378 error ("size mismatch in structure assignment"); | |
| 379 } | |
| 380 else | |
| 381 { | |
| 382 for (octave_idx_type i = 0; i < len; i++) | |
| 383 { | |
| 384 std::string k = t_keys[i]; | |
| 4197 | 385 |
| 6609 | 386 Cell t_rhs = rhs.contents (k); |
| 387 | |
| 388 assign (idx, k, t_rhs); | |
| 4197 | 389 |
| 6609 | 390 if (error_state) |
| 391 break; | |
| 392 } | |
| 4197 | 393 } |
| 394 } | |
| 395 else | |
| 396 error ("field name mismatch in structure assignment"); | |
| 397 | |
| 398 return *this; | |
| 399 } | |
| 400 | |
| 3932 | 401 Octave_map& |
| 4587 | 402 Octave_map::assign (const octave_value_list& idx, const std::string& k, |
| 4513 | 403 const Cell& rhs) |
| 3932 | 404 { |
| 5881 | 405 Cell tmp; |
| 406 | |
| 407 if (contains (k)) | |
| 408 tmp = map[k]; | |
|
9127
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
409 else |
|
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
410 tmp = Cell (dimensions); |
| 3932 | 411 |
|
9127
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
412 tmp.assign (idx, rhs); |
| 3932 | 413 |
| 414 if (! error_state) | |
| 415 { | |
|
9127
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
416 dim_vector tmp_dims = tmp.dims (); |
| 3932 | 417 |
|
9127
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
418 if (tmp_dims != dimensions) |
| 3943 | 419 { |
| 4219 | 420 for (iterator p = begin (); p != end (); p++) |
|
9127
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
421 contents(p).resize (tmp_dims, Cell::resize_fill_value ()); |
|
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
422 |
|
5ec4dc52c131
fix empty struct indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
423 dimensions = tmp_dims; |
| 4561 | 424 } |
| 3932 | 425 |
| 5880 | 426 maybe_add_to_key_list (k); |
| 427 | |
| 4587 | 428 map[k] = tmp; |
| 3932 | 429 } |
| 430 | |
| 431 return *this; | |
| 432 } | |
| 433 | |
| 3933 | 434 Octave_map& |
| 4675 | 435 Octave_map::assign (const std::string& k, const octave_value& rhs) |
| 436 { | |
| 6639 | 437 if (nfields () == 0) |
| 4675 | 438 { |
| 5880 | 439 maybe_add_to_key_list (k); |
| 440 | |
| 4675 | 441 map[k] = Cell (rhs); |
| 442 | |
| 443 dimensions = dim_vector (1, 1); | |
| 444 } | |
| 445 else | |
| 446 { | |
| 447 dim_vector dv = dims (); | |
| 448 | |
| 449 if (dv.all_ones ()) | |
| 5880 | 450 { |
| 451 maybe_add_to_key_list (k); | |
| 452 | |
| 453 map[k] = Cell (rhs); | |
| 454 } | |
| 4675 | 455 else |
| 456 error ("invalid structure assignment"); | |
| 457 } | |
| 458 | |
| 459 return *this; | |
| 460 } | |
| 461 | |
| 462 Octave_map& | |
| 4587 | 463 Octave_map::assign (const std::string& k, const Cell& rhs) |
| 3933 | 464 { |
| 6639 | 465 if (nfields () == 0) |
| 4563 | 466 { |
| 5880 | 467 maybe_add_to_key_list (k); |
| 468 | |
| 4587 | 469 map[k] = rhs; |
| 4563 | 470 |
| 4730 | 471 dimensions = rhs.dims (); |
| 4563 | 472 } |
| 3933 | 473 else |
| 474 { | |
| 4562 | 475 if (dims () == rhs.dims ()) |
| 5880 | 476 { |
| 477 maybe_add_to_key_list (k); | |
| 478 | |
| 479 map[k] = rhs; | |
| 480 } | |
| 3933 | 481 else |
| 482 error ("invalid structure assignment"); | |
| 483 } | |
| 484 | |
| 485 return *this; | |
| 486 } | |
| 487 | |
| 488 Octave_map | |
| 7046 | 489 Octave_map::index (const octave_value_list& idx, bool resize_ok) const |
| 3933 | 490 { |
| 491 Octave_map retval; | |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
492 |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
493 octave_idx_type n_idx = idx.length (); |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
494 |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
495 if (n_idx > 0) |
| 3933 | 496 { |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
497 Array<idx_vector> ra_idx (n_idx); |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
498 |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
499 for (octave_idx_type i = 0; i < n_idx; i++) |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
500 { |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
501 ra_idx(i) = idx(i).index_vector (); |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
502 if (error_state) |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
503 break; |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
504 } |
| 3933 | 505 |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
506 if (! error_state) |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
507 { |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
508 for (const_iterator p = begin (); p != end (); p++) |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
509 { |
|
9379
d77fa87c47d8
oct-map.cc: preserve key order
John W. Eaton <jwe@octave.org>
parents:
9127
diff
changeset
|
510 Cell tmp = contents (p); |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
511 |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9392
diff
changeset
|
512 tmp = tmp.Array<octave_value>::index (ra_idx, resize_ok); |
| 3933 | 513 |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
514 if (error_state) |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
515 break; |
|
8294
b2a6309b2d87
oct-map.cc: copy key_list in indexing functions
John W. Eaton <jwe@octave.org>
parents:
8175
diff
changeset
|
516 |
|
8682
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
517 retval.assign (key(p), tmp); |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
518 } |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
519 |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
520 // Preserve order of keys. |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
521 retval.key_list = key_list; |
|
38968f09f7ca
optimize Octave_map::index
Jaroslav Hajek <highegg@gmail.com>
parents:
8679
diff
changeset
|
522 } |
| 3933 | 523 } |
| 5435 | 524 else |
| 5539 | 525 retval = *this; |
| 3933 | 526 |
| 5539 | 527 return retval; |
| 3933 | 528 } |
| 529 | |
| 1278 | 530 /* |
|
9392
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
531 %!# test preservation of key order by indexing |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
532 %!test |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
533 %! x(1, 1).d = 10; x(4, 6).a = "b"; x(2, 4).f = 27; |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
534 %! assert (fieldnames (x([1, 2], [2:5])), {"d"; "a"; "f"}); |
|
26c72e899228
Add tests for preservation of key order
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
9380
diff
changeset
|
535 */ |