1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
use std::fmt;
use super::{Array, Dimension};
fn format_array<A, D: Dimension, F>(view: &Array<A, D>, f: &mut fmt::Formatter,
mut format: F) -> fmt::Result where
F: FnMut(&mut fmt::Formatter, &A) -> fmt::Result,
{
let ndim = view.dim.slice().len();
/* private nowadays
if ndim > 0 && f.width.is_none() {
f.width = Some(4)
}
*/
// None will be an empty iter.
let mut last_index = match view.dim.first_index() {
None => view.dim.clone(),
Some(ix) => ix,
};
for _ in 0..ndim {
try!(write!(f, "["));
}
let mut first = true;
// Simply use the indexed iterator, and take the index wraparounds
// as cues for when to add []'s and how many to add.
for (index, elt) in view.indexed_iter() {
let take_n = if ndim == 0 { 1 } else { ndim - 1 };
let mut update_index = false;
for (i, (a, b)) in index.slice().iter().take(take_n)
.zip(last_index.slice().iter())
.enumerate()
{
if a != b {
// New row.
// # of ['s needed
let n = ndim - i - 1;
for _ in 0..n {
try!(write!(f, "]"));
}
try!(write!(f, ","));
if !f.alternate() {
try!(write!(f, "\n"));
}
for _ in 0..ndim - n {
try!(write!(f, " "));
}
for _ in 0..n {
try!(write!(f, "["));
}
first = true;
update_index = true;
break;
}
}
if !first {
try!(write!(f, ", "));
}
first = false;
try!(format(f, elt));
if update_index {
last_index = index;
}
}
for _ in 0..ndim {
try!(write!(f, "]"));
}
Ok(())
}
// NOTE: We can impl other fmt traits here
impl<'a, A: fmt::Display, D: Dimension> fmt::Display for Array<A, D>
{
/// Format the array using `Display` and apply the formatting parameters used
/// to each element.
///
/// The array is shown in multiline style, unless the alternate form
/// is used -- i.e. `{:#}`.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
format_array(self, f, |f, elt| elt.fmt(f))
}
}
impl<'a, A: fmt::Debug, D: Dimension> fmt::Debug for Array<A, D>
{
/// Format the array using `Debug` and apply the formatting parameters used
/// to each element.
///
/// The array is shown in multiline style, unless the alternate form
/// is used -- i.e. `{:#}`.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
format_array(self, f, |f, elt| elt.fmt(f))
}
}
impl<'a, A: fmt::LowerExp, D: Dimension> fmt::LowerExp for Array<A, D>
{
/// Format the array using `LowerExp` and apply the formatting parameters used
/// to each element.
///
/// The array is shown in multiline style, unless the alternate form
/// is used -- i.e. `{:#e}`.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
format_array(self, f, |f, elt| elt.fmt(f))
}
}
impl<'a, A: fmt::UpperExp, D: Dimension> fmt::UpperExp for Array<A, D>
{
/// Format the array using `UpperExp` and apply the formatting parameters used
/// to each element.
///
/// The array is shown in multiline style, unless the alternate form
/// is used -- i.e. `{:#E}`.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
format_array(self, f, |f, elt| elt.fmt(f))
}
}