svgparser 0.4.3

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// This file is autogenerated. Do not edit it!

use std::fmt;
use std::str::FromStr;

use value_id::ValueId;

use { Stream, Length, RgbColor };

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Property<'a> {
    AlignmentBaseline(AlignmentBaseline),
    BaselineShift(BaselineShift),
    ClipRule(ClipRule),
    Color(Color),
    ColorInterpolation(ColorInterpolation),
    ColorRendering(ColorRendering),
    Cursor(Cursor),
    Direction(Direction),
    Display(Display),
    DominantBaseline(DominantBaseline),
    Fill(Fill<'a>),
    FillRule(FillRule),
    FontSize(FontSize),
    FontStretch(FontStretch),
    FontStyle(FontStyle),
    FontVariant(FontVariant),
    FontWeight(FontWeight),
    LineCap(LineCap),
    Overflow(Overflow),
    PointerEvents(PointerEvents),
    ShapeRendering(ShapeRendering),
    SpreadMethod(SpreadMethod),
    Stroke(Stroke<'a>),
    StrokeLinecap(StrokeLinecap),
    StrokeLinejoin(StrokeLinejoin),
    StrokeWidth(StrokeWidth),
    TextAnchor(TextAnchor),
    TextDecoration(TextDecoration),
    TextRendering(TextRendering),
    UnicodeBidi(UnicodeBidi),
    Units(Units),
    Visibility(Visibility),
    WritingMode(WritingMode),
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum AlignmentBaseline {
    Auto,
    Baseline,
    BeforeEdge,
    TextBeforeEdge,
    Middle,
    Central,
    AfterEdge,
    TextAfterEdge,
    Ideographic,
    Alphabetic,
    Hanging,
    Mathematical,
    Inherit,
}

impl AlignmentBaseline {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<AlignmentBaseline> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Auto => return Some(AlignmentBaseline::Auto),
                ValueId::Baseline => return Some(AlignmentBaseline::Baseline),
                ValueId::BeforeEdge => return Some(AlignmentBaseline::BeforeEdge),
                ValueId::TextBeforeEdge => return Some(AlignmentBaseline::TextBeforeEdge),
                ValueId::Middle => return Some(AlignmentBaseline::Middle),
                ValueId::Central => return Some(AlignmentBaseline::Central),
                ValueId::AfterEdge => return Some(AlignmentBaseline::AfterEdge),
                ValueId::TextAfterEdge => return Some(AlignmentBaseline::TextAfterEdge),
                ValueId::Ideographic => return Some(AlignmentBaseline::Ideographic),
                ValueId::Alphabetic => return Some(AlignmentBaseline::Alphabetic),
                ValueId::Hanging => return Some(AlignmentBaseline::Hanging),
                ValueId::Mathematical => return Some(AlignmentBaseline::Mathematical),
                ValueId::Inherit => return Some(AlignmentBaseline::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum BaselineShift {
    Baseline,
    Sub,
    Super,
    Length(Length),
    Inherit,
}

impl BaselineShift {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<BaselineShift> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Baseline => return Some(BaselineShift::Baseline),
                ValueId::Sub => return Some(BaselineShift::Sub),
                ValueId::Super => return Some(BaselineShift::Super),
                ValueId::Inherit => return Some(BaselineShift::Inherit),
                _ => {}
            }
        }

        match Stream::from_str(text).parse_length().ok() {
            Some(l) => return Some(BaselineShift::Length(l)),
            None => {}
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum ClipRule {
    Nonzero,
    Evenodd,
    Inherit,
}

impl ClipRule {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<ClipRule> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Nonzero => return Some(ClipRule::Nonzero),
                ValueId::Evenodd => return Some(ClipRule::Evenodd),
                ValueId::Inherit => return Some(ClipRule::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Color {
    Color(RgbColor),
    Inherit,
}

impl Color {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Color> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Inherit => return Some(Color::Inherit),
                _ => {}
            }
        }

        match RgbColor::from_str(text).ok() {
            Some(l) => return Some(Color::Color(l)),
            None => {}
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum ColorInterpolation {
    Auto,
    SRGB,
    LinearRGB,
    Inherit,
}

impl ColorInterpolation {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<ColorInterpolation> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Auto => return Some(ColorInterpolation::Auto),
                ValueId::SRGB => return Some(ColorInterpolation::SRGB),
                ValueId::LinearRGB => return Some(ColorInterpolation::LinearRGB),
                ValueId::Inherit => return Some(ColorInterpolation::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum ColorRendering {
    Auto,
    OptimizeSpeed,
    OptimizeQuality,
    Inherit,
}

impl ColorRendering {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<ColorRendering> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Auto => return Some(ColorRendering::Auto),
                ValueId::OptimizeSpeed => return Some(ColorRendering::OptimizeSpeed),
                ValueId::OptimizeQuality => return Some(ColorRendering::OptimizeQuality),
                ValueId::Inherit => return Some(ColorRendering::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Cursor {
    Auto,
    Crosshair,
    Default,
    Pointer,
    Move,
    EResize,
    NeResize,
    NwResize,
    NResize,
    SeResize,
    SwResize,
    SResize,
    WResize,
    Text,
    Wait,
    Help,
    Inherit,
}

impl Cursor {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Cursor> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Auto => return Some(Cursor::Auto),
                ValueId::Crosshair => return Some(Cursor::Crosshair),
                ValueId::Default => return Some(Cursor::Default),
                ValueId::Pointer => return Some(Cursor::Pointer),
                ValueId::Move => return Some(Cursor::Move),
                ValueId::EResize => return Some(Cursor::EResize),
                ValueId::NeResize => return Some(Cursor::NeResize),
                ValueId::NwResize => return Some(Cursor::NwResize),
                ValueId::NResize => return Some(Cursor::NResize),
                ValueId::SeResize => return Some(Cursor::SeResize),
                ValueId::SwResize => return Some(Cursor::SwResize),
                ValueId::SResize => return Some(Cursor::SResize),
                ValueId::WResize => return Some(Cursor::WResize),
                ValueId::Text => return Some(Cursor::Text),
                ValueId::Wait => return Some(Cursor::Wait),
                ValueId::Help => return Some(Cursor::Help),
                ValueId::Inherit => return Some(Cursor::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Direction {
    Ltr,
    Rtl,
    Inherit,
}

impl Direction {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Direction> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Ltr => return Some(Direction::Ltr),
                ValueId::Rtl => return Some(Direction::Rtl),
                ValueId::Inherit => return Some(Direction::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Display {
    Inline,
    Block,
    ListItem,
    RunIn,
    Compact,
    Marker,
    Table,
    InlineTable,
    TableRowGroup,
    TableHeaderGroup,
    TableFooterGroup,
    TableRow,
    TableColumnGroup,
    TableColumn,
    TableCell,
    TableCaption,
    None,
    Inherit,
}

impl Display {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Display> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Inline => return Some(Display::Inline),
                ValueId::Block => return Some(Display::Block),
                ValueId::ListItem => return Some(Display::ListItem),
                ValueId::RunIn => return Some(Display::RunIn),
                ValueId::Compact => return Some(Display::Compact),
                ValueId::Marker => return Some(Display::Marker),
                ValueId::Table => return Some(Display::Table),
                ValueId::InlineTable => return Some(Display::InlineTable),
                ValueId::TableRowGroup => return Some(Display::TableRowGroup),
                ValueId::TableHeaderGroup => return Some(Display::TableHeaderGroup),
                ValueId::TableFooterGroup => return Some(Display::TableFooterGroup),
                ValueId::TableRow => return Some(Display::TableRow),
                ValueId::TableColumnGroup => return Some(Display::TableColumnGroup),
                ValueId::TableColumn => return Some(Display::TableColumn),
                ValueId::TableCell => return Some(Display::TableCell),
                ValueId::TableCaption => return Some(Display::TableCaption),
                ValueId::None => return Some(Display::None),
                ValueId::Inherit => return Some(Display::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum DominantBaseline {
    Auto,
    UseScript,
    NoChange,
    ResetSize,
    Ideographic,
    Alphabetic,
    Hanging,
    Mathematical,
    Central,
    Middle,
    TextAfterEdge,
    TextBeforeEdge,
    Inherit,
}

impl DominantBaseline {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<DominantBaseline> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Auto => return Some(DominantBaseline::Auto),
                ValueId::UseScript => return Some(DominantBaseline::UseScript),
                ValueId::NoChange => return Some(DominantBaseline::NoChange),
                ValueId::ResetSize => return Some(DominantBaseline::ResetSize),
                ValueId::Ideographic => return Some(DominantBaseline::Ideographic),
                ValueId::Alphabetic => return Some(DominantBaseline::Alphabetic),
                ValueId::Hanging => return Some(DominantBaseline::Hanging),
                ValueId::Mathematical => return Some(DominantBaseline::Mathematical),
                ValueId::Central => return Some(DominantBaseline::Central),
                ValueId::Middle => return Some(DominantBaseline::Middle),
                ValueId::TextAfterEdge => return Some(DominantBaseline::TextAfterEdge),
                ValueId::TextBeforeEdge => return Some(DominantBaseline::TextBeforeEdge),
                ValueId::Inherit => return Some(DominantBaseline::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Fill<'a> {
    None,
    CurrentColor,
    Color(RgbColor),
    FuncIRI(&'a str),
    Inherit,
}

impl<'a> Fill<'a> {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Fill> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::None => return Some(Fill::None),
                ValueId::CurrentColor => return Some(Fill::CurrentColor),
                ValueId::Inherit => return Some(Fill::Inherit),
                _ => {}
            }
        }

        match parse_func_iri(text) {
            Some(l) => return Some(Fill::FuncIRI(l)),
            None => {}
        }

        match RgbColor::from_str(text).ok() {
            Some(l) => return Some(Fill::Color(l)),
            None => {}
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum FillRule {
    Nonzero,
    Evenodd,
    Inherit,
}

impl FillRule {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<FillRule> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Nonzero => return Some(FillRule::Nonzero),
                ValueId::Evenodd => return Some(FillRule::Evenodd),
                ValueId::Inherit => return Some(FillRule::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum FontSize {
    XxSmall,
    XSmall,
    Small,
    Medium,
    Large,
    XLarge,
    XxLarge,
    Larger,
    Smaller,
    Length(Length),
    Inherit,
}

impl FontSize {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<FontSize> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::XxSmall => return Some(FontSize::XxSmall),
                ValueId::XSmall => return Some(FontSize::XSmall),
                ValueId::Small => return Some(FontSize::Small),
                ValueId::Medium => return Some(FontSize::Medium),
                ValueId::Large => return Some(FontSize::Large),
                ValueId::XLarge => return Some(FontSize::XLarge),
                ValueId::XxLarge => return Some(FontSize::XxLarge),
                ValueId::Larger => return Some(FontSize::Larger),
                ValueId::Smaller => return Some(FontSize::Smaller),
                ValueId::Inherit => return Some(FontSize::Inherit),
                _ => {}
            }
        }

        match Stream::from_str(text).parse_length().ok() {
            Some(l) => return Some(FontSize::Length(l)),
            None => {}
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum FontStretch {
    Normal,
    Wider,
    Narrower,
    UltraCondensed,
    ExtraCondensed,
    Condensed,
    SemiCondensed,
    SemiExpanded,
    Expanded,
    ExtraExpanded,
    UltraExpanded,
    Inherit,
}

impl FontStretch {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<FontStretch> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Normal => return Some(FontStretch::Normal),
                ValueId::Wider => return Some(FontStretch::Wider),
                ValueId::Narrower => return Some(FontStretch::Narrower),
                ValueId::UltraCondensed => return Some(FontStretch::UltraCondensed),
                ValueId::ExtraCondensed => return Some(FontStretch::ExtraCondensed),
                ValueId::Condensed => return Some(FontStretch::Condensed),
                ValueId::SemiCondensed => return Some(FontStretch::SemiCondensed),
                ValueId::SemiExpanded => return Some(FontStretch::SemiExpanded),
                ValueId::Expanded => return Some(FontStretch::Expanded),
                ValueId::ExtraExpanded => return Some(FontStretch::ExtraExpanded),
                ValueId::UltraExpanded => return Some(FontStretch::UltraExpanded),
                ValueId::Inherit => return Some(FontStretch::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum FontStyle {
    Normal,
    Italic,
    Oblique,
    Inherit,
}

impl FontStyle {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<FontStyle> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Normal => return Some(FontStyle::Normal),
                ValueId::Italic => return Some(FontStyle::Italic),
                ValueId::Oblique => return Some(FontStyle::Oblique),
                ValueId::Inherit => return Some(FontStyle::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum FontVariant {
    Normal,
    SmallCaps,
    Inherit,
}

impl FontVariant {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<FontVariant> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Normal => return Some(FontVariant::Normal),
                ValueId::SmallCaps => return Some(FontVariant::SmallCaps),
                ValueId::Inherit => return Some(FontVariant::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum FontWeight {
    Normal,
    Bold,
    Bolder,
    Lighter,
    N100,
    N200,
    N300,
    N400,
    N500,
    N600,
    N700,
    N800,
    N900,
    Inherit,
}

impl FontWeight {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<FontWeight> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Normal => return Some(FontWeight::Normal),
                ValueId::Bold => return Some(FontWeight::Bold),
                ValueId::Bolder => return Some(FontWeight::Bolder),
                ValueId::Lighter => return Some(FontWeight::Lighter),
                ValueId::N100 => return Some(FontWeight::N100),
                ValueId::N200 => return Some(FontWeight::N200),
                ValueId::N300 => return Some(FontWeight::N300),
                ValueId::N400 => return Some(FontWeight::N400),
                ValueId::N500 => return Some(FontWeight::N500),
                ValueId::N600 => return Some(FontWeight::N600),
                ValueId::N700 => return Some(FontWeight::N700),
                ValueId::N800 => return Some(FontWeight::N800),
                ValueId::N900 => return Some(FontWeight::N900),
                ValueId::Inherit => return Some(FontWeight::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum LineCap {
    Butt,
    Round,
    Square,
    Inherit,
}

impl LineCap {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<LineCap> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Butt => return Some(LineCap::Butt),
                ValueId::Round => return Some(LineCap::Round),
                ValueId::Square => return Some(LineCap::Square),
                ValueId::Inherit => return Some(LineCap::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Overflow {
    Visible,
    Hidden,
    Scroll,
    Auto,
    Inherit,
}

impl Overflow {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Overflow> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Visible => return Some(Overflow::Visible),
                ValueId::Hidden => return Some(Overflow::Hidden),
                ValueId::Scroll => return Some(Overflow::Scroll),
                ValueId::Auto => return Some(Overflow::Auto),
                ValueId::Inherit => return Some(Overflow::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum PointerEvents {
    VisiblePainted,
    VisibleFill,
    VisibleStroke,
    Visible,
    Painted,
    Fill,
    Stroke,
    All,
    None,
    Inherit,
}

impl PointerEvents {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<PointerEvents> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::VisiblePainted => return Some(PointerEvents::VisiblePainted),
                ValueId::VisibleFill => return Some(PointerEvents::VisibleFill),
                ValueId::VisibleStroke => return Some(PointerEvents::VisibleStroke),
                ValueId::Visible => return Some(PointerEvents::Visible),
                ValueId::Painted => return Some(PointerEvents::Painted),
                ValueId::Fill => return Some(PointerEvents::Fill),
                ValueId::Stroke => return Some(PointerEvents::Stroke),
                ValueId::All => return Some(PointerEvents::All),
                ValueId::None => return Some(PointerEvents::None),
                ValueId::Inherit => return Some(PointerEvents::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum ShapeRendering {
    Auto,
    OptimizeSpeed,
    CrispEdges,
    GeometricPrecision,
    Inherit,
}

impl ShapeRendering {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<ShapeRendering> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Auto => return Some(ShapeRendering::Auto),
                ValueId::OptimizeSpeed => return Some(ShapeRendering::OptimizeSpeed),
                ValueId::CrispEdges => return Some(ShapeRendering::CrispEdges),
                ValueId::GeometricPrecision => return Some(ShapeRendering::GeometricPrecision),
                ValueId::Inherit => return Some(ShapeRendering::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum SpreadMethod {
    Pad,
    Reflect,
    Repeat,
}

impl SpreadMethod {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<SpreadMethod> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Pad => return Some(SpreadMethod::Pad),
                ValueId::Reflect => return Some(SpreadMethod::Reflect),
                ValueId::Repeat => return Some(SpreadMethod::Repeat),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Stroke<'a> {
    None,
    CurrentColor,
    Color(RgbColor),
    FuncIRI(&'a str),
    Inherit,
}

impl<'a> Stroke<'a> {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Stroke> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::None => return Some(Stroke::None),
                ValueId::CurrentColor => return Some(Stroke::CurrentColor),
                ValueId::Inherit => return Some(Stroke::Inherit),
                _ => {}
            }
        }

        match parse_func_iri(text) {
            Some(l) => return Some(Stroke::FuncIRI(l)),
            None => {}
        }

        match RgbColor::from_str(text).ok() {
            Some(l) => return Some(Stroke::Color(l)),
            None => {}
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum StrokeLinecap {
    Butt,
    Round,
    Square,
    Inherit,
}

impl StrokeLinecap {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<StrokeLinecap> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Butt => return Some(StrokeLinecap::Butt),
                ValueId::Round => return Some(StrokeLinecap::Round),
                ValueId::Square => return Some(StrokeLinecap::Square),
                ValueId::Inherit => return Some(StrokeLinecap::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum StrokeLinejoin {
    Miter,
    Round,
    Bevel,
    Inherit,
}

impl StrokeLinejoin {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<StrokeLinejoin> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Miter => return Some(StrokeLinejoin::Miter),
                ValueId::Round => return Some(StrokeLinejoin::Round),
                ValueId::Bevel => return Some(StrokeLinejoin::Bevel),
                ValueId::Inherit => return Some(StrokeLinejoin::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum StrokeWidth {
    Length(Length),
    Inherit,
}

impl StrokeWidth {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<StrokeWidth> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Inherit => return Some(StrokeWidth::Inherit),
                _ => {}
            }
        }

        match Stream::from_str(text).parse_length().ok() {
            Some(l) => return Some(StrokeWidth::Length(l)),
            None => {}
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum TextAnchor {
    Start,
    Middle,
    End,
    Inherit,
}

impl TextAnchor {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<TextAnchor> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Start => return Some(TextAnchor::Start),
                ValueId::Middle => return Some(TextAnchor::Middle),
                ValueId::End => return Some(TextAnchor::End),
                ValueId::Inherit => return Some(TextAnchor::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum TextDecoration {
    None,
    Underline,
    Overline,
    LineThrough,
    Blink,
    Inherit,
}

impl TextDecoration {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<TextDecoration> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::None => return Some(TextDecoration::None),
                ValueId::Underline => return Some(TextDecoration::Underline),
                ValueId::Overline => return Some(TextDecoration::Overline),
                ValueId::LineThrough => return Some(TextDecoration::LineThrough),
                ValueId::Blink => return Some(TextDecoration::Blink),
                ValueId::Inherit => return Some(TextDecoration::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum TextRendering {
    Auto,
    OptimizeSpeed,
    OptimizeLegibility,
    GeometricPrecision,
    Inherit,
}

impl TextRendering {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<TextRendering> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Auto => return Some(TextRendering::Auto),
                ValueId::OptimizeSpeed => return Some(TextRendering::OptimizeSpeed),
                ValueId::OptimizeLegibility => return Some(TextRendering::OptimizeLegibility),
                ValueId::GeometricPrecision => return Some(TextRendering::GeometricPrecision),
                ValueId::Inherit => return Some(TextRendering::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum UnicodeBidi {
    Normal,
    Embed,
    BidiOverride,
    Inherit,
}

impl UnicodeBidi {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<UnicodeBidi> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Normal => return Some(UnicodeBidi::Normal),
                ValueId::Embed => return Some(UnicodeBidi::Embed),
                ValueId::BidiOverride => return Some(UnicodeBidi::BidiOverride),
                ValueId::Inherit => return Some(UnicodeBidi::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Units {
    UserSpaceOnUse,
    ObjectBoundingBox,
}

impl Units {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Units> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::UserSpaceOnUse => return Some(Units::UserSpaceOnUse),
                ValueId::ObjectBoundingBox => return Some(Units::ObjectBoundingBox),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum Visibility {
    Visible,
    Hidden,
    Collapse,
    Inherit,
}

impl Visibility {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<Visibility> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::Visible => return Some(Visibility::Visible),
                ValueId::Hidden => return Some(Visibility::Hidden),
                ValueId::Collapse => return Some(Visibility::Collapse),
                ValueId::Inherit => return Some(Visibility::Inherit),
                _ => {}
            }
        }

        None
    }
}

#[derive(Debug,Copy,Clone,PartialEq)]
#[allow(missing_docs)]
pub enum WritingMode {
    LrTb,
    RlTb,
    TbRl,
    Lr,
    Rl,
    Tb,
    Inherit,
}

impl WritingMode {
    /// Converts string to a property.
    pub fn from_str(text: &str) -> Option<WritingMode> {
        if let Some(n) = ValueId::from_name(text) {
            match n {
                ValueId::LrTb => return Some(WritingMode::LrTb),
                ValueId::RlTb => return Some(WritingMode::RlTb),
                ValueId::TbRl => return Some(WritingMode::TbRl),
                ValueId::Lr => return Some(WritingMode::Lr),
                ValueId::Rl => return Some(WritingMode::Rl),
                ValueId::Tb => return Some(WritingMode::Tb),
                ValueId::Inherit => return Some(WritingMode::Inherit),
                _ => {}
            }
        }

        None
    }
}


macro_rules! try_opt {
    ($expr: expr) => {
        match $expr {
            Some(value) => value,
            None => return None
        }
    }
}

fn parse_func_iri(text: &str) -> Option<&str> {
    let mut stream = Stream::from_str(text);
    if !stream.at_end() && stream.is_char_eq_raw(b'u') {
        try_opt!(stream.advance(5).ok());
        let link = stream.slice_next_raw(try_opt!(stream.len_to(b')').ok()));
        Some(link)
    } else {
        None
    }
}