octave-nkf: src/ov-cell.cc comparison

comparison src/ov-cell.cc @ 11586:12df7854fa7c

strip trailing whitespace from source files

author	John W. Eaton <jwe@octave.org>
date	Thu, 20 Jan 2011 17:24:59 -0500
parents	fd0a3ac60b0e
children	7a5aacf65f81

comparison

equal deleted inserted replaced

-:1473d0cf86d2
+:12df7854fa7c
 return octave_value ();
 }
 template <>
 bool
 octave_base_matrix<Cell>::fast_elem_insert (octave_idx_type n,
 const octave_value& x)
 {
 const octave_cell *xrep =
 dynamic_cast<const octave_cell *> (&x.get_rep ());
 bool retval = xrep && xrep->matrix.numel () == 1 && n < matrix.numel ();
 if (retval)
 matrix(n) = xrep->matrix(0);
 {
 tmp = octave_value::empty_conv (type.substr (1), rhs);
 tmp.make_unique (); // probably a no-op.
 }
 else
 // optimization: ignore the copy still stored inside our array.
 tmp.make_unique (1);
 if (! error_state)
 t_rhs = tmp.subsasgn (next_type, next_idx, rhs);
 }
 }
 return retval;
 }
 bool
 octave_cell::is_cellstr (void) const
 {
 bool retval;
 if (cellstr_cache.get ())
 retval = true;
 }
 return retval;
 }
 void
 octave_cell::assign (const octave_value_list& idx, const Cell& rhs)
 {
 clear_cellstr_cache ();
 octave_base_matrix<Cell>::assign (idx, rhs);
 }
 void
 octave_cell::assign (const octave_value_list& idx, const octave_value& rhs)
 {
 clear_cellstr_cache ();
 octave_base_matrix<Cell>::assign (idx, rhs);
 }
 void
 octave_cell::delete_elements (const octave_value_list& idx)
 {
 clear_cellstr_cache ();
 octave_base_matrix<Cell>::delete_elements (idx);
 }
 // We already have the cache.
 retval = new octave_cell (tmp);
 }
 else
 error ("sort: only cell arrays of character strings may be sorted");
 return retval;
 }
 octave_value
 octave_cell::sort (Array<octave_idx_type> &sidx, octave_idx_type dim,
 // We already have the cache.
 retval = new octave_cell (tmp);
 }
 else
 error ("sort: only cell arrays of character strings may be sorted");
 return retval;
 }
 sortmode
 octave_cell::is_sorted (sortmode mode) const
 {
 sortmode retval = UNSORTED;
 if (is_cellstr ())
 retval = tmp.is_sorted (mode);
 }
 else
 error ("issorted: not a cell array of strings");
 return retval;
 }
 Array<octave_idx_type>
 retval = tmp.sort_rows_idx (mode);
 }
 else
 error ("sortrows: only cell arrays of character strings may be sorted");
 return retval;
 }
 sortmode
 octave_cell::is_sorted_rows (sortmode mode) const
 {
 sortmode retval = UNSORTED;
 if (is_cellstr ())
 retval = tmp.is_sorted_rows (mode);
 }
 else
 error ("issorted: not a cell array of strings");
 return retval;
 }
 bool
 octave_cell::is_true (void) const
 }
 }
 #define CELL_ELT_TAG "<cell-element>"
 bool
 octave_cell::save_ascii (std::ostream& os)
 {
 dim_vector d = dims ();
 if (d.length () > 2)
 {
 os << "# ndims: " << d.length () << "\n";
 for (int i = 0; i < d.length (); i++)
 os << " " << d (i);
 os << "\n";
 Cell tmp = cell_value ();
 for (octave_idx_type i = 0; i < d.numel (); i++)
 {
 octave_value o_val = tmp.elem (i);
 // Recurse to print sub-value.
 bool b = save_ascii_data (os, o_val, CELL_ELT_TAG, false, 0);
 if (! b)
 return os;
 }
 }
 else
 {
 // Keep this case, rather than use generic code above for backward
 // compatiability. Makes load_ascii much more complex!!
 os << "# rows: " << rows () << "\n"
 << "# columns: " << columns () << "\n";
 Cell tmp = cell_value ();
 for (octave_idx_type j = 0; j < tmp.cols (); j++)
 {
 for (octave_idx_type i = 0; i < tmp.rows (); i++)
 {
 octave_value o_val = tmp.elem (i, j);
 // Recurse to print sub-value.
 bool b = save_ascii_data (os, o_val, CELL_ELT_TAG, false, 0);
 if (! b)
 return os;
 }
 os << "\n";
 }
 }
 return true;
 }
 bool
 octave_cell::load_ascii (std::istream& is)
 {
 bool success = true;
 clear_cellstr_cache ();
 {
 octave_value t2;
 bool dummy;
 // recurse to read cell elements
 std::string nm = read_ascii_data (is, std::string (),
 dummy, t2, i);
 if (nm == CELL_ELT_TAG)
 {
 if (is)
 success = false;
 goto cell_read_error;
 }
 }
 }
 cell_read_error:
 if (is)
 matrix = tmp;
 else
 }
 return success;
 }
 bool
 octave_cell::save_binary (std::ostream& os, bool& save_as_floats)
 {
 dim_vector d = dims ();
 if (d.length () < 1)
 return false;
 for (int i = 0; i < d.length (); i++)
 {
 di = d(i);
 os.write (reinterpret_cast<char *> (&di), 4);
 }
 Cell tmp = cell_value ();
 for (octave_idx_type i = 0; i < d.numel (); i++)
 {
 octave_value o_val = tmp.elem (i);
 // Recurse to print sub-value.
 bool b = save_binary_data (os, o_val, CELL_ELT_TAG, "", 0,
 save_as_floats);
 if (! b)
 return false;
 }
 return true;
 }
 bool
 octave_cell::load_binary (std::istream& is, bool swap,
 oct_mach_info::float_format fmt)
 {
 clear_cellstr_cache ();
 return false;
 if (swap)
 swap_bytes<4> (&di);
 dv(i) = di;
 }
 // Convert an array with a single dimension to be a row vector.
 // Octave should never write files like this, other software
 // might.
 if (mdims == 1)
 octave_value t2;
 bool dummy;
 std::string doc;
 // recurse to read cell elements
 std::string nm = read_binary_data (is, swap, fmt, std::string (),
 dummy, t2, doc);
 if (nm == CELL_ELT_TAG)
 {
 if (is)
 dim_vector dv = dims ();
 int empty = save_hdf5_empty (loc_id, name, dv);
 if (empty)
 return (empty > 0);
 hsize_t rank = dv.length ();
 hid_t space_hid = -1, data_hid = -1, size_hid = -1;
 #if HAVE_HDF5_18
 data_hid = H5Gcreate (loc_id, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 #else
 #endif
 if (data_hid < 0)
 return false;
 // Have to save cell array shape, since can't have a
 // dataset of groups....
 space_hid = H5Screate_simple (1, &rank, 0);
 if (space_hid < 0)
 {
 H5Gclose (data_hid);
 return false;
 }
 // Octave uses column-major, while HDF5 uses row-major ordering
 for (hsize_t i = 0; i < rank; i++)
 hdims[i] = dv(rank-i-1);
 #if HAVE_HDF5_18
 size_hid = H5Dcreate (data_hid, "dims", H5T_NATIVE_IDX, space_hid,
 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 #else
 size_hid = H5Dcreate (data_hid, "dims", H5T_NATIVE_IDX, space_hid,
 H5P_DEFAULT);
 #endif
 if (size_hid < 0)
 {
 H5Sclose (space_hid);
 H5Gclose (data_hid);
 return false;
 }
 #else
 hid_t data_hid = H5Dopen (group_id, "dims");
 #endif
 hid_t space_hid = H5Dget_space (data_hid);
 hsize_t rank = H5Sget_simple_extent_ndims (space_hid);
 if (rank != 1)
 {
 H5Dclose (data_hid);
 H5Gclose (group_id);
 return false;
 }
 // Octave uses column-major, while HDF5 uses row-major ordering.
 dv.resize (hdims[0]);
 OCTAVE_LOCAL_BUFFER (octave_idx_type, tmp, hdims[0]);
 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL,
 H5P_DEFAULT, tmp) < 0)
 {
 H5Dclose (data_hid);
 H5Gclose (group_id);
 return false;
 int current_item = 0;
 hsize_t num_obj = 0;
 #if HAVE_HDF5_18
 group_id = H5Gopen (loc_id, name, H5P_DEFAULT);
 #else
 group_id = H5Gopen (loc_id, name);
 #endif
 H5Gget_num_objs (group_id, &num_obj);
 H5Gclose (group_id);
 for (octave_idx_type i = 0; i < dv.numel (); i++)
 if (current_item >= static_cast<int> (num_obj))
 retval2 = -1;
 else
 retval2 = H5Giterate (loc_id, name, &current_item,
 hdf5_read_next_data, &dsub);
 if (retval2 <= 0)
 break;
 octave_value ov = dsub.tc;
 m.elem (i) = ov;
 if (retval2 >= 0)
 {
 matrix = m;
 retval = true;
 }
 return retval;
 }
 #endif
 FORWARD_MAPPER (xisupper);
 FORWARD_MAPPER (xisxdigit);
 FORWARD_MAPPER (xtoascii);
 FORWARD_MAPPER (xtolower);
 FORWARD_MAPPER (xtoupper);
 default:
 return octave_base_value::map (umap);
 }
 }

Mercurial > octave-nkf

comparison src/ov-cell.cc @ 11586:12df7854fa7c