...
Documentation
Documentation

# Package sharedTypes

## Overview ▹

## Overview ▾

## Index ▹

## Index ▾

### Package files

ST_OnOff.go ST_TwipsMeasure.go common.go

## Constants

    const ST_FixedPercentagePattern = `-?((100)|([0-9][0-9]?))(\.[0-9][0-9]?)?%`

    const ST_GuidPattern = `\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}`

    const ST_PercentagePattern = `-?[0-9]+(\.[0-9]+)?%`

    const ST_PositiveFixedPercentagePattern = `((100)|([0-9][0-9]?))(\.[0-9][0-9]?)?%`

    const ST_PositivePercentagePattern = `[0-9]+(\.[0-9]+)?%`

    const ST_PositiveUniversalMeasurePattern = `[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)`

    const ST_UniversalMeasurePattern = `-?[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)`

## Variables

    var ST_FixedPercentagePatternRe = regexp.MustCompile(ST_FixedPercentagePattern)

    var ST_GuidPatternRe = regexp.MustCompile(ST_GuidPattern)

    var ST_PercentagePatternRe = regexp.MustCompile(ST_PercentagePattern)

    var ST_PositiveFixedPercentagePatternRe = regexp.MustCompile(ST_PositiveFixedPercentagePattern)

    var ST_PositivePercentagePatternRe = regexp.MustCompile(ST_PositivePercentagePattern)

    var ST_PositiveUniversalMeasurePatternRe = regexp.MustCompile(ST_PositiveUniversalMeasurePattern)

    var ST_UniversalMeasurePatternRe = regexp.MustCompile(ST_UniversalMeasurePattern)

## func FormatDate ¶

    func FormatDate(t time.Time) string

## func FormatDateTime ¶

    func FormatDateTime(t time.Time) string

## func FormatTime ¶

    func FormatTime(t time.Time) string

## func ParseStdlibTime ¶

    func ParseStdlibTime(s string) (time.Time, error)

## func ParseUintRelaxed ¶

    func ParseUintRelaxed(s string, bitSize int) (uint64, error)

ParseUintRelaxed parses an unsigned integer of the given bit size, tolerating the signed (often negative) values Microsoft Office writes for handle-like attributes such as chart axis IDs (c:axId / c:crossAx). These are declared xsd:unsignedInt but Office emits them as signed int32, so strict ParseUint rejects them and the whole document fails to read.

A conformant unsigned value is parsed as-is; a negative value falls back to signed parsing and is stored as its two's-complement bit pattern, so an axis and the crossAx referencing it still resolve to the same value.

The signature mirrors strconv.ParseUint so generated code can substitute it directly for the same (uint64, error) result shape.

## type ST_AlgClass ¶

    type ST_AlgClass byte

    const (
        ST_AlgClassUnset  ST_AlgClass = 0
        ST_AlgClassHash   ST_AlgClass = 1
        ST_AlgClassCustom ST_AlgClass = 2
    )

### func (ST_AlgClass) MarshalXML ¶

    func (m ST_AlgClass) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_AlgClass) MarshalXMLAttr ¶

    func (e ST_AlgClass) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_AlgClass) String ¶

    func (m ST_AlgClass) String() string

### func (*ST_AlgClass) UnmarshalXML ¶

    func (m *ST_AlgClass) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_AlgClass) UnmarshalXMLAttr ¶

    func (e *ST_AlgClass) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_AlgClass) Validate ¶

    func (m ST_AlgClass) Validate() error

### func (ST_AlgClass) ValidateWithPath ¶

    func (m ST_AlgClass) ValidateWithPath(path string) error

## type ST_AlgType ¶

    type ST_AlgType byte

    const (
        ST_AlgTypeUnset   ST_AlgType = 0
        ST_AlgTypeTypeAny ST_AlgType = 1
        ST_AlgTypeCustom  ST_AlgType = 2
    )

### func (ST_AlgType) MarshalXML ¶

    func (m ST_AlgType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_AlgType) MarshalXMLAttr ¶

    func (e ST_AlgType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_AlgType) String ¶

    func (m ST_AlgType) String() string

### func (*ST_AlgType) UnmarshalXML ¶

    func (m *ST_AlgType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_AlgType) UnmarshalXMLAttr ¶

    func (e *ST_AlgType) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_AlgType) Validate ¶

    func (m ST_AlgType) Validate() error

### func (ST_AlgType) ValidateWithPath ¶

    func (m ST_AlgType) ValidateWithPath(path string) error

## type ST_CalendarType ¶

    type ST_CalendarType byte

    const (
        ST_CalendarTypeUnset                ST_CalendarType = 0
        ST_CalendarTypeGregorian            ST_CalendarType = 1
        ST_CalendarTypeGregorianUs          ST_CalendarType = 2
        ST_CalendarTypeGregorianMeFrench    ST_CalendarType = 3
        ST_CalendarTypeGregorianArabic      ST_CalendarType = 4
        ST_CalendarTypeHijri                ST_CalendarType = 5
        ST_CalendarTypeHebrew               ST_CalendarType = 6
        ST_CalendarTypeTaiwan               ST_CalendarType = 7
        ST_CalendarTypeJapan                ST_CalendarType = 8
        ST_CalendarTypeThai                 ST_CalendarType = 9
        ST_CalendarTypeKorea                ST_CalendarType = 10
        ST_CalendarTypeSaka                 ST_CalendarType = 11
        ST_CalendarTypeGregorianXlitEnglish ST_CalendarType = 12
        ST_CalendarTypeGregorianXlitFrench  ST_CalendarType = 13
        ST_CalendarTypeNone                 ST_CalendarType = 14
    )

### func (ST_CalendarType) MarshalXML ¶

    func (m ST_CalendarType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_CalendarType) MarshalXMLAttr ¶

    func (e ST_CalendarType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_CalendarType) String ¶

    func (m ST_CalendarType) String() string

### func (*ST_CalendarType) UnmarshalXML ¶

    func (m *ST_CalendarType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_CalendarType) UnmarshalXMLAttr ¶

    func (e *ST_CalendarType) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_CalendarType) Validate ¶

    func (m ST_CalendarType) Validate() error

### func (ST_CalendarType) ValidateWithPath ¶

    func (m ST_CalendarType) ValidateWithPath(path string) error

## type ST_ConformanceClass ¶

    type ST_ConformanceClass byte

    const (
        ST_ConformanceClassUnset        ST_ConformanceClass = 0
        ST_ConformanceClassStrict       ST_ConformanceClass = 1
        ST_ConformanceClassTransitional ST_ConformanceClass = 2
    )

### func (ST_ConformanceClass) MarshalXML ¶

    func (m ST_ConformanceClass) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_ConformanceClass) MarshalXMLAttr ¶

    func (e ST_ConformanceClass) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_ConformanceClass) String ¶

    func (m ST_ConformanceClass) String() string

### func (*ST_ConformanceClass) UnmarshalXML ¶

    func (m *ST_ConformanceClass) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_ConformanceClass) UnmarshalXMLAttr ¶

    func (e *ST_ConformanceClass) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_ConformanceClass) Validate ¶

    func (m ST_ConformanceClass) Validate() error

### func (ST_ConformanceClass) ValidateWithPath ¶

    func (m ST_ConformanceClass) ValidateWithPath(path string) error

## type ST_CryptProv ¶

    type ST_CryptProv byte

    const (
        ST_CryptProvUnset   ST_CryptProv = 0
        ST_CryptProvRsaAES  ST_CryptProv = 1
        ST_CryptProvRsaFull ST_CryptProv = 2
        ST_CryptProvCustom  ST_CryptProv = 3
    )

### func (ST_CryptProv) MarshalXML ¶

    func (m ST_CryptProv) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_CryptProv) MarshalXMLAttr ¶

    func (e ST_CryptProv) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_CryptProv) String ¶

    func (m ST_CryptProv) String() string

### func (*ST_CryptProv) UnmarshalXML ¶

    func (m *ST_CryptProv) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_CryptProv) UnmarshalXMLAttr ¶

    func (e *ST_CryptProv) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_CryptProv) Validate ¶

    func (m ST_CryptProv) Validate() error

### func (ST_CryptProv) ValidateWithPath ¶

    func (m ST_CryptProv) ValidateWithPath(path string) error

## type ST_OnOff ¶

ST_OnOff is a union type

    type ST_OnOff struct {
        Bool      *bool
        ST_OnOff1 ST_OnOff1
    }

### func ParseUnionST_OnOff ¶

    func ParseUnionST_OnOff(s string) (ST_OnOff, error)

### func (ST_OnOff) MarshalXML ¶

    func (m ST_OnOff) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_OnOff) String ¶

    func (m ST_OnOff) String() string

### func (*ST_OnOff) Validate ¶

    func (m *ST_OnOff) Validate() error

### func (*ST_OnOff) ValidateWithPath ¶

    func (m *ST_OnOff) ValidateWithPath(path string) error

## type ST_OnOff1 ¶

    type ST_OnOff1 byte

    const (
        ST_OnOff1Unset ST_OnOff1 = 0
        ST_OnOff1On    ST_OnOff1 = 1
        ST_OnOff1Off   ST_OnOff1 = 2
    )

### func (ST_OnOff1) MarshalXML ¶

    func (m ST_OnOff1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_OnOff1) MarshalXMLAttr ¶

    func (e ST_OnOff1) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_OnOff1) String ¶

    func (m ST_OnOff1) String() string

### func (*ST_OnOff1) UnmarshalXML ¶

    func (m *ST_OnOff1) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_OnOff1) UnmarshalXMLAttr ¶

    func (e *ST_OnOff1) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_OnOff1) Validate ¶

    func (m ST_OnOff1) Validate() error

### func (ST_OnOff1) ValidateWithPath ¶

    func (m ST_OnOff1) ValidateWithPath(path string) error

## type ST_TrueFalse ¶

    type ST_TrueFalse byte

    const (
        ST_TrueFalseUnset ST_TrueFalse = 0
        ST_TrueFalseT     ST_TrueFalse = 1
        ST_TrueFalseF     ST_TrueFalse = 2
        ST_TrueFalseTrue  ST_TrueFalse = 3
        ST_TrueFalseFalse ST_TrueFalse = 4
    )

### func (ST_TrueFalse) MarshalXML ¶

    func (m ST_TrueFalse) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_TrueFalse) MarshalXMLAttr ¶

    func (e ST_TrueFalse) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_TrueFalse) String ¶

    func (m ST_TrueFalse) String() string

### func (*ST_TrueFalse) UnmarshalXML ¶

    func (m *ST_TrueFalse) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_TrueFalse) UnmarshalXMLAttr ¶

    func (e *ST_TrueFalse) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_TrueFalse) Validate ¶

    func (m ST_TrueFalse) Validate() error

### func (ST_TrueFalse) ValidateWithPath ¶

    func (m ST_TrueFalse) ValidateWithPath(path string) error

## type ST_TrueFalseBlank ¶

    type ST_TrueFalseBlank byte

    const (
        ST_TrueFalseBlankUnset  ST_TrueFalseBlank = 0
        ST_TrueFalseBlankT      ST_TrueFalseBlank = 1
        ST_TrueFalseBlankF      ST_TrueFalseBlank = 2
        ST_TrueFalseBlankTrue   ST_TrueFalseBlank = 3
        ST_TrueFalseBlankFalse  ST_TrueFalseBlank = 4
        ST_TrueFalseBlankTrue_  ST_TrueFalseBlank = 6
        ST_TrueFalseBlankFalse_ ST_TrueFalseBlank = 7
    )

### func (ST_TrueFalseBlank) MarshalXML ¶

    func (m ST_TrueFalseBlank) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_TrueFalseBlank) MarshalXMLAttr ¶

    func (e ST_TrueFalseBlank) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_TrueFalseBlank) String ¶

    func (m ST_TrueFalseBlank) String() string

### func (*ST_TrueFalseBlank) UnmarshalXML ¶

    func (m *ST_TrueFalseBlank) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_TrueFalseBlank) UnmarshalXMLAttr ¶

    func (e *ST_TrueFalseBlank) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_TrueFalseBlank) Validate ¶

    func (m ST_TrueFalseBlank) Validate() error

### func (ST_TrueFalseBlank) ValidateWithPath ¶

    func (m ST_TrueFalseBlank) ValidateWithPath(path string) error

## type ST_TwipsMeasure ¶

ST_TwipsMeasure is a union type

    type ST_TwipsMeasure struct {
        ST_UnsignedDecimalNumber    *uint64
        ST_PositiveUniversalMeasure *string
    }

### func ParseUnionST_TwipsMeasure ¶

    func ParseUnionST_TwipsMeasure(s string) (ST_TwipsMeasure, error)

### func (ST_TwipsMeasure) MarshalXML ¶

    func (m ST_TwipsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_TwipsMeasure) String ¶

    func (m ST_TwipsMeasure) String() string

### func (*ST_TwipsMeasure) Validate ¶

    func (m *ST_TwipsMeasure) Validate() error

### func (*ST_TwipsMeasure) ValidateWithPath ¶

    func (m *ST_TwipsMeasure) ValidateWithPath(path string) error

## type ST_VerticalAlignRun ¶

    type ST_VerticalAlignRun byte

    const (
        ST_VerticalAlignRunUnset       ST_VerticalAlignRun = 0
        ST_VerticalAlignRunBaseline    ST_VerticalAlignRun = 1
        ST_VerticalAlignRunSuperscript ST_VerticalAlignRun = 2
        ST_VerticalAlignRunSubscript   ST_VerticalAlignRun = 3
    )

### func (ST_VerticalAlignRun) MarshalXML ¶

    func (m ST_VerticalAlignRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_VerticalAlignRun) MarshalXMLAttr ¶

    func (e ST_VerticalAlignRun) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_VerticalAlignRun) String ¶

    func (m ST_VerticalAlignRun) String() string

### func (*ST_VerticalAlignRun) UnmarshalXML ¶

    func (m *ST_VerticalAlignRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_VerticalAlignRun) UnmarshalXMLAttr ¶

    func (e *ST_VerticalAlignRun) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_VerticalAlignRun) Validate ¶

    func (m ST_VerticalAlignRun) Validate() error

### func (ST_VerticalAlignRun) ValidateWithPath ¶

    func (m ST_VerticalAlignRun) ValidateWithPath(path string) error

## type ST_XAlign ¶

    type ST_XAlign byte

    const (
        ST_XAlignUnset   ST_XAlign = 0
        ST_XAlignLeft    ST_XAlign = 1
        ST_XAlignCenter  ST_XAlign = 2
        ST_XAlignRight   ST_XAlign = 3
        ST_XAlignInside  ST_XAlign = 4
        ST_XAlignOutside ST_XAlign = 5
    )

### func (ST_XAlign) MarshalXML ¶

    func (m ST_XAlign) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_XAlign) MarshalXMLAttr ¶

    func (e ST_XAlign) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_XAlign) String ¶

    func (m ST_XAlign) String() string

### func (*ST_XAlign) UnmarshalXML ¶

    func (m *ST_XAlign) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_XAlign) UnmarshalXMLAttr ¶

    func (e *ST_XAlign) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_XAlign) Validate ¶

    func (m ST_XAlign) Validate() error

### func (ST_XAlign) ValidateWithPath ¶

    func (m ST_XAlign) ValidateWithPath(path string) error

## type ST_YAlign ¶

    type ST_YAlign byte

    const (
        ST_YAlignUnset   ST_YAlign = 0
        ST_YAlignInline  ST_YAlign = 1
        ST_YAlignTop     ST_YAlign = 2
        ST_YAlignCenter  ST_YAlign = 3
        ST_YAlignBottom  ST_YAlign = 4
        ST_YAlignInside  ST_YAlign = 5
        ST_YAlignOutside ST_YAlign = 6
    )

### func (ST_YAlign) MarshalXML ¶

    func (m ST_YAlign) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_YAlign) MarshalXMLAttr ¶

    func (e ST_YAlign) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_YAlign) String ¶

    func (m ST_YAlign) String() string

### func (*ST_YAlign) UnmarshalXML ¶

    func (m *ST_YAlign) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_YAlign) UnmarshalXMLAttr ¶

    func (e *ST_YAlign) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_YAlign) Validate ¶

    func (m ST_YAlign) Validate() error

### func (ST_YAlign) ValidateWithPath ¶

    func (m ST_YAlign) ValidateWithPath(path string) error