SkSVGAttributeParser Class Reference

#include <SkSVGAttributeParser.h>

Inheritance diagram for SkSVGAttributeParser:

Public Types
template<typename T >
using	ParseResult = SkTLazy< T >

Public Member Functions
	SkSVGAttributeParser (const char[])
bool	parseInteger (SkSVGIntegerType *)
bool	parseViewBox (SkSVGViewBoxType *)
bool	parsePreserveAspectRatio (SkSVGPreserveAspectRatio *)
bool	parse (SkSVGIntegerType *v)
template<>
bool	parse (SkSVGColorType *color)
template<>
bool	parse (SkSVGColor *color)
template<>
bool	parse (SkSVGIRI *iri)
template<>
bool	parse (SkSVGStringType *result)
template<>
bool	parse (SkSVGNumberType *number)
template<>
bool	parse (SkSVGLength *length)
template<>
bool	parse (SkSVGTransformType *t)
template<>
bool	parse (SkSVGPaint *paint)
template<>
bool	parse (SkSVGFuncIRI *firi)
template<>
bool	parse (SkSVGLineCap *cap)
template<>
bool	parse (SkSVGLineJoin *join)
template<>
bool	parse (SkSVGObjectBoundingBoxUnits *objectBoundingBoxUnits)
template<>
bool	parse (SkSVGPointsType *points)
template<>
bool	parse (SkSVGFillRule *fillRule)
template<>
bool	parse (SkSVGVisibility *visibility)
template<>
bool	parse (SkSVGDashArray *dashArray)
template<>
bool	parse (SkSVGFontFamily *family)
template<>
bool	parse (SkSVGFontSize *size)
template<>
bool	parse (SkSVGFontStyle *style)
template<>
bool	parse (SkSVGFontWeight *weight)
template<>
bool	parse (SkSVGTextAnchor *anchor)
template<>
bool	parse (SkSVGPreserveAspectRatio *par)
template<>
bool	parse (std::vector< SkSVGLength > *lengths)
template<>
bool	parse (std::vector< SkSVGNumberType > *numbers)
template<>
bool	parse (SkSVGColorspace *colorspace)
template<>
bool	parse (SkSVGDisplay *display)
template<>
bool	parse (SkSVGFeInputType *type)
template<>
bool	parse (SkSVGFeColorMatrixType *type)
template<>
bool	parse (SkSVGFeCompositeOperator *op)
template<>
bool	parse (SkSVGSpreadMethod *spread)
template<>
bool	parse (SkSVGXmlSpace *xs)
Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default
	SkNoncopyable (SkNoncopyable &&)=default
SkNoncopyable &	operator= (SkNoncopyable &&)=default

Static Public Member Functions
template<typename T >
static ParseResult< T >	parse (const char *value)
template<typename T >
static ParseResult< T >	parse (const char *expectedName, const char *name, const char *value)
template<typename PropertyT >
static ParseResult< PropertyT >	parseProperty (const char *expectedName, const char *name, const char *value)
template<>
bool	parse (SkSVGFeTurbulenceBaseFrequency *freq)
template<>
bool	parse (SkSVGFeTurbulenceType *type)
template<>
bool	parse (SkPath *path)

Detailed Description

Definition at line 17 of file SkSVGAttributeParser.h.

Member Typedef Documentation

ParseResult

template<typename T >

using SkSVGAttributeParser::ParseResult = SkTLazy<T>

Definition at line 29 of file SkSVGAttributeParser.h.

Constructor & Destructor Documentation

SkSVGAttributeParser()

SkSVGAttributeParser::SkSVGAttributeParser

(

const char

attributeString[]

)

Definition at line 43 of file SkSVGAttributeParser.cpp.

    : fCurPos(attributeString), fEndPos(fCurPos + strlen(attributeString)) {}

Member Function Documentation

parse() [1/37]

template<typename T >

static ParseResult< T > SkSVGAttributeParser::parse ( const char *  expectedName, const char *  name, const char *  value  )

inlinestatic

Definition at line 41 of file SkSVGAttributeParser.h.

                                                   {
        if (!strcmp(name, expectedName)) {
            return parse<T>(value);
        }
 
        return ParseResult<T>();
    }

parse() [2/37]

template<typename T >

static ParseResult< T > SkSVGAttributeParser::parse ( const char *  value )

inlinestatic

Definition at line 31 of file SkSVGAttributeParser.h.

                                                                         {
        ParseResult<T> result;
        T parsedValue;
        if (SkSVGAttributeParser(value).parse(&parsedValue)) {
            result.set(std::move(parsedValue));
        }
        return result;
    }

parse() [3/37]

template<>

bool SkSVGAttributeParser::parse ( SkPath *  path )

static

Definition at line 23 of file SkSVGPath.cpp.

                                                     {
    return SkParsePath::FromSVGString(fCurPos, path);
}

parse() [4/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGColor *

color

)

Definition at line 446 of file SkSVGAttributeParser.cpp.

                                                  {
    this->parseWSToken();
    if (!this->parseSVGColor(color, SkSVGColor::Vars())) {
        return false;
    }
    this->parseWSToken();
    return this->parseEOSToken();
}

parse() [5/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGColorspace *

colorspace

)

Definition at line 1144 of file SkSVGAttributeParser.cpp.

                                                            {
    static constexpr std::tuple<const char*, SkSVGColorspace> gColorspaceMap[] = {
        { "auto"     , SkSVGColorspace::kAuto      },
        { "sRGB"     , SkSVGColorspace::kSRGB      },
        { "linearRGB", SkSVGColorspace::kLinearRGB },
    };
 
    return this->parseEnumMap(gColorspaceMap, colorspace) && this->parseEOSToken();
}

parse() [6/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGColorType *

color

)

Definition at line 398 of file SkSVGAttributeParser.cpp.

                                                      {
    this->parseWSToken();
    if (!this->parseSVGColorType(color)) {
        return false;
    }
    this->parseWSToken();
    return this->parseEOSToken();
}

parse() [7/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGDashArray *

dashArray

)

Definition at line 931 of file SkSVGAttributeParser.cpp.

                                                          {
    bool parsedValue = false;
    if (this->parseExpectedStringToken("none")) {
        *dashArray = SkSVGDashArray(SkSVGDashArray::Type::kNone);
        parsedValue = true;
    } else if (this->parseExpectedStringToken("inherit")) {
        *dashArray = SkSVGDashArray(SkSVGDashArray::Type::kInherit);
        parsedValue = true;
    } else {
        std::vector<SkSVGLength> dashes;
        for (;;) {
            SkSVGLength dash;
            // parseLength() also consumes trailing separators.
            if (!this->parse(&dash)) {
                break;
            }
 
            dashes.push_back(dash);
            parsedValue = true;
        }
 
        if (parsedValue) {
            *dashArray = SkSVGDashArray(std::move(dashes));
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [8/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGDisplay *

display

)

Definition at line 1156 of file SkSVGAttributeParser.cpp.

                                                      {
    static const struct {
        SkSVGDisplay fType;
        const char*  fName;
    } gDisplayInfo[] = {
        { SkSVGDisplay::kInline, "inline" },
        { SkSVGDisplay::kNone  , "none"   },
    };
 
    bool parsedValue = false;
    for (const auto& parseInfo : gDisplayInfo) {
        if (this->parseExpectedStringToken(parseInfo.fName)) {
            *display = SkSVGDisplay(parseInfo.fType);
            parsedValue = true;
            break;
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [9/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFeColorMatrixType *

type

)

Definition at line 100 of file SkSVGFeColorMatrix.cpp.

                                                                         {
    static constexpr std::tuple<const char*, SkSVGFeColorMatrixType> gTypeMap[] = {
            {"matrix", SkSVGFeColorMatrixType::kMatrix},
            {"saturate", SkSVGFeColorMatrixType::kSaturate},
            {"hueRotate", SkSVGFeColorMatrixType::kHueRotate},
            {"luminanceToAlpha", SkSVGFeColorMatrixType::kLuminanceToAlpha},
    };
 
    return this->parseEnumMap(gTypeMap, type) && this->parseEOSToken();
}

parse() [10/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFeCompositeOperator *

op

)

Definition at line 63 of file SkSVGFeComposite.cpp.

                                                                         {
    static constexpr std::tuple<const char*, SkSVGFeCompositeOperator> gOpMap[] = {
            {"over", SkSVGFeCompositeOperator::kOver},
            {"in", SkSVGFeCompositeOperator::kIn},
            {"out", SkSVGFeCompositeOperator::kOut},
            {"atop", SkSVGFeCompositeOperator::kAtop},
            {"xor", SkSVGFeCompositeOperator::kXor},
            {"arithmetic", SkSVGFeCompositeOperator::kArithmetic},
    };
 
    return this->parseEnumMap(gOpMap, op) && this->parseEOSToken();
}

parse() [11/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFeInputType *

type

)

Definition at line 103 of file SkSVGFe.cpp.

                                                                   {
    static constexpr std::tuple<const char*, SkSVGFeInputType::Type> gTypeMap[] = {
            {"SourceGraphic", SkSVGFeInputType::Type::kSourceGraphic},
            {"SourceAlpha", SkSVGFeInputType::Type::kSourceAlpha},
            {"BackgroundImage", SkSVGFeInputType::Type::kBackgroundImage},
            {"BackgroundAlpha", SkSVGFeInputType::Type::kBackgroundAlpha},
            {"FillPaint", SkSVGFeInputType::Type::kFillPaint},
            {"StrokePaint", SkSVGFeInputType::Type::kStrokePaint},
    };
 
    SkSVGStringType resultId;
    SkSVGFeInputType::Type t;
    bool parsedValue = false;
    if (this->parseEnumMap(gTypeMap, &t)) {
        *type = SkSVGFeInputType(t);
        parsedValue = true;
    } else if (parse(&resultId)) {
        *type = SkSVGFeInputType(resultId);
        parsedValue = true;
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [12/37]

template<>

bool SkSVGAttributeParser::parse ( SkSVGFeTurbulenceBaseFrequency *  freq )

static

Definition at line 28 of file SkSVGFeTurbulence.cpp.

                                              {
    SkSVGNumberType freqX;
    if (!this->parse(&freqX)) {
        return false;
    }
 
    SkSVGNumberType freqY;
    this->parseCommaWspToken();
    if (this->parse(&freqY)) {
        *freq = SkSVGFeTurbulenceBaseFrequency(freqX, freqY);
    } else {
        *freq = SkSVGFeTurbulenceBaseFrequency(freqX, freqX);
    }
 
    return this->parseEOSToken();
}

parse() [13/37]

template<>

bool SkSVGAttributeParser::parse ( SkSVGFeTurbulenceType *  type )

static

Definition at line 47 of file SkSVGFeTurbulence.cpp.

                                                                                   {
    bool parsedValue = false;
 
    if (this->parseExpectedStringToken("fractalNoise")) {
        *type = SkSVGFeTurbulenceType(SkSVGFeTurbulenceType::kFractalNoise);
        parsedValue = true;
    } else if (this->parseExpectedStringToken("turbulence")) {
        *type = SkSVGFeTurbulenceType(SkSVGFeTurbulenceType::kTurbulence);
        parsedValue = true;
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [14/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFillRule *

fillRule

)

Definition at line 882 of file SkSVGAttributeParser.cpp.

                                                        {
    static const struct {
        SkSVGFillRule::Type fType;
        const char*         fName;
    } gFillRuleInfo[] = {
        { SkSVGFillRule::Type::kNonZero, "nonzero" },
        { SkSVGFillRule::Type::kEvenOdd, "evenodd" },
        { SkSVGFillRule::Type::kInherit, "inherit" },
    };
 
    bool parsedValue = false;
    for (size_t i = 0; i < std::size(gFillRuleInfo); ++i) {
        if (this->parseExpectedStringToken(gFillRuleInfo[i].fName)) {
            *fillRule = SkSVGFillRule(gFillRuleInfo[i].fType);
            parsedValue = true;
            break;
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [15/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFontFamily *

family

)

Definition at line 962 of file SkSVGAttributeParser.cpp.

                                                        {
    bool parsedValue = false;
    if (this->parseExpectedStringToken("inherit")) {
        *family = SkSVGFontFamily();
        parsedValue = true;
    } else {
        // The spec allows specifying a comma-separated list for explicit fallback order.
        // For now, we only use the first entry and rely on the font manager to handle fallback.
        const auto* comma = strchr(fCurPos, ',');
        auto family_name = comma ? SkString(fCurPos, comma - fCurPos)
                                 : SkString(fCurPos);
        *family = SkSVGFontFamily(family_name.c_str());
        fCurPos += strlen(fCurPos);
        parsedValue = true;
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [16/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFontSize *

size

)

Definition at line 983 of file SkSVGAttributeParser.cpp.

                                                    {
    bool parsedValue = false;
    if (this->parseExpectedStringToken("inherit")) {
        *size = SkSVGFontSize();
        parsedValue = true;
    } else {
        SkSVGLength length;
        if (this->parse(&length)) {
            *size = SkSVGFontSize(length);
            parsedValue = true;
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [17/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFontStyle *

style

)

Definition at line 1001 of file SkSVGAttributeParser.cpp.

                                                      {
    static constexpr std::tuple<const char*, SkSVGFontStyle::Type> gStyleMap[] = {
        { "normal" , SkSVGFontStyle::Type::kNormal  },
        { "italic" , SkSVGFontStyle::Type::kItalic  },
        { "oblique", SkSVGFontStyle::Type::kOblique },
        { "inherit", SkSVGFontStyle::Type::kInherit },
    };
 
    bool parsedValue = false;
    SkSVGFontStyle::Type type;
 
    if (this->parseEnumMap(gStyleMap, &type)) {
        *style = SkSVGFontStyle(type);
        parsedValue = true;
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [18/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFontWeight *

weight

)

Definition at line 1022 of file SkSVGAttributeParser.cpp.

                                                        {
    static constexpr std::tuple<const char*, SkSVGFontWeight::Type> gWeightMap[] = {
        { "normal" , SkSVGFontWeight::Type::kNormal  },
        { "bold"   , SkSVGFontWeight::Type::kBold    },
        { "bolder" , SkSVGFontWeight::Type::kBolder  },
        { "lighter", SkSVGFontWeight::Type::kLighter },
        { "100"    , SkSVGFontWeight::Type::k100     },
        { "200"    , SkSVGFontWeight::Type::k200     },
        { "300"    , SkSVGFontWeight::Type::k300     },
        { "400"    , SkSVGFontWeight::Type::k400     },
        { "500"    , SkSVGFontWeight::Type::k500     },
        { "600"    , SkSVGFontWeight::Type::k600     },
        { "700"    , SkSVGFontWeight::Type::k700     },
        { "800"    , SkSVGFontWeight::Type::k800     },
        { "900"    , SkSVGFontWeight::Type::k900     },
        { "inherit", SkSVGFontWeight::Type::kInherit },
    };
 
    bool parsedValue = false;
    SkSVGFontWeight::Type type;
 
    if (this->parseEnumMap(gWeightMap, &type)) {
        *weight = SkSVGFontWeight(type);
        parsedValue = true;
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [19/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGFuncIRI *

firi

)

Definition at line 752 of file SkSVGAttributeParser.cpp.

                                                   {
    SkSVGStringType iri;
    bool parsedValue = false;
 
    if (this->parseExpectedStringToken("none")) {
        *firi = SkSVGFuncIRI();
        parsedValue = true;
    } else if (this->parseFuncIRI(firi)) {
        parsedValue = true;
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [20/37]

bool SkSVGAttributeParser::parse ( SkSVGIntegerType *  v )

inline

Definition at line 27 of file SkSVGAttributeParser.h.

{ return parseInteger(v); }

parse() [21/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGIRI *

iri

)

Definition at line 457 of file SkSVGAttributeParser.cpp.

                                              {
    // consume preceding whitespace
    this->parseWSToken();
 
    SkSVGIRI::Type iriType;
    if (this->parseExpectedStringToken("#")) {
        iriType = SkSVGIRI::Type::kLocal;
    } else if (this->matchStringToken("data:")) {
        iriType = SkSVGIRI::Type::kDataURI;
    } else {
        iriType = SkSVGIRI::Type::kNonlocal;
    }
 
    const auto* start = fCurPos;
    if (!this->advanceWhile([](char c) -> bool { return c != ')'; })) {
        return false;
    }
    *iri = SkSVGIRI(iriType, SkString(start, fCurPos - start));
    return true;
}

parse() [22/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGLength *

length

)

Definition at line 538 of file SkSVGAttributeParser.cpp.

                                                    {
    SkScalar s;
    SkSVGLength::Unit u = SkSVGLength::Unit::kNumber;
 
    if (this->parseScalarToken(&s) &&
        (this->parseLengthUnitToken(&u) || this->parseSepToken() || this->parseEOSToken())) {
        *length = SkSVGLength(s, u);
        // consume trailing separators
        this->parseSepToken();
        return true;
    }
 
    return false;
}

parse() [23/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGLineCap *

cap

)

Definition at line 768 of file SkSVGAttributeParser.cpp.

                                                  {
    static const struct {
        SkSVGLineCap fType;
        const char*        fName;
    } gCapInfo[] = {
        { SkSVGLineCap::kButt   , "butt"    },
        { SkSVGLineCap::kRound  , "round"   },
        { SkSVGLineCap::kSquare , "square"  },
    };
 
    bool parsedValue = false;
    for (size_t i = 0; i < std::size(gCapInfo); ++i) {
        if (this->parseExpectedStringToken(gCapInfo[i].fName)) {
            *cap = SkSVGLineCap(gCapInfo[i].fType);
            parsedValue = true;
            break;
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [24/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGLineJoin *

join

)

Definition at line 792 of file SkSVGAttributeParser.cpp.

                                                    {
    static const struct {
        SkSVGLineJoin::Type fType;
        const char*         fName;
    } gJoinInfo[] = {
        { SkSVGLineJoin::Type::kMiter  , "miter"   },
        { SkSVGLineJoin::Type::kRound  , "round"   },
        { SkSVGLineJoin::Type::kBevel  , "bevel"   },
        { SkSVGLineJoin::Type::kInherit, "inherit" },
    };
 
    bool parsedValue = false;
    for (size_t i = 0; i < std::size(gJoinInfo); ++i) {
        if (this->parseExpectedStringToken(gJoinInfo[i].fName)) {
            *join = SkSVGLineJoin(gJoinInfo[i].fType);
            parsedValue = true;
            break;
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [25/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGNumberType *

number

)

Definition at line 502 of file SkSVGAttributeParser.cpp.

                                                        {
    // consume WS
    this->parseWSToken();
 
    SkScalar s;
    if (this->parseScalarToken(&s)) {
        *number = SkSVGNumberType(s);
        // consume trailing separators
        this->parseSepToken();
        return true;
    }
 
    return false;
}

parse() [26/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGObjectBoundingBoxUnits *

objectBoundingBoxUnits

)

Definition at line 817 of file SkSVGAttributeParser.cpp.

                                                                                    {
    bool parsedValue = false;
    if (this->parseExpectedStringToken("userSpaceOnUse")) {
        *objectBoundingBoxUnits =
                SkSVGObjectBoundingBoxUnits(SkSVGObjectBoundingBoxUnits::Type::kUserSpaceOnUse);
        parsedValue = true;
    } else if (this->parseExpectedStringToken("objectBoundingBox")) {
        *objectBoundingBoxUnits =
                SkSVGObjectBoundingBoxUnits(SkSVGObjectBoundingBoxUnits::Type::kObjectBoundingBox);
        parsedValue = true;
    }
    return parsedValue && this->parseEOSToken();
}

parse() [27/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGPaint *

paint

)

Definition at line 725 of file SkSVGAttributeParser.cpp.

                                                  {
    SkSVGColor c;
    SkSVGFuncIRI iri;
    bool parsedValue = false;
 
    this->parseWSToken();
    if (this->parseSVGColor(&c, SkSVGColor::Vars())) {
        *paint = SkSVGPaint(std::move(c));
        parsedValue = true;
    } else if (this->parseExpectedStringToken("none")) {
        *paint = SkSVGPaint(SkSVGPaint::Type::kNone);
        parsedValue = true;
    } else if (this->parseFuncIRI(&iri)) {
        // optional fallback color
        this->parseWSToken();
        this->parseSVGColor(&c, SkSVGColor::Vars());
        *paint = SkSVGPaint(iri.iri(), std::move(c));
        parsedValue = true;
    }
    this->parseWSToken();
    return parsedValue && this->parseEOSToken();
}

parse() [28/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGPointsType *

points

)

Definition at line 833 of file SkSVGAttributeParser.cpp.

                                                        {
    SkSVGPointsType pts;
 
    // Skip initial wsp.
    // list-of-points:
    //     wsp* coordinate-pairs? wsp*
    this->advanceWhile(is_ws);
 
    bool parsedValue = false;
    for (;;) {
        // Adjacent coordinate-pairs separated by comma-wsp.
        // coordinate-pairs:
        //     coordinate-pair
        //     | coordinate-pair comma-wsp coordinate-pairs
        if (parsedValue && !this->parseCommaWspToken()) {
            break;
        }
 
        SkScalar x, y;
        if (!this->parseScalarToken(&x)) {
            break;
        }
 
        // Coordinate values separated by comma-wsp or '-'.
        // coordinate-pair:
        //     coordinate comma-wsp coordinate
        //     | coordinate negative-coordinate
        if (!this->parseCommaWspToken() && !this->parseEOSToken() && *fCurPos != '-') {
            break;
        }
 
        if (!this->parseScalarToken(&y)) {
            break;
        }
 
        pts.push_back(SkPoint::Make(x, y));
        parsedValue = true;
    }
 
    if (parsedValue && this->parseEOSToken()) {
        *points = std::move(pts);
        return true;
    }
 
    return false;
}

parse() [29/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGPreserveAspectRatio *

par

)

Definition at line 1110 of file SkSVGAttributeParser.cpp.

                                                              {
    return this->parsePreserveAspectRatio(par);
}

parse() [30/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGSpreadMethod *

spread

)

Definition at line 102 of file SkSVGGradient.cpp.

                                                          {
    static const struct {
        SkSVGSpreadMethod::Type fType;
        const char*             fName;
    } gSpreadInfo[] = {
        { SkSVGSpreadMethod::Type::kPad    , "pad"     },
        { SkSVGSpreadMethod::Type::kReflect, "reflect" },
        { SkSVGSpreadMethod::Type::kRepeat , "repeat"  },
    };
 
    bool parsedValue = false;
    for (size_t i = 0; i < std::size(gSpreadInfo); ++i) {
        if (this->parseExpectedStringToken(gSpreadInfo[i].fName)) {
            *spread = SkSVGSpreadMethod(gSpreadInfo[i].fType);
            parsedValue = true;
            break;
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [31/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGStringType *

result

)

Definition at line 491 of file SkSVGAttributeParser.cpp.

                                                        {
    if (this->parseEOSToken()) {
        return false;
    }
    *result = SkSVGStringType(fCurPos);
    fCurPos += result->size();
    return this->parseEOSToken();
}

parse() [32/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGTextAnchor *

anchor

)

Definition at line 1053 of file SkSVGAttributeParser.cpp.

                                                        {
    static constexpr std::tuple<const char*, SkSVGTextAnchor::Type> gAnchorMap[] = {
        { "start"  , SkSVGTextAnchor::Type::kStart  },
        { "middle" , SkSVGTextAnchor::Type::kMiddle },
        { "end"    , SkSVGTextAnchor::Type::kEnd    },
        { "inherit", SkSVGTextAnchor::Type::kInherit},
    };
 
    bool parsedValue = false;
    SkSVGTextAnchor::Type type;
 
    if (this->parseEnumMap(gAnchorMap, &type)) {
        *anchor = SkSVGTextAnchor(type);
        parsedValue = true;
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [33/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGTransformType *

t

)

Definition at line 692 of file SkSVGAttributeParser.cpp.

                                                      {
    SkMatrix matrix = SkMatrix::I();
 
    bool parsed = false;
    while (true) {
        SkMatrix m;
 
        if (!( this->parseMatrixToken(&m)
            || this->parseTranslateToken(&m)
            || this->parseScaleToken(&m)
            || this->parseRotateToken(&m)
            || this->parseSkewXToken(&m)
            || this->parseSkewYToken(&m))) {
            break;
        }
 
        matrix.preConcat(m);
        parsed = true;
 
        this->parseCommaWspToken();
    }
 
    this->parseWSToken();
    if (!parsed || !this->parseEOSToken()) {
        return false;
    }
 
    *t = SkSVGTransformType(matrix);
    return true;
}

parse() [34/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGVisibility *

visibility

)

Definition at line 906 of file SkSVGAttributeParser.cpp.

                                                            {
    static const struct {
        SkSVGVisibility::Type fType;
        const char*           fName;
    } gVisibilityInfo[] = {
        { SkSVGVisibility::Type::kVisible , "visible"  },
        { SkSVGVisibility::Type::kHidden  , "hidden"   },
        { SkSVGVisibility::Type::kCollapse, "collapse" },
        { SkSVGVisibility::Type::kInherit , "inherit"  },
    };
 
    bool parsedValue = false;
    for (const auto& parseInfo : gVisibilityInfo) {
        if (this->parseExpectedStringToken(parseInfo.fName)) {
            *visibility = SkSVGVisibility(parseInfo.fType);
            parsedValue = true;
            break;
        }
    }
 
    return parsedValue && this->parseEOSToken();
}

parse() [35/37]

template<>

bool SkSVGAttributeParser::parse

(

SkSVGXmlSpace *

xs

)

Definition at line 575 of file SkSVGText.cpp.

                                                  {
    static constexpr std::tuple<const char*, SkSVGXmlSpace> gXmlSpaceMap[] = {
            {"default" , SkSVGXmlSpace::kDefault },
            {"preserve", SkSVGXmlSpace::kPreserve},
    };
 
    return this->parseEnumMap(gXmlSpaceMap, xs) && this->parseEOSToken();
}

parse() [36/37]

template<>

bool SkSVGAttributeParser::parse

(

std::vector< SkSVGLength > *

lengths

)

Definition at line 1134 of file SkSVGAttributeParser.cpp.

                                                                {
    return this->parseList(lengths);
}

parse() [37/37]

template<>

bool SkSVGAttributeParser::parse

(

std::vector< SkSVGNumberType > *

numbers

)

Definition at line 1139 of file SkSVGAttributeParser.cpp.

                                                                    {
    return this->parseList(numbers);
}

parseInteger()

bool SkSVGAttributeParser::parseInteger

(

SkSVGIntegerType *

number

)

Definition at line 518 of file SkSVGAttributeParser.cpp.

                                                                {
    // consume WS
    this->parseWSToken();
 
    // consume optional '+'
    this->parseExpectedStringToken("+");
 
    SkSVGIntegerType i;
    if (this->parseInt32Token(&i)) {
        *number = SkSVGNumberType(i);
        // consume trailing separators
        this->parseSepToken();
        return true;
    }
 
    return false;
}

parsePreserveAspectRatio()

bool SkSVGAttributeParser::parsePreserveAspectRatio

(

SkSVGPreserveAspectRatio *

par

)

Definition at line 1073 of file SkSVGAttributeParser.cpp.

                                                                                 {
    static constexpr std::tuple<const char*, SkSVGPreserveAspectRatio::Align> gAlignMap[] = {
        { "none"    , SkSVGPreserveAspectRatio::kNone     },
        { "xMinYMin", SkSVGPreserveAspectRatio::kXMinYMin },
        { "xMidYMin", SkSVGPreserveAspectRatio::kXMidYMin },
        { "xMaxYMin", SkSVGPreserveAspectRatio::kXMaxYMin },
        { "xMinYMid", SkSVGPreserveAspectRatio::kXMinYMid },
        { "xMidYMid", SkSVGPreserveAspectRatio::kXMidYMid },
        { "xMaxYMid", SkSVGPreserveAspectRatio::kXMaxYMid },
        { "xMinYMax", SkSVGPreserveAspectRatio::kXMinYMax },
        { "xMidYMax", SkSVGPreserveAspectRatio::kXMidYMax },
        { "xMaxYMax", SkSVGPreserveAspectRatio::kXMaxYMax },
    };
 
    static constexpr std::tuple<const char*, SkSVGPreserveAspectRatio::Scale> gScaleMap[] = {
        { "meet" , SkSVGPreserveAspectRatio::kMeet  },
        { "slice", SkSVGPreserveAspectRatio::kSlice },
    };
 
    bool parsedValue = false;
 
    // ignoring optional 'defer'
    this->parseExpectedStringToken("defer");
    this->parseWSToken();
 
    if (this->parseEnumMap(gAlignMap, &par->fAlign)) {
        parsedValue = true;
 
        // optional scaling selector
        this->parseWSToken();
        this->parseEnumMap(gScaleMap, &par->fScale);
    }
 
    return parsedValue && this->parseEOSToken();
}

parseProperty()

template<typename PropertyT >

static ParseResult< PropertyT > SkSVGAttributeParser::parseProperty ( const char *  expectedName, const char *  name, const char *  value  )

inlinestatic

Definition at line 52 of file SkSVGAttributeParser.h.

                                                                   {
        if (strcmp(name, expectedName) != 0) {
            return ParseResult<PropertyT>();
        }
 
        if (!strcmp(value, "inherit")) {
            PropertyT result(SkSVGPropertyState::kInherit);
            return ParseResult<PropertyT>(&result);
        }
 
        auto pr = parse<typename PropertyT::ValueT>(value);
        if (pr.isValid()) {
            PropertyT result(*pr);
            return ParseResult<PropertyT>(&result);
        }
 
        return ParseResult<PropertyT>();
    }

parseViewBox()

bool SkSVGAttributeParser::parseViewBox

(

SkSVGViewBoxType *

vb

)

Definition at line 554 of file SkSVGAttributeParser.cpp.

                                                            {
    SkScalar x, y, w, h;
    this->parseWSToken();
 
    bool parsedValue = false;
    if (this->parseScalarToken(&x) && this->parseSepToken() &&
        this->parseScalarToken(&y) && this->parseSepToken() &&
        this->parseScalarToken(&w) && this->parseSepToken() &&
        this->parseScalarToken(&h)) {
 
        *vb = SkSVGViewBoxType(SkRect::MakeXYWH(x, y, w, h));
        parsedValue = true;
        // consume trailing whitespace
        this->parseWSToken();
    }
    return parsedValue && this->parseEOSToken();
}

---

The documentation for this class was generated from the following files:

• third_party/skia/modules/svg/include/SkSVGAttributeParser.h
• third_party/skia/modules/svg/src/SkSVGAttributeParser.cpp
• third_party/skia/modules/svg/src/SkSVGFe.cpp
• third_party/skia/modules/svg/src/SkSVGFeColorMatrix.cpp
• third_party/skia/modules/svg/src/SkSVGFeComposite.cpp
• third_party/skia/modules/svg/src/SkSVGFeTurbulence.cpp
• third_party/skia/modules/svg/src/SkSVGGradient.cpp
• third_party/skia/modules/svg/src/SkSVGPath.cpp
• third_party/skia/modules/svg/src/SkSVGText.cpp