/// A piece is a portion of the format string which represents the next part
/// to emit. These are emitted as a stream by the `Parser` class.
-#[deriving(PartialEq)]
+#[deriving(Copy, PartialEq)]
pub enum Piece<'a> {
/// A literal string which should directly be emitted
String(&'a str),
NextArgument(Argument<'a>),
}
-impl<'a> Copy for Piece<'a> {}
-
/// Representation of an argument specification.
-#[deriving(PartialEq)]
+#[deriving(Copy, PartialEq)]
pub struct Argument<'a> {
/// Where to find this argument
pub position: Position<'a>,
pub format: FormatSpec<'a>,
}
-impl<'a> Copy for Argument<'a> {}
-
/// Specification for the formatting of an argument in the format string.
-#[deriving(PartialEq)]
+#[deriving(Copy, PartialEq)]
pub struct FormatSpec<'a> {
/// Optionally specified character to fill alignment with
pub fill: Option<char>,
pub ty: &'a str
}
-impl<'a> Copy for FormatSpec<'a> {}
-
/// Enum describing where an argument for a format can be located.
-#[deriving(PartialEq)]
+#[deriving(Copy, PartialEq)]
pub enum Position<'a> {
/// The argument will be in the next position. This is the default.
ArgumentNext,
ArgumentNamed(&'a str),
}
-impl<'a> Copy for Position<'a> {}
-
/// Enum of alignments which are supported.
-#[deriving(PartialEq)]
+#[deriving(Copy, PartialEq)]
pub enum Alignment {
/// The value will be aligned to the left.
AlignLeft,
AlignUnknown,
}
-impl Copy for Alignment {}
-
/// Various flags which can be applied to format strings. The meaning of these
/// flags is defined by the formatters themselves.
-#[deriving(PartialEq)]
+#[deriving(Copy, PartialEq)]
pub enum Flag {
/// A `+` will be used to denote positive numbers.
FlagSignPlus,
FlagSignAwareZeroPad,
}
-impl Copy for Flag {}
-
/// A count is used for the precision and width parameters of an integer, and
/// can reference either an argument or a literal integer.
-#[deriving(PartialEq)]
+#[deriving(Copy, PartialEq)]
pub enum Count<'a> {
/// The count is specified explicitly.
CountIs(uint),
CountImplied,
}
-impl<'a> Copy for Count<'a> {}
-
/// The parser structure for interpreting the input format string. This is
/// modelled as an iterator over `Piece` structures to form a stream of tokens
/// being output.