...
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)

## 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 (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