Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "NewDataValidation", "(", "allowBlank", "bool", ")", "*", "DataValidation", "{", "return", "&", "DataValidation", "{", "AllowBlank", ":", "allowBlank", ",", "ShowErrorMessage", ":", "false", ",", "ShowInputMessage", ":", "false", ",", "}", "\n", "}" ]

[ "NewDataValidation", "return", "data", "validation", "struct", "." ]

[ "func", "(", "dd", "*", "DataValidation", ")", "SetError", "(", "style", "DataValidationErrorStyle", ",", "title", ",", "msg", "string", ")", "{", "dd", ".", "Error", "=", "&", "msg", "\n", "dd", ".", "ErrorTitle", "=", "&", "title", "\n", "strStyle", ":=", "styleStop", "\n", "switch", "style", "{", "case", "DataValidationErrorStyleStop", ":", "strStyle", "=", "styleStop", "\n", "case", "DataValidationErrorStyleWarning", ":", "strStyle", "=", "styleWarning", "\n", "case", "DataValidationErrorStyleInformation", ":", "strStyle", "=", "styleInformation", "\n\n", "}", "\n", "dd", ".", "ShowErrorMessage", "=", "true", "\n", "dd", ".", "ErrorStyle", "=", "&", "strStyle", "\n", "}" ]

[ "SetError", "set", "error", "notice", "." ]

[ "func", "(", "dd", "*", "DataValidation", ")", "SetInput", "(", "title", ",", "msg", "string", ")", "{", "dd", ".", "ShowInputMessage", "=", "true", "\n", "dd", ".", "PromptTitle", "=", "&", "title", "\n", "dd", ".", "Prompt", "=", "&", "msg", "\n", "}" ]

[ "SetInput", "set", "prompt", "notice", "." ]

[ "func", "(", "dd", "*", "DataValidation", ")", "SetDropList", "(", "keys", "[", "]", "string", ")", "error", "{", "formula", ":=", "\"", "\\\"", "\"", "+", "strings", ".", "Join", "(", "keys", ",", "\"", "\"", ")", "+", "\"", "\\\"", "\"", "\n", "if", "dataValidationFormulaStrLen", "<", "len", "(", "formula", ")", "{", "return", "fmt", ".", "Errorf", "(", "dataValidationFormulaStrLenErr", ")", "\n", "}", "\n", "dd", ".", "Formula1", "=", "formula", "\n", "dd", ".", "Type", "=", "convDataValidationType", "(", "typeList", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetDropList", "data", "validation", "list", "." ]

[ "func", "(", "dd", "*", "DataValidation", ")", "SetRange", "(", "f1", ",", "f2", "int", ",", "t", "DataValidationType", ",", "o", "DataValidationOperator", ")", "error", "{", "formula1", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f1", ")", "\n", "formula2", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f2", ")", "\n", "if", "dataValidationFormulaStrLen", "<", "len", "(", "dd", ".", "Formula1", ")", "||", "dataValidationFormulaStrLen", "<", "len", "(", "dd", ".", "Formula2", ")", "{", "return", "fmt", ".", "Errorf", "(", "dataValidationFormulaStrLenErr", ")", "\n", "}", "\n\n", "dd", ".", "Formula1", "=", "formula1", "\n", "dd", ".", "Formula2", "=", "formula2", "\n", "dd", ".", "Type", "=", "convDataValidationType", "(", "t", ")", "\n", "dd", ".", "Operator", "=", "convDataValidationOperatior", "(", "o", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetRange", "provides", "function", "to", "set", "data", "validation", "range", "in", "drop", "list", "." ]

[ "func", "(", "dd", "*", "DataValidation", ")", "SetSqref", "(", "sqref", "string", ")", "{", "if", "dd", ".", "Sqref", "==", "\"", "\"", "{", "dd", ".", "Sqref", "=", "sqref", "\n", "}", "else", "{", "dd", ".", "Sqref", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dd", ".", "Sqref", ",", "sqref", ")", "\n", "}", "\n", "}" ]

[ "SetSqref", "provides", "function", "to", "set", "data", "validation", "range", "in", "drop", "list", "." ]

[ "func", "convDataValidationType", "(", "t", "DataValidationType", ")", "string", "{", "typeMap", ":=", "map", "[", "DataValidationType", "]", "string", "{", "typeNone", ":", "\"", "\"", ",", "DataValidationTypeCustom", ":", "\"", "\"", ",", "DataValidationTypeDate", ":", "\"", "\"", ",", "DataValidationTypeDecimal", ":", "\"", "\"", ",", "typeList", ":", "\"", "\"", ",", "DataValidationTypeTextLeng", ":", "\"", "\"", ",", "DataValidationTypeTime", ":", "\"", "\"", ",", "DataValidationTypeWhole", ":", "\"", "\"", ",", "}", "\n\n", "return", "typeMap", "[", "t", "]", "\n\n", "}" ]

[ "convDataValidationType", "get", "excel", "data", "validation", "type", "." ]

[ "func", "convDataValidationOperatior", "(", "o", "DataValidationOperator", ")", "string", "{", "typeMap", ":=", "map", "[", "DataValidationOperator", "]", "string", "{", "DataValidationOperatorBetween", ":", "\"", "\"", ",", "DataValidationOperatorEqual", ":", "\"", "\"", ",", "DataValidationOperatorGreaterThan", ":", "\"", "\"", ",", "DataValidationOperatorGreaterThanOrEqual", ":", "\"", "\"", ",", "DataValidationOperatorLessThan", ":", "\"", "\"", ",", "DataValidationOperatorLessThanOrEqual", ":", "\"", "\"", ",", "DataValidationOperatorNotBetween", ":", "\"", "\"", ",", "DataValidationOperatorNotEqual", ":", "\"", "\"", ",", "}", "\n\n", "return", "typeMap", "[", "o", "]", "\n\n", "}" ]

[ "convDataValidationOperatior", "get", "excel", "data", "validation", "operator", "." ]

[ "func", "ReadZipReader", "(", "r", "*", "zip", ".", "Reader", ")", "(", "map", "[", "string", "]", "[", "]", "byte", ",", "int", ",", "error", ")", "{", "fileList", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "byte", ")", "\n", "worksheets", ":=", "0", "\n", "for", "_", ",", "v", ":=", "range", "r", ".", "File", "{", "fileList", "[", "v", ".", "Name", "]", "=", "readFile", "(", "v", ")", "\n", "if", "len", "(", "v", ".", "Name", ")", ">", "18", "{", "if", "v", ".", "Name", "[", "0", ":", "19", "]", "==", "\"", "\"", "{", "worksheets", "++", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "fileList", ",", "worksheets", ",", "nil", "\n", "}" ]

[ "ReadZipReader", "can", "be", "used", "to", "read", "an", "XLSX", "in", "memory", "without", "touching", "the", "filesystem", "." ]

[ "func", "(", "f", "*", "File", ")", "readXML", "(", "name", "string", ")", "[", "]", "byte", "{", "if", "content", ",", "ok", ":=", "f", ".", "XLSX", "[", "name", "]", ";", "ok", "{", "return", "content", "\n", "}", "\n", "return", "[", "]", "byte", "{", "}", "\n", "}" ]

[ "readXML", "provides", "a", "function", "to", "read", "XML", "content", "as", "string", "." ]

[ "func", "(", "f", "*", "File", ")", "saveFileList", "(", "name", "string", ",", "content", "[", "]", "byte", ")", "{", "newContent", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "len", "(", "XMLHeader", ")", "+", "len", "(", "content", ")", ")", "\n", "newContent", "=", "append", "(", "newContent", ",", "[", "]", "byte", "(", "XMLHeader", ")", "...", ")", "\n", "newContent", "=", "append", "(", "newContent", ",", "content", "...", ")", "\n", "f", ".", "XLSX", "[", "name", "]", "=", "newContent", "\n", "}" ]

[ "saveFileList", "provides", "a", "function", "to", "update", "given", "file", "content", "in", "file", "list", "of", "XLSX", "." ]

[ "func", "readFile", "(", "file", "*", "zip", ".", "File", ")", "[", "]", "byte", "{", "rc", ",", "err", ":=", "file", ".", "Open", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "buff", ":=", "bytes", ".", "NewBuffer", "(", "nil", ")", "\n", "_", ",", "_", "=", "io", ".", "Copy", "(", "buff", ",", "rc", ")", "\n", "rc", ".", "Close", "(", ")", "\n", "return", "buff", ".", "Bytes", "(", ")", "\n", "}" ]

[ "Read", "file", "content", "as", "string", "in", "a", "archive", "file", "." ]

[ "func", "JoinCellName", "(", "col", "string", ",", "row", "int", ")", "(", "string", ",", "error", ")", "{", "normCol", ":=", "strings", ".", "Map", "(", "func", "(", "rune", "rune", ")", "rune", "{", "switch", "{", "case", "'A'", "<=", "rune", "&&", "rune", "<=", "'Z'", ":", "return", "rune", "\n", "case", "'a'", "<=", "rune", "&&", "rune", "<=", "'z'", ":", "return", "rune", "-", "32", "\n", "}", "\n", "return", "-", "1", "\n", "}", ",", "col", ")", "\n", "if", "len", "(", "col", ")", "==", "0", "||", "len", "(", "col", ")", "!=", "len", "(", "normCol", ")", "{", "return", "\"", "\"", ",", "newInvalidColumnNameError", "(", "col", ")", "\n", "}", "\n", "if", "row", "<", "1", "{", "return", "\"", "\"", ",", "newInvalidRowNumberError", "(", "row", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "normCol", ",", "row", ")", ",", "nil", "\n", "}" ]

[ "JoinCellName", "joins", "cell", "name", "from", "column", "name", "and", "row", "number", "." ]

[ "func", "namespaceStrictToTransitional", "(", "content", "[", "]", "byte", ")", "[", "]", "byte", "{", "var", "namespaceTranslationDic", "=", "map", "[", "string", "]", "string", "{", "StrictSourceRelationship", ":", "SourceRelationship", ",", "StrictSourceRelationshipChart", ":", "SourceRelationshipChart", ",", "StrictSourceRelationshipComments", ":", "SourceRelationshipComments", ",", "StrictSourceRelationshipImage", ":", "SourceRelationshipImage", ",", "StrictNameSpaceSpreadSheet", ":", "NameSpaceSpreadSheet", ",", "}", "\n", "for", "s", ",", "n", ":=", "range", "namespaceTranslationDic", "{", "content", "=", "bytes", ".", "Replace", "(", "content", ",", "[", "]", "byte", "(", "s", ")", ",", "[", "]", "byte", "(", "n", ")", ",", "-", "1", ")", "\n", "}", "\n", "return", "content", "\n", "}" ]

[ "namespaceStrictToTransitional", "provides", "a", "method", "to", "convert", "Strict", "and", "Transitional", "namespaces", "." ]

[ "func", "formatToInt", "(", "i", "int", ",", "v", "string", ")", "string", "{", "f", ",", "err", ":=", "strconv", ".", "ParseFloat", "(", "v", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "v", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int", "(", "f", ")", ")", "\n", "}" ]

[ "formatToInt", "provides", "a", "function", "to", "convert", "original", "string", "to", "integer", "format", "as", "string", "type", "by", "given", "built", "-", "in", "number", "formats", "code", "and", "cell", "string", "." ]

[ "func", "formatToA", "(", "i", "int", ",", "v", "string", ")", "string", "{", "f", ",", "err", ":=", "strconv", ".", "ParseFloat", "(", "v", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "v", "\n", "}", "\n", "if", "f", "<", "0", "{", "t", ":=", "int", "(", "math", ".", "Abs", "(", "f", ")", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "t", ")", "\n", "}", "\n", "t", ":=", "int", "(", "f", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "t", ")", "\n", "}" ]

[ "formatToA", "provides", "a", "function", "to", "convert", "original", "string", "to", "special", "format", "as", "string", "type", "by", "given", "built", "-", "in", "number", "formats", "code", "and", "cell", "string", "." ]

[ "func", "is12HourTime", "(", "format", "string", ")", "bool", "{", "return", "strings", ".", "Contains", "(", "format", ",", "\"", "\"", ")", "||", "strings", ".", "Contains", "(", "format", ",", "\"", "\"", ")", "||", "strings", ".", "Contains", "(", "format", ",", "\"", "\"", ")", "||", "strings", ".", "Contains", "(", "format", ",", "\"", "\"", ")", "\n", "}" ]

[ "is12HourTime", "checks", "whether", "an", "Excel", "time", "format", "string", "is", "a", "12", "hours", "form", "." ]

[ "func", "parseFormatStyleSet", "(", "style", "string", ")", "(", "*", "formatStyle", ",", "error", ")", "{", "format", ":=", "formatStyle", "{", "DecimalPlaces", ":", "2", ",", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "style", ")", ",", "&", "format", ")", "\n", "return", "&", "format", ",", "err", "\n", "}" ]

[ "parseFormatStyleSet", "provides", "a", "function", "to", "parse", "the", "format", "settings", "of", "the", "cells", "and", "conditional", "formats", "." ]

[ "func", "setFont", "(", "formatStyle", "*", "formatStyle", ")", "*", "font", "{", "fontUnderlineType", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", "}", "\n", "if", "formatStyle", ".", "Font", ".", "Size", "<", "1", "{", "formatStyle", ".", "Font", ".", "Size", "=", "11", "\n", "}", "\n", "if", "formatStyle", ".", "Font", ".", "Color", "==", "\"", "\"", "{", "formatStyle", ".", "Font", ".", "Color", "=", "\"", "\"", "\n", "}", "\n", "f", ":=", "font", "{", "B", ":", "formatStyle", ".", "Font", ".", "Bold", ",", "I", ":", "formatStyle", ".", "Font", ".", "Italic", ",", "Sz", ":", "&", "attrValInt", "{", "Val", ":", "formatStyle", ".", "Font", ".", "Size", "}", ",", "Color", ":", "&", "xlsxColor", "{", "RGB", ":", "getPaletteColor", "(", "formatStyle", ".", "Font", ".", "Color", ")", "}", ",", "Name", ":", "&", "attrValString", "{", "Val", ":", "formatStyle", ".", "Font", ".", "Family", "}", ",", "Family", ":", "&", "attrValInt", "{", "Val", ":", "2", "}", ",", "}", "\n", "if", "f", ".", "Name", ".", "Val", "==", "\"", "\"", "{", "f", ".", "Name", ".", "Val", "=", "\"", "\"", "\n", "f", ".", "Scheme", "=", "&", "attrValString", "{", "Val", ":", "\"", "\"", "}", "\n", "}", "\n", "val", ",", "ok", ":=", "fontUnderlineType", "[", "formatStyle", ".", "Font", ".", "Underline", "]", "\n", "if", "ok", "{", "f", ".", "U", "=", "&", "attrValString", "{", "Val", ":", "val", "}", "\n", "}", "\n", "return", "&", "f", "\n", "}" ]

[ "setFont", "provides", "a", "function", "to", "add", "font", "style", "by", "given", "cell", "format", "settings", "." ]

[ "func", "setNumFmt", "(", "style", "*", "xlsxStyleSheet", ",", "formatStyle", "*", "formatStyle", ")", "int", "{", "dp", ":=", "\"", "\"", "\n", "numFmtID", ":=", "164", "// Default custom number format code from 164.", "\n", "if", "formatStyle", ".", "DecimalPlaces", "<", "0", "||", "formatStyle", ".", "DecimalPlaces", ">", "30", "{", "formatStyle", ".", "DecimalPlaces", "=", "2", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "formatStyle", ".", "DecimalPlaces", ";", "i", "++", "{", "dp", "+=", "\"", "\"", "\n", "}", "\n", "if", "formatStyle", ".", "CustomNumFmt", "!=", "nil", "{", "return", "setCustomNumFmt", "(", "style", ",", "formatStyle", ")", "\n", "}", "\n", "_", ",", "ok", ":=", "builtInNumFmt", "[", "formatStyle", ".", "NumFmt", "]", "\n", "if", "!", "ok", "{", "fc", ",", "currency", ":=", "currencyNumFmt", "[", "formatStyle", ".", "NumFmt", "]", "\n", "if", "!", "currency", "{", "return", "setLangNumFmt", "(", "style", ",", "formatStyle", ")", "\n", "}", "\n", "fc", "=", "strings", ".", "Replace", "(", "fc", ",", "\"", "\"", ",", "dp", ",", "-", "1", ")", "\n", "if", "formatStyle", ".", "NegRed", "{", "fc", "=", "fc", "+", "\"", "\"", "+", "fc", "\n", "}", "\n", "if", "style", ".", "NumFmts", "!=", "nil", "{", "numFmtID", "=", "style", ".", "NumFmts", ".", "NumFmt", "[", "len", "(", "style", ".", "NumFmts", ".", "NumFmt", ")", "-", "1", "]", ".", "NumFmtID", "+", "1", "\n", "nf", ":=", "xlsxNumFmt", "{", "FormatCode", ":", "fc", ",", "NumFmtID", ":", "numFmtID", ",", "}", "\n", "style", ".", "NumFmts", ".", "NumFmt", "=", "append", "(", "style", ".", "NumFmts", ".", "NumFmt", ",", "&", "nf", ")", "\n", "style", ".", "NumFmts", ".", "Count", "++", "\n", "}", "else", "{", "nf", ":=", "xlsxNumFmt", "{", "FormatCode", ":", "fc", ",", "NumFmtID", ":", "numFmtID", ",", "}", "\n", "numFmts", ":=", "xlsxNumFmts", "{", "NumFmt", ":", "[", "]", "*", "xlsxNumFmt", "{", "&", "nf", "}", ",", "Count", ":", "1", ",", "}", "\n", "style", ".", "NumFmts", "=", "&", "numFmts", "\n", "}", "\n", "return", "numFmtID", "\n", "}", "\n", "return", "formatStyle", ".", "NumFmt", "\n", "}" ]

[ "setNumFmt", "provides", "a", "function", "to", "check", "if", "number", "format", "code", "in", "the", "range", "of", "built", "-", "in", "values", "." ]

[ "func", "setCustomNumFmt", "(", "style", "*", "xlsxStyleSheet", ",", "formatStyle", "*", "formatStyle", ")", "int", "{", "nf", ":=", "xlsxNumFmt", "{", "FormatCode", ":", "*", "formatStyle", ".", "CustomNumFmt", "}", "\n", "if", "style", ".", "NumFmts", "!=", "nil", "{", "nf", ".", "NumFmtID", "=", "style", ".", "NumFmts", ".", "NumFmt", "[", "len", "(", "style", ".", "NumFmts", ".", "NumFmt", ")", "-", "1", "]", ".", "NumFmtID", "+", "1", "\n", "style", ".", "NumFmts", ".", "NumFmt", "=", "append", "(", "style", ".", "NumFmts", ".", "NumFmt", ",", "&", "nf", ")", "\n", "style", ".", "NumFmts", ".", "Count", "++", "\n", "}", "else", "{", "nf", ".", "NumFmtID", "=", "164", "\n", "numFmts", ":=", "xlsxNumFmts", "{", "NumFmt", ":", "[", "]", "*", "xlsxNumFmt", "{", "&", "nf", "}", ",", "Count", ":", "1", ",", "}", "\n", "style", ".", "NumFmts", "=", "&", "numFmts", "\n", "}", "\n", "return", "nf", ".", "NumFmtID", "\n", "}" ]

[ "setCustomNumFmt", "provides", "a", "function", "to", "set", "custom", "number", "format", "code", "." ]

[ "func", "setLangNumFmt", "(", "style", "*", "xlsxStyleSheet", ",", "formatStyle", "*", "formatStyle", ")", "int", "{", "numFmts", ",", "ok", ":=", "langNumFmt", "[", "formatStyle", ".", "Lang", "]", "\n", "if", "!", "ok", "{", "return", "0", "\n", "}", "\n", "var", "fc", "string", "\n", "fc", ",", "ok", "=", "numFmts", "[", "formatStyle", ".", "NumFmt", "]", "\n", "if", "!", "ok", "{", "return", "0", "\n", "}", "\n", "nf", ":=", "xlsxNumFmt", "{", "FormatCode", ":", "fc", "}", "\n", "if", "style", ".", "NumFmts", "!=", "nil", "{", "nf", ".", "NumFmtID", "=", "style", ".", "NumFmts", ".", "NumFmt", "[", "len", "(", "style", ".", "NumFmts", ".", "NumFmt", ")", "-", "1", "]", ".", "NumFmtID", "+", "1", "\n", "style", ".", "NumFmts", ".", "NumFmt", "=", "append", "(", "style", ".", "NumFmts", ".", "NumFmt", ",", "&", "nf", ")", "\n", "style", ".", "NumFmts", ".", "Count", "++", "\n", "}", "else", "{", "nf", ".", "NumFmtID", "=", "formatStyle", ".", "NumFmt", "\n", "numFmts", ":=", "xlsxNumFmts", "{", "NumFmt", ":", "[", "]", "*", "xlsxNumFmt", "{", "&", "nf", "}", ",", "Count", ":", "1", ",", "}", "\n", "style", ".", "NumFmts", "=", "&", "numFmts", "\n", "}", "\n", "return", "nf", ".", "NumFmtID", "\n", "}" ]

[ "setLangNumFmt", "provides", "a", "function", "to", "set", "number", "format", "code", "with", "language", "." ]

[ "func", "setFills", "(", "formatStyle", "*", "formatStyle", ",", "fg", "bool", ")", "*", "xlsxFill", "{", "var", "patterns", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n\n", "var", "variants", "=", "[", "]", "float64", "{", "90", ",", "0", ",", "45", ",", "135", ",", "}", "\n\n", "var", "fill", "xlsxFill", "\n", "switch", "formatStyle", ".", "Fill", ".", "Type", "{", "case", "\"", "\"", ":", "if", "len", "(", "formatStyle", ".", "Fill", ".", "Color", ")", "!=", "2", "{", "break", "\n", "}", "\n", "var", "gradient", "xlsxGradientFill", "\n", "switch", "formatStyle", ".", "Fill", ".", "Shading", "{", "case", "0", ",", "1", ",", "2", ",", "3", ":", "gradient", ".", "Degree", "=", "variants", "[", "formatStyle", ".", "Fill", ".", "Shading", "]", "\n", "case", "4", ":", "gradient", ".", "Type", "=", "\"", "\"", "\n", "case", "5", ":", "gradient", ".", "Type", "=", "\"", "\"", "\n", "gradient", ".", "Bottom", "=", "0.5", "\n", "gradient", ".", "Left", "=", "0.5", "\n", "gradient", ".", "Right", "=", "0.5", "\n", "gradient", ".", "Top", "=", "0.5", "\n", "default", ":", "break", "\n", "}", "\n", "var", "stops", "[", "]", "*", "xlsxGradientFillStop", "\n", "for", "index", ",", "color", ":=", "range", "formatStyle", ".", "Fill", ".", "Color", "{", "var", "stop", "xlsxGradientFillStop", "\n", "stop", ".", "Position", "=", "float64", "(", "index", ")", "\n", "stop", ".", "Color", ".", "RGB", "=", "getPaletteColor", "(", "color", ")", "\n", "stops", "=", "append", "(", "stops", ",", "&", "stop", ")", "\n", "}", "\n", "gradient", ".", "Stop", "=", "stops", "\n", "fill", ".", "GradientFill", "=", "&", "gradient", "\n", "case", "\"", "\"", ":", "if", "formatStyle", ".", "Fill", ".", "Pattern", ">", "18", "||", "formatStyle", ".", "Fill", ".", "Pattern", "<", "0", "{", "break", "\n", "}", "\n", "if", "len", "(", "formatStyle", ".", "Fill", ".", "Color", ")", "<", "1", "{", "break", "\n", "}", "\n", "var", "pattern", "xlsxPatternFill", "\n", "pattern", ".", "PatternType", "=", "patterns", "[", "formatStyle", ".", "Fill", ".", "Pattern", "]", "\n", "if", "fg", "{", "pattern", ".", "FgColor", ".", "RGB", "=", "getPaletteColor", "(", "formatStyle", ".", "Fill", ".", "Color", "[", "0", "]", ")", "\n", "}", "else", "{", "pattern", ".", "BgColor", ".", "RGB", "=", "getPaletteColor", "(", "formatStyle", ".", "Fill", ".", "Color", "[", "0", "]", ")", "\n", "}", "\n", "fill", ".", "PatternFill", "=", "&", "pattern", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "return", "&", "fill", "\n", "}" ]

[ "setFills", "provides", "a", "function", "to", "add", "fill", "elements", "in", "the", "styles", ".", "xml", "by", "given", "cell", "format", "settings", "." ]

[ "func", "setAlignment", "(", "formatStyle", "*", "formatStyle", ")", "*", "xlsxAlignment", "{", "var", "alignment", "xlsxAlignment", "\n", "if", "formatStyle", ".", "Alignment", "!=", "nil", "{", "alignment", ".", "Horizontal", "=", "formatStyle", ".", "Alignment", ".", "Horizontal", "\n", "alignment", ".", "Indent", "=", "formatStyle", ".", "Alignment", ".", "Indent", "\n", "alignment", ".", "JustifyLastLine", "=", "formatStyle", ".", "Alignment", ".", "JustifyLastLine", "\n", "alignment", ".", "ReadingOrder", "=", "formatStyle", ".", "Alignment", ".", "ReadingOrder", "\n", "alignment", ".", "RelativeIndent", "=", "formatStyle", ".", "Alignment", ".", "RelativeIndent", "\n", "alignment", ".", "ShrinkToFit", "=", "formatStyle", ".", "Alignment", ".", "ShrinkToFit", "\n", "alignment", ".", "TextRotation", "=", "formatStyle", ".", "Alignment", ".", "TextRotation", "\n", "alignment", ".", "Vertical", "=", "formatStyle", ".", "Alignment", ".", "Vertical", "\n", "alignment", ".", "WrapText", "=", "formatStyle", ".", "Alignment", ".", "WrapText", "\n", "}", "\n", "return", "&", "alignment", "\n", "}" ]

[ "setAlignment", "provides", "a", "function", "to", "formatting", "information", "pertaining", "to", "text", "alignment", "in", "cells", ".", "There", "are", "a", "variety", "of", "choices", "for", "how", "text", "is", "aligned", "both", "horizontally", "and", "vertically", "as", "well", "as", "indentation", "settings", "and", "so", "on", "." ]

[ "func", "setProtection", "(", "formatStyle", "*", "formatStyle", ")", "*", "xlsxProtection", "{", "var", "protection", "xlsxProtection", "\n", "if", "formatStyle", ".", "Protection", "!=", "nil", "{", "protection", ".", "Hidden", "=", "formatStyle", ".", "Protection", ".", "Hidden", "\n", "protection", ".", "Locked", "=", "formatStyle", ".", "Protection", ".", "Locked", "\n", "}", "\n", "return", "&", "protection", "\n", "}" ]

[ "setProtection", "provides", "a", "function", "to", "set", "protection", "properties", "associated", "with", "the", "cell", "." ]

[ "func", "setBorders", "(", "formatStyle", "*", "formatStyle", ")", "*", "xlsxBorder", "{", "var", "styles", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n\n", "var", "border", "xlsxBorder", "\n", "for", "_", ",", "v", ":=", "range", "formatStyle", ".", "Border", "{", "if", "0", "<=", "v", ".", "Style", "&&", "v", ".", "Style", "<", "14", "{", "var", "color", "xlsxColor", "\n", "color", ".", "RGB", "=", "getPaletteColor", "(", "v", ".", "Color", ")", "\n", "switch", "v", ".", "Type", "{", "case", "\"", "\"", ":", "border", ".", "Left", ".", "Style", "=", "styles", "[", "v", ".", "Style", "]", "\n", "border", ".", "Left", ".", "Color", "=", "&", "color", "\n", "case", "\"", "\"", ":", "border", ".", "Right", ".", "Style", "=", "styles", "[", "v", ".", "Style", "]", "\n", "border", ".", "Right", ".", "Color", "=", "&", "color", "\n", "case", "\"", "\"", ":", "border", ".", "Top", ".", "Style", "=", "styles", "[", "v", ".", "Style", "]", "\n", "border", ".", "Top", ".", "Color", "=", "&", "color", "\n", "case", "\"", "\"", ":", "border", ".", "Bottom", ".", "Style", "=", "styles", "[", "v", ".", "Style", "]", "\n", "border", ".", "Bottom", ".", "Color", "=", "&", "color", "\n", "case", "\"", "\"", ":", "border", ".", "Diagonal", ".", "Style", "=", "styles", "[", "v", ".", "Style", "]", "\n", "border", ".", "Diagonal", ".", "Color", "=", "&", "color", "\n", "border", ".", "DiagonalUp", "=", "true", "\n", "case", "\"", "\"", ":", "border", ".", "Diagonal", ".", "Style", "=", "styles", "[", "v", ".", "Style", "]", "\n", "border", ".", "Diagonal", ".", "Color", "=", "&", "color", "\n", "border", ".", "DiagonalDown", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "&", "border", "\n", "}" ]

[ "setBorders", "provides", "a", "function", "to", "add", "border", "elements", "in", "the", "styles", ".", "xml", "by", "given", "borders", "format", "settings", "." ]

[ "func", "setCellXfs", "(", "style", "*", "xlsxStyleSheet", ",", "fontID", ",", "numFmtID", ",", "fillID", ",", "borderID", "int", ",", "applyAlignment", ",", "applyProtection", "bool", ",", "alignment", "*", "xlsxAlignment", ",", "protection", "*", "xlsxProtection", ")", "int", "{", "var", "xf", "xlsxXf", "\n", "xf", ".", "FontID", "=", "fontID", "\n", "if", "fontID", "!=", "0", "{", "xf", ".", "ApplyFont", "=", "true", "\n", "}", "\n", "xf", ".", "NumFmtID", "=", "numFmtID", "\n", "if", "numFmtID", "!=", "0", "{", "xf", ".", "ApplyNumberFormat", "=", "true", "\n", "}", "\n", "xf", ".", "FillID", "=", "fillID", "\n", "xf", ".", "BorderID", "=", "borderID", "\n", "style", ".", "CellXfs", ".", "Count", "++", "\n", "xf", ".", "Alignment", "=", "alignment", "\n", "xf", ".", "ApplyAlignment", "=", "applyAlignment", "\n", "if", "applyProtection", "{", "xf", ".", "ApplyProtection", "=", "applyProtection", "\n", "xf", ".", "Protection", "=", "protection", "\n", "}", "\n", "xfID", ":=", "0", "\n", "xf", ".", "XfID", "=", "&", "xfID", "\n", "style", ".", "CellXfs", ".", "Xf", "=", "append", "(", "style", ".", "CellXfs", ".", "Xf", ",", "xf", ")", "\n", "return", "style", ".", "CellXfs", ".", "Count", "-", "1", "\n", "}" ]

[ "setCellXfs", "provides", "a", "function", "to", "set", "describes", "all", "of", "the", "formatting", "for", "a", "cell", "." ]

[ "func", "(", "f", "*", "File", ")", "GetCellStyle", "(", "sheet", ",", "axis", "string", ")", "(", "int", ",", "error", ")", "{", "xlsx", ",", "err", ":=", "f", ".", "workSheetReader", "(", "sheet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "cellData", ",", "col", ",", "_", ",", "err", ":=", "f", ".", "prepareCell", "(", "xlsx", ",", "sheet", ",", "axis", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "f", ".", "prepareCellStyle", "(", "xlsx", ",", "col", ",", "cellData", ".", "S", ")", ",", "err", "\n", "}" ]

[ "GetCellStyle", "provides", "a", "function", "to", "get", "cell", "style", "index", "by", "given", "worksheet", "name", "and", "cell", "coordinates", "." ]

[ "func", "drawCondFmtAboveAverage", "(", "p", "int", ",", "ct", "string", ",", "format", "*", "formatConditional", ")", "*", "xlsxCfRule", "{", "return", "&", "xlsxCfRule", "{", "Priority", ":", "p", "+", "1", ",", "Type", ":", "validType", "[", "format", ".", "Type", "]", ",", "AboveAverage", ":", "&", "format", ".", "AboveAverage", ",", "DxfID", ":", "&", "format", ".", "Format", ",", "}", "\n", "}" ]

[ "drawCondFmtAboveAverage", "provides", "a", "function", "to", "create", "conditional", "formatting", "rule", "for", "above", "average", "and", "below", "average", "by", "given", "priority", "criteria", "type", "and", "format", "settings", "." ]

[ "func", "drawCondFmtDataBar", "(", "p", "int", ",", "ct", "string", ",", "format", "*", "formatConditional", ")", "*", "xlsxCfRule", "{", "return", "&", "xlsxCfRule", "{", "Priority", ":", "p", "+", "1", ",", "Type", ":", "validType", "[", "format", ".", "Type", "]", ",", "DataBar", ":", "&", "xlsxDataBar", "{", "Cfvo", ":", "[", "]", "*", "xlsxCfvo", "{", "{", "Type", ":", "format", ".", "MinType", "}", ",", "{", "Type", ":", "format", ".", "MaxType", "}", "}", ",", "Color", ":", "[", "]", "*", "xlsxColor", "{", "{", "RGB", ":", "getPaletteColor", "(", "format", ".", "BarColor", ")", "}", "}", ",", "}", ",", "}", "\n", "}" ]

[ "drawCondFmtDataBar", "provides", "a", "function", "to", "create", "conditional", "formatting", "rule", "for", "data", "bar", "by", "given", "priority", "criteria", "type", "and", "format", "settings", "." ]

[ "func", "drawConfFmtExp", "(", "p", "int", ",", "ct", "string", ",", "format", "*", "formatConditional", ")", "*", "xlsxCfRule", "{", "return", "&", "xlsxCfRule", "{", "Priority", ":", "p", "+", "1", ",", "Type", ":", "validType", "[", "format", ".", "Type", "]", ",", "Formula", ":", "[", "]", "string", "{", "format", ".", "Criteria", "}", ",", "DxfID", ":", "&", "format", ".", "Format", ",", "}", "\n", "}" ]

[ "drawConfFmtExp", "provides", "a", "function", "to", "create", "conditional", "formatting", "rule", "for", "expression", "by", "given", "priority", "criteria", "type", "and", "format", "settings", "." ]

[ "func", "ThemeColor", "(", "baseColor", "string", ",", "tint", "float64", ")", "string", "{", "if", "tint", "==", "0", "{", "return", "\"", "\"", "+", "baseColor", "\n", "}", "\n", "r", ",", "_", ":=", "strconv", ".", "ParseInt", "(", "baseColor", "[", "0", ":", "2", "]", ",", "16", ",", "64", ")", "\n", "g", ",", "_", ":=", "strconv", ".", "ParseInt", "(", "baseColor", "[", "2", ":", "4", "]", ",", "16", ",", "64", ")", "\n", "b", ",", "_", ":=", "strconv", ".", "ParseInt", "(", "baseColor", "[", "4", ":", "6", "]", ",", "16", ",", "64", ")", "\n", "h", ",", "s", ",", "l", ":=", "RGBToHSL", "(", "uint8", "(", "r", ")", ",", "uint8", "(", "g", ")", ",", "uint8", "(", "b", ")", ")", "\n", "if", "tint", "<", "0", "{", "l", "*=", "(", "1", "+", "tint", ")", "\n", "}", "else", "{", "l", "=", "l", "*", "(", "1", "-", "tint", ")", "+", "(", "1", "-", "(", "1", "-", "tint", ")", ")", "\n", "}", "\n", "br", ",", "bg", ",", "bb", ":=", "HSLToRGB", "(", "h", ",", "s", ",", "l", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "br", ",", "bg", ",", "bb", ")", "\n", "}" ]

[ "ThemeColor", "applied", "the", "color", "with", "tint", "value", "." ]

[ "func", "parseFormatShapeSet", "(", "formatSet", "string", ")", "(", "*", "formatShape", ",", "error", ")", "{", "format", ":=", "formatShape", "{", "Width", ":", "160", ",", "Height", ":", "160", ",", "Format", ":", "formatPicture", "{", "FPrintsWithSheet", ":", "true", ",", "FLocksWithSheet", ":", "false", ",", "NoChangeAspect", ":", "false", ",", "OffsetX", ":", "0", ",", "OffsetY", ":", "0", ",", "XScale", ":", "1.0", ",", "YScale", ":", "1.0", ",", "}", ",", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "formatSet", ")", ",", "&", "format", ")", "\n", "return", "&", "format", ",", "err", "\n", "}" ]

[ "parseFormatShapeSet", "provides", "a", "function", "to", "parse", "the", "format", "settings", "of", "the", "shape", "with", "default", "value", "." ]

[ "func", "setShapeRef", "(", "color", "string", ",", "i", "int", ")", "*", "aRef", "{", "if", "color", "==", "\"", "\"", "{", "return", "&", "aRef", "{", "Idx", ":", "0", ",", "ScrgbClr", ":", "&", "aScrgbClr", "{", "R", ":", "0", ",", "G", ":", "0", ",", "B", ":", "0", ",", "}", ",", "}", "\n", "}", "\n", "return", "&", "aRef", "{", "Idx", ":", "i", ",", "SrgbClr", ":", "&", "attrValString", "{", "Val", ":", "strings", ".", "Replace", "(", "strings", ".", "ToUpper", "(", "color", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", ",", "}", ",", "}", "\n", "}" ]

[ "setShapeRef", "provides", "a", "function", "to", "set", "color", "with", "hex", "model", "by", "given", "actual", "color", "value", "." ]

[ "func", "trimCell", "(", "column", "[", "]", "xlsxC", ")", "[", "]", "xlsxC", "{", "col", ":=", "make", "(", "[", "]", "xlsxC", ",", "len", "(", "column", ")", ")", "\n", "i", ":=", "0", "\n", "for", "_", ",", "c", ":=", "range", "column", "{", "if", "c", ".", "S", "!=", "0", "||", "c", ".", "V", "!=", "\"", "\"", "||", "c", ".", "F", "!=", "nil", "||", "c", ".", "T", "!=", "\"", "\"", "{", "col", "[", "i", "]", "=", "c", "\n", "i", "++", "\n", "}", "\n", "}", "\n", "return", "col", "[", "0", ":", "i", "]", "\n", "}" ]

[ "trimCell", "provides", "a", "function", "to", "trim", "blank", "cells", "which", "created", "by", "completeCol", "." ]

[ "func", "(", "f", "*", "File", ")", "setContentTypes", "(", "index", "int", ")", "{", "content", ":=", "f", ".", "contentTypesReader", "(", ")", "\n", "content", ".", "Overrides", "=", "append", "(", "content", ".", "Overrides", ",", "xlsxOverride", "{", "PartName", ":", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "index", ")", "+", "\"", "\"", ",", "ContentType", ":", "\"", "\"", ",", "}", ")", "\n", "}" ]

[ "setContentTypes", "provides", "a", "function", "to", "read", "and", "update", "property", "of", "contents", "type", "of", "XLSX", "." ]

[ "func", "(", "f", "*", "File", ")", "setSheet", "(", "index", "int", ",", "name", "string", ")", "{", "var", "xlsx", "xlsxWorksheet", "\n", "xlsx", ".", "Dimension", ".", "Ref", "=", "\"", "\"", "\n", "xlsx", ".", "SheetViews", ".", "SheetView", "=", "append", "(", "xlsx", ".", "SheetViews", ".", "SheetView", ",", "xlsxSheetView", "{", "WorkbookViewID", ":", "0", ",", "}", ")", "\n", "path", ":=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "index", ")", "+", "\"", "\"", "\n", "f", ".", "sheetMap", "[", "trimSheetName", "(", "name", ")", "]", "=", "path", "\n", "f", ".", "Sheet", "[", "path", "]", "=", "&", "xlsx", "\n", "}" ]

[ "setSheet", "provides", "a", "function", "to", "update", "sheet", "property", "by", "given", "index", "." ]

[ "func", "(", "f", "*", "File", ")", "setWorkbook", "(", "name", "string", ",", "sheetID", ",", "rid", "int", ")", "{", "content", ":=", "f", ".", "workbookReader", "(", ")", "\n", "content", ".", "Sheets", ".", "Sheet", "=", "append", "(", "content", ".", "Sheets", ".", "Sheet", ",", "xlsxSheet", "{", "Name", ":", "trimSheetName", "(", "name", ")", ",", "SheetID", ":", "sheetID", ",", "ID", ":", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "rid", ")", ",", "}", ")", "\n", "}" ]

[ "setWorkbook", "update", "workbook", "property", "of", "XLSX", ".", "Maximum", "31", "characters", "are", "allowed", "in", "sheet", "title", "." ]

[ "func", "(", "f", "*", "File", ")", "workbookRelsReader", "(", ")", "*", "xlsxWorkbookRels", "{", "if", "f", ".", "WorkBookRels", "==", "nil", "{", "var", "content", "xlsxWorkbookRels", "\n", "_", "=", "xml", ".", "Unmarshal", "(", "namespaceStrictToTransitional", "(", "f", ".", "readXML", "(", "\"", "\"", ")", ")", ",", "&", "content", ")", "\n", "f", ".", "WorkBookRels", "=", "&", "content", "\n", "}", "\n", "return", "f", ".", "WorkBookRels", "\n", "}" ]

[ "workbookRelsReader", "provides", "a", "function", "to", "read", "and", "unmarshal", "workbook", "relationships", "of", "XLSX", "file", "." ]

[ "func", "(", "f", "*", "File", ")", "addXlsxWorkbookRels", "(", "sheet", "int", ")", "int", "{", "content", ":=", "f", ".", "workbookRelsReader", "(", ")", "\n", "rID", ":=", "0", "\n", "for", "_", ",", "v", ":=", "range", "content", ".", "Relationships", "{", "t", ",", "_", ":=", "strconv", ".", "Atoi", "(", "strings", ".", "TrimPrefix", "(", "v", ".", "ID", ",", "\"", "\"", ")", ")", "\n", "if", "t", ">", "rID", "{", "rID", "=", "t", "\n", "}", "\n", "}", "\n", "rID", "++", "\n", "ID", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "ID", ".", "WriteString", "(", "\"", "\"", ")", "\n", "ID", ".", "WriteString", "(", "strconv", ".", "Itoa", "(", "rID", ")", ")", "\n", "target", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "target", ".", "WriteString", "(", "\"", "\"", ")", "\n", "target", ".", "WriteString", "(", "strconv", ".", "Itoa", "(", "sheet", ")", ")", "\n", "target", ".", "WriteString", "(", "\"", "\"", ")", "\n", "content", ".", "Relationships", "=", "append", "(", "content", ".", "Relationships", ",", "xlsxWorkbookRelation", "{", "ID", ":", "ID", ".", "String", "(", ")", ",", "Target", ":", "target", ".", "String", "(", ")", ",", "Type", ":", "SourceRelationshipWorkSheet", ",", "}", ")", "\n", "return", "rID", "\n", "}" ]

[ "addXlsxWorkbookRels", "update", "workbook", "relationships", "property", "of", "XLSX", "." ]

[ "func", "replaceRelationshipsBytes", "(", "content", "[", "]", "byte", ")", "[", "]", "byte", "{", "oldXmlns", ":=", "[", "]", "byte", "(", "`xmlns:relationships=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" relationships`", ")", "\n", "newXmlns", ":=", "[", "]", "byte", "(", "\"", "\"", ")", "\n", "return", "bytes", ".", "Replace", "(", "content", ",", "oldXmlns", ",", "newXmlns", ",", "-", "1", ")", "\n", "}" ]

[ "replaceRelationshipsBytes", ";", "Some", "tools", "that", "read", "XLSX", "files", "have", "very", "strict", "requirements", "about", "the", "structure", "of", "the", "input", "XML", ".", "This", "function", "is", "a", "horrible", "hack", "to", "fix", "that", "after", "the", "XML", "marshalling", "is", "completed", "." ]

[ "func", "replaceRelationshipsNameSpaceBytes", "(", "workbookMarshal", "[", "]", "byte", ")", "[", "]", "byte", "{", "oldXmlns", ":=", "[", "]", "byte", "(", "`<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">`", ")", "\n", "newXmlns", ":=", "[", "]", "byte", "(", "`<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"x15\" xmlns:x15=\"http://schemas.microsoft.com/office/spreadsheetml/2010/11/main\">`", ")", "\n", "return", "bytes", ".", "Replace", "(", "workbookMarshal", ",", "oldXmlns", ",", "newXmlns", ",", "-", "1", ")", "\n", "}" ]

[ "replaceRelationshipsNameSpaceBytes", ";", "Some", "tools", "that", "read", "XLSX", "files", "have", "very", "strict", "requirements", "about", "the", "structure", "of", "the", "input", "XML", ".", "In", "particular", "both", "Numbers", "on", "the", "Mac", "and", "SAS", "dislike", "inline", "XML", "namespace", "declarations", "or", "namespace", "prefixes", "that", "don", "t", "match", "the", "ones", "that", "Excel", "itself", "uses", ".", "This", "is", "a", "problem", "because", "the", "Go", "XML", "library", "doesn", "t", "multiple", "namespace", "declarations", "in", "a", "single", "element", "of", "a", "document", ".", "This", "function", "is", "a", "horrible", "hack", "to", "fix", "that", "after", "the", "XML", "marshalling", "is", "completed", "." ]

[ "func", "(", "f", "*", "File", ")", "GetActiveSheetIndex", "(", ")", "int", "{", "for", "idx", ",", "name", ":=", "range", "f", ".", "GetSheetMap", "(", ")", "{", "xlsx", ",", "_", ":=", "f", ".", "workSheetReader", "(", "name", ")", "\n", "for", "_", ",", "sheetView", ":=", "range", "xlsx", ".", "SheetViews", ".", "SheetView", "{", "if", "sheetView", ".", "TabSelected", "{", "return", "idx", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GetActiveSheetIndex", "provides", "a", "function", "to", "get", "active", "sheet", "index", "of", "the", "XLSX", ".", "If", "not", "found", "the", "active", "sheet", "will", "be", "return", "integer", "0", "." ]

[ "func", "(", "f", "*", "File", ")", "SetSheetName", "(", "oldName", ",", "newName", "string", ")", "{", "oldName", "=", "trimSheetName", "(", "oldName", ")", "\n", "newName", "=", "trimSheetName", "(", "newName", ")", "\n", "content", ":=", "f", ".", "workbookReader", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "content", ".", "Sheets", ".", "Sheet", "{", "if", "v", ".", "Name", "==", "oldName", "{", "content", ".", "Sheets", ".", "Sheet", "[", "k", "]", ".", "Name", "=", "newName", "\n", "f", ".", "sheetMap", "[", "newName", "]", "=", "f", ".", "sheetMap", "[", "oldName", "]", "\n", "delete", "(", "f", ".", "sheetMap", ",", "oldName", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "SetSheetName", "provides", "a", "function", "to", "set", "the", "worksheet", "name", "be", "given", "old", "and", "new", "worksheet", "name", ".", "Maximum", "31", "characters", "are", "allowed", "in", "sheet", "title", "and", "this", "function", "only", "changes", "the", "name", "of", "the", "sheet", "and", "will", "not", "update", "the", "sheet", "name", "in", "the", "formula", "or", "reference", "associated", "with", "the", "cell", ".", "So", "there", "may", "be", "problem", "formula", "error", "or", "reference", "missing", "." ]

[ "func", "(", "f", "*", "File", ")", "GetSheetName", "(", "index", "int", ")", "string", "{", "content", ":=", "f", ".", "workbookReader", "(", ")", "\n", "rels", ":=", "f", ".", "workbookRelsReader", "(", ")", "\n", "for", "_", ",", "rel", ":=", "range", "rels", ".", "Relationships", "{", "rID", ",", "_", ":=", "strconv", ".", "Atoi", "(", "strings", ".", "TrimSuffix", "(", "strings", ".", "TrimPrefix", "(", "rel", ".", "Target", ",", "\"", "\"", ")", ",", "\"", "\"", ")", ")", "\n", "if", "rID", "==", "index", "{", "for", "_", ",", "v", ":=", "range", "content", ".", "Sheets", ".", "Sheet", "{", "if", "v", ".", "ID", "==", "rel", ".", "ID", "{", "return", "v", ".", "Name", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "GetSheetName", "provides", "a", "function", "to", "get", "worksheet", "name", "of", "XLSX", "by", "given", "worksheet", "index", ".", "If", "given", "sheet", "index", "is", "invalid", "will", "return", "an", "empty", "string", "." ]

[ "func", "(", "f", "*", "File", ")", "getSheetMap", "(", ")", "map", "[", "string", "]", "string", "{", "maps", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "idx", ",", "name", ":=", "range", "f", ".", "GetSheetMap", "(", ")", "{", "maps", "[", "name", "]", "=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "idx", ")", "+", "\"", "\"", "\n", "}", "\n", "return", "maps", "\n", "}" ]

[ "getSheetMap", "provides", "a", "function", "to", "get", "worksheet", "name", "and", "XML", "file", "path", "map", "of", "XLSX", "." ]

[ "func", "(", "f", "*", "File", ")", "SetSheetBackground", "(", "sheet", ",", "picture", "string", ")", "error", "{", "var", "err", "error", "\n", "// Check picture exists first.", "if", "_", ",", "err", "=", "os", ".", "Stat", "(", "picture", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "ext", ",", "ok", ":=", "supportImageTypes", "[", "path", ".", "Ext", "(", "picture", ")", "]", "\n", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "file", ",", "_", ":=", "ioutil", ".", "ReadFile", "(", "picture", ")", "\n", "name", ":=", "f", ".", "addMedia", "(", "file", ",", "ext", ")", "\n", "rID", ":=", "f", ".", "addSheetRelationships", "(", "sheet", ",", "SourceRelationshipImage", ",", "strings", ".", "Replace", "(", "name", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", ",", "\"", "\"", ")", "\n", "f", ".", "addSheetPicture", "(", "sheet", ",", "rID", ")", "\n", "f", ".", "setContentTypePartImageExtensions", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "SetSheetBackground", "provides", "a", "function", "to", "set", "background", "picture", "by", "given", "worksheet", "name", "and", "file", "path", "." ]

[ "func", "(", "f", "*", "File", ")", "DeleteSheet", "(", "name", "string", ")", "{", "content", ":=", "f", ".", "workbookReader", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "content", ".", "Sheets", ".", "Sheet", "{", "if", "v", ".", "Name", "==", "trimSheetName", "(", "name", ")", "&&", "len", "(", "content", ".", "Sheets", ".", "Sheet", ")", ">", "1", "{", "content", ".", "Sheets", ".", "Sheet", "=", "append", "(", "content", ".", "Sheets", ".", "Sheet", "[", ":", "k", "]", ",", "content", ".", "Sheets", ".", "Sheet", "[", "k", "+", "1", ":", "]", "...", ")", "\n", "sheet", ":=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "v", ".", "SheetID", ")", "+", "\"", "\"", "\n", "rels", ":=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "v", ".", "SheetID", ")", "+", "\"", "\"", "\n", "target", ":=", "f", ".", "deleteSheetFromWorkbookRels", "(", "v", ".", "ID", ")", "\n", "f", ".", "deleteSheetFromContentTypes", "(", "target", ")", "\n", "f", ".", "deleteCalcChain", "(", "v", ".", "SheetID", ",", "\"", "\"", ")", "// Delete CalcChain", "\n", "delete", "(", "f", ".", "sheetMap", ",", "name", ")", "\n", "delete", "(", "f", ".", "XLSX", ",", "sheet", ")", "\n", "delete", "(", "f", ".", "XLSX", ",", "rels", ")", "\n", "delete", "(", "f", ".", "Sheet", ",", "sheet", ")", "\n", "f", ".", "SheetCount", "--", "\n", "}", "\n", "}", "\n", "f", ".", "SetActiveSheet", "(", "len", "(", "f", ".", "GetSheetMap", "(", ")", ")", ")", "\n", "}" ]

[ "DeleteSheet", "provides", "a", "function", "to", "delete", "worksheet", "in", "a", "workbook", "by", "given", "worksheet", "name", ".", "Use", "this", "method", "with", "caution", "which", "will", "affect", "changes", "in", "references", "such", "as", "formulas", "charts", "and", "so", "on", ".", "If", "there", "is", "any", "referenced", "value", "of", "the", "deleted", "worksheet", "it", "will", "cause", "a", "file", "error", "when", "you", "open", "it", ".", "This", "function", "will", "be", "invalid", "when", "only", "the", "one", "worksheet", "is", "left", "." ]

[ "func", "(", "f", "*", "File", ")", "copySheet", "(", "from", ",", "to", "int", ")", "error", "{", "sheet", ",", "err", ":=", "f", ".", "workSheetReader", "(", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "from", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "worksheet", ":=", "deepcopy", ".", "Copy", "(", "sheet", ")", ".", "(", "*", "xlsxWorksheet", ")", "\n", "path", ":=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "to", ")", "+", "\"", "\"", "\n", "if", "len", "(", "worksheet", ".", "SheetViews", ".", "SheetView", ")", ">", "0", "{", "worksheet", ".", "SheetViews", ".", "SheetView", "[", "0", "]", ".", "TabSelected", "=", "false", "\n", "}", "\n", "worksheet", ".", "Drawing", "=", "nil", "\n", "worksheet", ".", "TableParts", "=", "nil", "\n", "worksheet", ".", "PageSetUp", "=", "nil", "\n", "f", ".", "Sheet", "[", "path", "]", "=", "worksheet", "\n", "toRels", ":=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "to", ")", "+", "\"", "\"", "\n", "fromRels", ":=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "from", ")", "+", "\"", "\"", "\n", "_", ",", "ok", ":=", "f", ".", "XLSX", "[", "fromRels", "]", "\n", "if", "ok", "{", "f", ".", "XLSX", "[", "toRels", "]", "=", "f", ".", "XLSX", "[", "fromRels", "]", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "copySheet", "provides", "a", "function", "to", "duplicate", "a", "worksheet", "by", "gave", "source", "and", "target", "worksheet", "name", "." ]

[ "func", "parseFormatPanesSet", "(", "formatSet", "string", ")", "(", "*", "formatPanes", ",", "error", ")", "{", "format", ":=", "formatPanes", "{", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "formatSet", ")", ",", "&", "format", ")", "\n", "return", "&", "format", ",", "err", "\n", "}" ]

[ "parseFormatPanesSet", "provides", "a", "function", "to", "parse", "the", "panes", "settings", "." ]

[ "func", "(", "f", "*", "File", ")", "UnprotectSheet", "(", "sheet", "string", ")", "error", "{", "xlsx", ",", "err", ":=", "f", ".", "workSheetReader", "(", "sheet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "xlsx", ".", "SheetProtection", "=", "nil", "\n", "return", "err", "\n", "}" ]

[ "UnprotectSheet", "provides", "a", "function", "to", "unprotect", "an", "Excel", "worksheet", "." ]

[ "func", "trimSheetName", "(", "name", "string", ")", "string", "{", "if", "strings", ".", "ContainsAny", "(", "name", ",", "\"", "\\\\", "\"", ")", "||", "utf8", ".", "RuneCountInString", "(", "name", ")", ">", "31", "{", "r", ":=", "make", "(", "[", "]", "rune", ",", "0", ",", "31", ")", "\n", "for", "_", ",", "v", ":=", "range", "name", "{", "switch", "v", "{", "case", "58", ",", "92", ",", "47", ",", "63", ",", "42", ",", "91", ",", "93", ":", "// replace :\\/?*[]", "continue", "\n", "default", ":", "r", "=", "append", "(", "r", ",", "v", ")", "\n", "}", "\n", "if", "len", "(", "r", ")", "==", "31", "{", "break", "\n", "}", "\n", "}", "\n", "name", "=", "string", "(", "r", ")", "\n", "}", "\n", "return", "name", "\n", "}" ]

[ "trimSheetName", "provides", "a", "function", "to", "trim", "invaild", "characters", "by", "given", "worksheet", "name", "." ]

[ "func", "(", "o", "*", "PageLayoutOrientation", ")", "getPageLayout", "(", "ps", "*", "xlsxPageSetUp", ")", "{", "// Excel default: portrait", "if", "ps", "==", "nil", "||", "ps", ".", "Orientation", "==", "\"", "\"", "{", "*", "o", "=", "OrientationPortrait", "\n", "return", "\n", "}", "\n", "*", "o", "=", "PageLayoutOrientation", "(", "ps", ".", "Orientation", ")", "\n", "}" ]

[ "getPageLayout", "provides", "a", "method", "to", "get", "the", "orientation", "for", "the", "worksheet", "." ]

[ "func", "(", "p", "*", "PageLayoutPaperSize", ")", "getPageLayout", "(", "ps", "*", "xlsxPageSetUp", ")", "{", "// Excel default: 1", "if", "ps", "==", "nil", "||", "ps", ".", "PaperSize", "==", "0", "{", "*", "p", "=", "1", "\n", "return", "\n", "}", "\n", "*", "p", "=", "PageLayoutPaperSize", "(", "ps", ".", "PaperSize", ")", "\n", "}" ]

[ "getPageLayout", "provides", "a", "method", "to", "get", "the", "paper", "size", "for", "the", "worksheet", "." ]

[ "func", "prepareSheetXML", "(", "xlsx", "*", "xlsxWorksheet", ",", "col", "int", ",", "row", "int", ")", "{", "rowCount", ":=", "len", "(", "xlsx", ".", "SheetData", ".", "Row", ")", "\n", "if", "rowCount", "<", "row", "{", "// append missing rows", "for", "rowIdx", ":=", "rowCount", ";", "rowIdx", "<", "row", ";", "rowIdx", "++", "{", "xlsx", ".", "SheetData", ".", "Row", "=", "append", "(", "xlsx", ".", "SheetData", ".", "Row", ",", "xlsxRow", "{", "R", ":", "rowIdx", "+", "1", "}", ")", "\n", "}", "\n", "}", "\n", "rowData", ":=", "&", "xlsx", ".", "SheetData", ".", "Row", "[", "row", "-", "1", "]", "\n", "fillColumns", "(", "rowData", ",", "col", ",", "row", ")", "\n", "}" ]

[ "fillSheetData", "ensures", "there", "are", "enough", "rows", "and", "columns", "in", "the", "chosen", "row", "to", "accept", "data", ".", "Missing", "rows", "are", "backfilled", "and", "given", "their", "row", "number" ]

[ "func", "timeToExcelTime", "(", "t", "time", ".", "Time", ")", "(", "float64", ",", "error", ")", "{", "// TODO in future this should probably also handle date1904 and like TimeFromExcelTime", "// Force user to explicit convet passed value to UTC time.", "// Because for example 1900-01-01 00:00:00 +0300 MSK converts to 1900-01-01 00:00:00 +0230 LMT", "// probably due to daylight saving.", "if", "t", ".", "Location", "(", ")", "!=", "time", ".", "UTC", "{", "return", "0.0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "t", ".", "Before", "(", "excelMinTime1900", ")", "{", "return", "0.0", ",", "nil", "\n", "}", "\n\n", "tt", ":=", "t", "\n", "diff", ":=", "t", ".", "Sub", "(", "excelMinTime1900", ")", "\n", "result", ":=", "float64", "(", "0", ")", "\n\n", "for", "diff", ">=", "maxDuration", "{", "result", "+=", "float64", "(", "maxDuration", "/", "dayNanoseconds", ")", "\n", "tt", "=", "tt", ".", "Add", "(", "-", "maxDuration", ")", "\n", "diff", "=", "tt", ".", "Sub", "(", "excelMinTime1900", ")", "\n", "}", "\n\n", "rem", ":=", "diff", "%", "dayNanoseconds", "\n", "result", "+=", "float64", "(", "diff", "-", "rem", ")", "/", "float64", "(", "dayNanoseconds", ")", "+", "float64", "(", "rem", ")", "/", "float64", "(", "dayNanoseconds", ")", "\n\n", "// Excel dates after 28th February 1900 are actually one day out.", "// Excel behaves as though the date 29th February 1900 existed, which it didn't.", "// Microsoft intentionally included this bug in Excel so that it would remain compatible with the spreadsheet", "// program that had the majority market share at the time; Lotus 1-2-3.", "// https://www.myonlinetraininghub.com/excel-date-and-time", "if", "t", ".", "After", "(", "excelBuggyPeriodStart", ")", "{", "result", "+=", "1.0", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "timeToExcelTime", "provides", "a", "function", "to", "convert", "time", "to", "Excel", "time", "." ]

[ "func", "shiftJulianToNoon", "(", "julianDays", ",", "julianFraction", "float64", ")", "(", "float64", ",", "float64", ")", "{", "switch", "{", "case", "-", "0.5", "<", "julianFraction", "&&", "julianFraction", "<", "0.5", ":", "julianFraction", "+=", "0.5", "\n", "case", "julianFraction", ">=", "0.5", ":", "julianDays", "++", "\n", "julianFraction", "-=", "0.5", "\n", "case", "julianFraction", "<=", "-", "0.5", ":", "julianDays", "--", "\n", "julianFraction", "+=", "1.5", "\n", "}", "\n", "return", "julianDays", ",", "julianFraction", "\n", "}" ]

[ "shiftJulianToNoon", "provides", "a", "function", "to", "process", "julian", "date", "to", "noon", "." ]

[ "func", "fractionOfADay", "(", "fraction", "float64", ")", "(", "hours", ",", "minutes", ",", "seconds", ",", "nanoseconds", "int", ")", "{", "const", "(", "c1us", "=", "1e3", "\n", "c1s", "=", "1e9", "\n", "c1day", "=", "24", "*", "60", "*", "60", "*", "c1s", "\n", ")", "\n\n", "frac", ":=", "int64", "(", "c1day", "*", "fraction", "+", "c1us", "/", "2", ")", "\n", "nanoseconds", "=", "int", "(", "(", "frac", "%", "c1s", ")", "/", "c1us", ")", "*", "c1us", "\n", "frac", "/=", "c1s", "\n", "seconds", "=", "int", "(", "frac", "%", "60", ")", "\n", "frac", "/=", "60", "\n", "minutes", "=", "int", "(", "frac", "%", "60", ")", "\n", "hours", "=", "int", "(", "frac", "/", "60", ")", "\n", "return", "\n", "}" ]

[ "fractionOfADay", "provides", "a", "function", "to", "return", "the", "integer", "values", "for", "hour", "minutes", "seconds", "and", "nanoseconds", "that", "comprised", "a", "given", "fraction", "of", "a", "day", ".", "values", "would", "round", "to", "1", "us", "." ]

[ "func", "(", "rows", "*", "Rows", ")", "Next", "(", ")", "bool", "{", "for", "{", "rows", ".", "token", ",", "rows", ".", "err", "=", "rows", ".", "decoder", ".", "Token", "(", ")", "\n", "if", "rows", ".", "err", "==", "io", ".", "EOF", "{", "rows", ".", "err", "=", "nil", "\n", "}", "\n", "if", "rows", ".", "token", "==", "nil", "{", "return", "false", "\n", "}", "\n\n", "switch", "startElement", ":=", "rows", ".", "token", ".", "(", "type", ")", "{", "case", "xml", ".", "StartElement", ":", "inElement", ":=", "startElement", ".", "Name", ".", "Local", "\n", "if", "inElement", "==", "\"", "\"", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Next", "will", "return", "true", "if", "find", "the", "next", "row", "element", "." ]

[ "func", "(", "rows", "*", "Rows", ")", "Columns", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "rows", ".", "token", "==", "nil", "{", "return", "[", "]", "string", "{", "}", ",", "nil", "\n", "}", "\n", "startElement", ":=", "rows", ".", "token", ".", "(", "xml", ".", "StartElement", ")", "\n", "r", ":=", "xlsxRow", "{", "}", "\n", "_", "=", "rows", ".", "decoder", ".", "DecodeElement", "(", "&", "r", ",", "&", "startElement", ")", "\n", "d", ":=", "rows", ".", "f", ".", "sharedStringsReader", "(", ")", "\n", "columns", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "r", ".", "C", ")", ")", "\n", "for", "_", ",", "colCell", ":=", "range", "r", ".", "C", "{", "col", ",", "_", ",", "err", ":=", "CellNameToCoordinates", "(", "colCell", ".", "R", ")", "\n", "if", "err", "!=", "nil", "{", "return", "columns", ",", "err", "\n", "}", "\n", "val", ",", "_", ":=", "colCell", ".", "getValueFrom", "(", "rows", ".", "f", ",", "d", ")", "\n", "columns", "[", "col", "-", "1", "]", "=", "val", "\n", "}", "\n", "return", "columns", ",", "nil", "\n", "}" ]

[ "Columns", "return", "the", "current", "row", "s", "column", "values" ]

[ "func", "(", "f", "*", "File", ")", "getTotalRowsCols", "(", "name", "string", ")", "(", "int", ",", "int", ",", "error", ")", "{", "decoder", ":=", "xml", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "f", ".", "readXML", "(", "name", ")", ")", ")", "\n", "var", "inElement", "string", "\n", "var", "r", "xlsxRow", "\n", "var", "tr", ",", "tc", "int", "\n", "for", "{", "token", ",", "_", ":=", "decoder", ".", "Token", "(", ")", "\n", "if", "token", "==", "nil", "{", "break", "\n", "}", "\n", "switch", "startElement", ":=", "token", ".", "(", "type", ")", "{", "case", "xml", ".", "StartElement", ":", "inElement", "=", "startElement", ".", "Name", ".", "Local", "\n", "if", "inElement", "==", "\"", "\"", "{", "r", "=", "xlsxRow", "{", "}", "\n", "_", "=", "decoder", ".", "DecodeElement", "(", "&", "r", ",", "&", "startElement", ")", "\n", "tr", "=", "r", ".", "R", "\n", "for", "_", ",", "colCell", ":=", "range", "r", ".", "C", "{", "col", ",", "_", ",", "err", ":=", "CellNameToCoordinates", "(", "colCell", ".", "R", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tr", ",", "tc", ",", "err", "\n", "}", "\n", "if", "col", ">", "tc", "{", "tc", "=", "col", "\n", "}", "\n", "}", "\n", "}", "\n", "default", ":", "}", "\n", "}", "\n", "return", "tr", ",", "tc", ",", "nil", "\n", "}" ]

[ "getTotalRowsCols", "provides", "a", "function", "to", "get", "total", "columns", "and", "rows", "in", "a", "worksheet", "." ]

[ "func", "(", "f", "*", "File", ")", "getRowHeight", "(", "sheet", "string", ",", "row", "int", ")", "int", "{", "xlsx", ",", "_", ":=", "f", ".", "workSheetReader", "(", "sheet", ")", "\n", "for", "_", ",", "v", ":=", "range", "xlsx", ".", "SheetData", ".", "Row", "{", "if", "v", ".", "R", "==", "row", "+", "1", "&&", "v", ".", "Ht", "!=", "0", "{", "return", "int", "(", "convertRowHeightToPixels", "(", "v", ".", "Ht", ")", ")", "\n", "}", "\n", "}", "\n", "// Optimisation for when the row heights haven't changed.", "return", "int", "(", "defaultRowHeightPixels", ")", "\n", "}" ]

[ "getRowHeight", "provides", "a", "function", "to", "get", "row", "height", "in", "pixels", "by", "given", "sheet", "name", "and", "row", "index", "." ]

[ "func", "convertRowHeightToPixels", "(", "height", "float64", ")", "float64", "{", "var", "pixels", "float64", "\n", "if", "height", "==", "0", "{", "return", "pixels", "\n", "}", "\n", "pixels", "=", "math", ".", "Ceil", "(", "4.0", "/", "3.0", "*", "height", ")", "\n", "return", "pixels", "\n", "}" ]

[ "convertRowHeightToPixels", "provides", "a", "function", "to", "convert", "the", "height", "of", "a", "cell", "from", "user", "s", "units", "to", "pixels", ".", "If", "the", "height", "hasn", "t", "been", "set", "by", "the", "user", "we", "use", "the", "default", "value", ".", "If", "the", "row", "is", "hidden", "it", "has", "a", "value", "of", "zero", "." ]

[ "func", "parseFormatChartSet", "(", "formatSet", "string", ")", "(", "*", "formatChart", ",", "error", ")", "{", "format", ":=", "formatChart", "{", "Dimension", ":", "formatChartDimension", "{", "Width", ":", "480", ",", "Height", ":", "290", ",", "}", ",", "Format", ":", "formatPicture", "{", "FPrintsWithSheet", ":", "true", ",", "FLocksWithSheet", ":", "false", ",", "NoChangeAspect", ":", "false", ",", "OffsetX", ":", "0", ",", "OffsetY", ":", "0", ",", "XScale", ":", "1.0", ",", "YScale", ":", "1.0", ",", "}", ",", "Legend", ":", "formatChartLegend", "{", "Position", ":", "\"", "\"", ",", "ShowLegendKey", ":", "false", ",", "}", ",", "Title", ":", "formatChartTitle", "{", "Name", ":", "\"", "\"", ",", "}", ",", "ShowBlanksAs", ":", "\"", "\"", ",", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "formatSet", ")", ",", "&", "format", ")", "\n", "return", "&", "format", ",", "err", "\n", "}" ]

[ "parseFormatChartSet", "provides", "a", "function", "to", "parse", "the", "format", "settings", "of", "the", "chart", "with", "default", "value", "." ]

[ "func", "(", "f", "*", "File", ")", "prepareDrawing", "(", "xlsx", "*", "xlsxWorksheet", ",", "drawingID", "int", ",", "sheet", ",", "drawingXML", "string", ")", "(", "int", ",", "string", ")", "{", "sheetRelationshipsDrawingXML", ":=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "drawingID", ")", "+", "\"", "\"", "\n", "if", "xlsx", ".", "Drawing", "!=", "nil", "{", "// The worksheet already has a picture or chart relationships, use the relationships drawing ../drawings/drawing%d.xml.", "sheetRelationshipsDrawingXML", "=", "f", ".", "getSheetRelationshipsTargetByID", "(", "sheet", ",", "xlsx", ".", "Drawing", ".", "RID", ")", "\n", "drawingID", ",", "_", "=", "strconv", ".", "Atoi", "(", "strings", ".", "TrimSuffix", "(", "strings", ".", "TrimPrefix", "(", "sheetRelationshipsDrawingXML", ",", "\"", "\"", ")", ",", "\"", "\"", ")", ")", "\n", "drawingXML", "=", "strings", ".", "Replace", "(", "sheetRelationshipsDrawingXML", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "}", "else", "{", "// Add first picture for given sheet.", "rID", ":=", "f", ".", "addSheetRelationships", "(", "sheet", ",", "SourceRelationshipDrawingML", ",", "sheetRelationshipsDrawingXML", ",", "\"", "\"", ")", "\n", "f", ".", "addSheetDrawing", "(", "sheet", ",", "rID", ")", "\n", "}", "\n", "return", "drawingID", ",", "drawingXML", "\n", "}" ]

[ "prepareDrawing", "provides", "a", "function", "to", "prepare", "drawing", "ID", "and", "XML", "by", "given", "drawingID", "worksheet", "name", "and", "default", "drawingXML", "." ]

[ "func", "(", "f", "*", "File", ")", "addDrawingChart", "(", "sheet", ",", "drawingXML", ",", "cell", "string", ",", "width", ",", "height", ",", "rID", "int", ",", "formatSet", "*", "formatPicture", ")", "error", "{", "col", ",", "row", ",", "err", ":=", "CellNameToCoordinates", "(", "cell", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "colIdx", ":=", "col", "-", "1", "\n", "rowIdx", ":=", "row", "-", "1", "\n\n", "width", "=", "int", "(", "float64", "(", "width", ")", "*", "formatSet", ".", "XScale", ")", "\n", "height", "=", "int", "(", "float64", "(", "height", ")", "*", "formatSet", ".", "YScale", ")", "\n", "colStart", ",", "rowStart", ",", "_", ",", "_", ",", "colEnd", ",", "rowEnd", ",", "x2", ",", "y2", ":=", "f", ".", "positionObjectPixels", "(", "sheet", ",", "colIdx", ",", "rowIdx", ",", "formatSet", ".", "OffsetX", ",", "formatSet", ".", "OffsetY", ",", "width", ",", "height", ")", "\n", "content", ",", "cNvPrID", ":=", "f", ".", "drawingParser", "(", "drawingXML", ")", "\n", "twoCellAnchor", ":=", "xdrCellAnchor", "{", "}", "\n", "twoCellAnchor", ".", "EditAs", "=", "formatSet", ".", "Positioning", "\n", "from", ":=", "xlsxFrom", "{", "}", "\n", "from", ".", "Col", "=", "colStart", "\n", "from", ".", "ColOff", "=", "formatSet", ".", "OffsetX", "*", "EMU", "\n", "from", ".", "Row", "=", "rowStart", "\n", "from", ".", "RowOff", "=", "formatSet", ".", "OffsetY", "*", "EMU", "\n", "to", ":=", "xlsxTo", "{", "}", "\n", "to", ".", "Col", "=", "colEnd", "\n", "to", ".", "ColOff", "=", "x2", "*", "EMU", "\n", "to", ".", "Row", "=", "rowEnd", "\n", "to", ".", "RowOff", "=", "y2", "*", "EMU", "\n", "twoCellAnchor", ".", "From", "=", "&", "from", "\n", "twoCellAnchor", ".", "To", "=", "&", "to", "\n\n", "graphicFrame", ":=", "xlsxGraphicFrame", "{", "NvGraphicFramePr", ":", "xlsxNvGraphicFramePr", "{", "CNvPr", ":", "&", "xlsxCNvPr", "{", "ID", ":", "f", ".", "countCharts", "(", ")", "+", "f", ".", "countMedia", "(", ")", "+", "1", ",", "Name", ":", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "cNvPrID", ")", ",", "}", ",", "}", ",", "Graphic", ":", "&", "xlsxGraphic", "{", "GraphicData", ":", "&", "xlsxGraphicData", "{", "URI", ":", "NameSpaceDrawingMLChart", ",", "Chart", ":", "&", "xlsxChart", "{", "C", ":", "NameSpaceDrawingMLChart", ",", "R", ":", "SourceRelationship", ",", "RID", ":", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "rID", ")", ",", "}", ",", "}", ",", "}", ",", "}", "\n", "graphic", ",", "_", ":=", "xml", ".", "Marshal", "(", "graphicFrame", ")", "\n", "twoCellAnchor", ".", "GraphicFrame", "=", "string", "(", "graphic", ")", "\n", "twoCellAnchor", ".", "ClientData", "=", "&", "xdrClientData", "{", "FLocksWithSheet", ":", "formatSet", ".", "FLocksWithSheet", ",", "FPrintsWithSheet", ":", "formatSet", ".", "FPrintsWithSheet", ",", "}", "\n", "content", ".", "TwoCellAnchor", "=", "append", "(", "content", ".", "TwoCellAnchor", ",", "&", "twoCellAnchor", ")", "\n", "f", ".", "Drawings", "[", "drawingXML", "]", "=", "content", "\n", "return", "err", "\n", "}" ]

[ "addDrawingChart", "provides", "a", "function", "to", "add", "chart", "graphic", "frame", "by", "given", "sheet", "drawingXML", "cell", "width", "height", "relationship", "index", "and", "format", "sets", "." ]

[ "func", "NewCachedEnforcer", "(", "params", "...", "interface", "{", "}", ")", "*", "CachedEnforcer", "{", "e", ":=", "&", "CachedEnforcer", "{", "}", "\n", "e", ".", "Enforcer", "=", "NewEnforcer", "(", "params", "...", ")", "\n", "e", ".", "enableCache", "=", "true", "\n", "e", ".", "m", "=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "e", ".", "locker", "=", "new", "(", "sync", ".", "Mutex", ")", "\n", "return", "e", "\n", "}" ]

[ "NewCachedEnforcer", "creates", "a", "cached", "enforcer", "via", "file", "or", "DB", "." ]

[ "func", "KeyMatchFunc", "(", "args", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "name1", ":=", "args", "[", "0", "]", ".", "(", "string", ")", "\n", "name2", ":=", "args", "[", "1", "]", ".", "(", "string", ")", "\n\n", "return", "bool", "(", "KeyMatch", "(", "name1", ",", "name2", ")", ")", ",", "nil", "\n", "}" ]

[ "KeyMatchFunc", "is", "the", "wrapper", "for", "KeyMatch", "." ]

[ "func", "KeyMatch2Func", "(", "args", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "name1", ":=", "args", "[", "0", "]", ".", "(", "string", ")", "\n", "name2", ":=", "args", "[", "1", "]", ".", "(", "string", ")", "\n\n", "return", "bool", "(", "KeyMatch2", "(", "name1", ",", "name2", ")", ")", ",", "nil", "\n", "}" ]

[ "KeyMatch2Func", "is", "the", "wrapper", "for", "KeyMatch2", "." ]

[ "func", "KeyMatch3Func", "(", "args", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "name1", ":=", "args", "[", "0", "]", ".", "(", "string", ")", "\n", "name2", ":=", "args", "[", "1", "]", ".", "(", "string", ")", "\n\n", "return", "bool", "(", "KeyMatch3", "(", "name1", ",", "name2", ")", ")", ",", "nil", "\n", "}" ]

[ "KeyMatch3Func", "is", "the", "wrapper", "for", "KeyMatch3", "." ]

[ "func", "RegexMatch", "(", "key1", "string", ",", "key2", "string", ")", "bool", "{", "res", ",", "err", ":=", "regexp", ".", "MatchString", "(", "key2", ",", "key1", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "RegexMatch", "determines", "whether", "key1", "matches", "the", "pattern", "of", "key2", "in", "regular", "expression", "." ]

[ "func", "RegexMatchFunc", "(", "args", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "name1", ":=", "args", "[", "0", "]", ".", "(", "string", ")", "\n", "name2", ":=", "args", "[", "1", "]", ".", "(", "string", ")", "\n\n", "return", "bool", "(", "RegexMatch", "(", "name1", ",", "name2", ")", ")", ",", "nil", "\n", "}" ]

[ "RegexMatchFunc", "is", "the", "wrapper", "for", "RegexMatch", "." ]

[ "func", "IPMatchFunc", "(", "args", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "ip1", ":=", "args", "[", "0", "]", ".", "(", "string", ")", "\n", "ip2", ":=", "args", "[", "1", "]", ".", "(", "string", ")", "\n\n", "return", "bool", "(", "IPMatch", "(", "ip1", ",", "ip2", ")", ")", ",", "nil", "\n", "}" ]

[ "IPMatchFunc", "is", "the", "wrapper", "for", "IPMatch", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetAllNamedSubjects", "(", "ptype", "string", ")", "[", "]", "string", "{", "return", "e", ".", "model", ".", "GetValuesForFieldInPolicy", "(", "\"", "\"", ",", "ptype", ",", "0", ")", "\n", "}" ]

[ "GetAllNamedSubjects", "gets", "the", "list", "of", "subjects", "that", "show", "up", "in", "the", "current", "named", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetAllNamedObjects", "(", "ptype", "string", ")", "[", "]", "string", "{", "return", "e", ".", "model", ".", "GetValuesForFieldInPolicy", "(", "\"", "\"", ",", "ptype", ",", "1", ")", "\n", "}" ]

[ "GetAllNamedObjects", "gets", "the", "list", "of", "objects", "that", "show", "up", "in", "the", "current", "named", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetAllNamedActions", "(", "ptype", "string", ")", "[", "]", "string", "{", "return", "e", ".", "model", ".", "GetValuesForFieldInPolicy", "(", "\"", "\"", ",", "ptype", ",", "2", ")", "\n", "}" ]

[ "GetAllNamedActions", "gets", "the", "list", "of", "actions", "that", "show", "up", "in", "the", "current", "named", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetAllNamedRoles", "(", "ptype", "string", ")", "[", "]", "string", "{", "return", "e", ".", "model", ".", "GetValuesForFieldInPolicy", "(", "\"", "\"", ",", "ptype", ",", "1", ")", "\n", "}" ]

[ "GetAllNamedRoles", "gets", "the", "list", "of", "roles", "that", "show", "up", "in", "the", "current", "named", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetNamedPolicy", "(", "ptype", "string", ")", "[", "]", "[", "]", "string", "{", "return", "e", ".", "model", ".", "GetPolicy", "(", "\"", "\"", ",", "ptype", ")", "\n", "}" ]

[ "GetNamedPolicy", "gets", "all", "the", "authorization", "rules", "in", "the", "named", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetFilteredNamedPolicy", "(", "ptype", "string", ",", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "[", "]", "[", "]", "string", "{", "return", "e", ".", "model", ".", "GetFilteredPolicy", "(", "\"", "\"", ",", "ptype", ",", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "}" ]

[ "GetFilteredNamedPolicy", "gets", "all", "the", "authorization", "rules", "in", "the", "named", "policy", "field", "filters", "can", "be", "specified", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetFilteredGroupingPolicy", "(", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "[", "]", "[", "]", "string", "{", "return", "e", ".", "GetFilteredNamedGroupingPolicy", "(", "\"", "\"", ",", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "}" ]

[ "GetFilteredGroupingPolicy", "gets", "all", "the", "role", "inheritance", "rules", "in", "the", "policy", "field", "filters", "can", "be", "specified", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetNamedGroupingPolicy", "(", "ptype", "string", ")", "[", "]", "[", "]", "string", "{", "return", "e", ".", "model", ".", "GetPolicy", "(", "\"", "\"", ",", "ptype", ")", "\n", "}" ]

[ "GetNamedGroupingPolicy", "gets", "all", "the", "role", "inheritance", "rules", "in", "the", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveNamedPolicy", "(", "ptype", "string", ",", "params", "...", "interface", "{", "}", ")", "bool", "{", "var", "ruleRemoved", "bool", "\n", "if", "strSlice", ",", "ok", ":=", "params", "[", "0", "]", ".", "(", "[", "]", "string", ")", ";", "len", "(", "params", ")", "==", "1", "&&", "ok", "{", "ruleRemoved", "=", "e", ".", "removePolicy", "(", "\"", "\"", ",", "ptype", ",", "strSlice", ")", "\n", "}", "else", "{", "policy", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "param", ":=", "range", "params", "{", "policy", "=", "append", "(", "policy", ",", "param", ".", "(", "string", ")", ")", "\n", "}", "\n\n", "ruleRemoved", "=", "e", ".", "removePolicy", "(", "\"", "\"", ",", "ptype", ",", "policy", ")", "\n", "}", "\n\n", "return", "ruleRemoved", "\n", "}" ]

[ "RemoveNamedPolicy", "removes", "an", "authorization", "rule", "from", "the", "current", "named", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveFilteredNamedPolicy", "(", "ptype", "string", ",", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "bool", "{", "return", "e", ".", "removeFilteredPolicy", "(", "\"", "\"", ",", "ptype", ",", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "}" ]

[ "RemoveFilteredNamedPolicy", "removes", "an", "authorization", "rule", "from", "the", "current", "named", "policy", "field", "filters", "can", "be", "specified", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "HasNamedGroupingPolicy", "(", "ptype", "string", ",", "params", "...", "interface", "{", "}", ")", "bool", "{", "if", "strSlice", ",", "ok", ":=", "params", "[", "0", "]", ".", "(", "[", "]", "string", ")", ";", "len", "(", "params", ")", "==", "1", "&&", "ok", "{", "return", "e", ".", "model", ".", "HasPolicy", "(", "\"", "\"", ",", "ptype", ",", "strSlice", ")", "\n", "}", "\n\n", "policy", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "param", ":=", "range", "params", "{", "policy", "=", "append", "(", "policy", ",", "param", ".", "(", "string", ")", ")", "\n", "}", "\n\n", "return", "e", ".", "model", ".", "HasPolicy", "(", "\"", "\"", ",", "ptype", ",", "policy", ")", "\n", "}" ]

[ "HasNamedGroupingPolicy", "determines", "whether", "a", "named", "role", "inheritance", "rule", "exists", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "AddNamedGroupingPolicy", "(", "ptype", "string", ",", "params", "...", "interface", "{", "}", ")", "bool", "{", "var", "ruleAdded", "bool", "\n", "if", "strSlice", ",", "ok", ":=", "params", "[", "0", "]", ".", "(", "[", "]", "string", ")", ";", "len", "(", "params", ")", "==", "1", "&&", "ok", "{", "ruleAdded", "=", "e", ".", "addPolicy", "(", "\"", "\"", ",", "ptype", ",", "strSlice", ")", "\n", "}", "else", "{", "policy", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "param", ":=", "range", "params", "{", "policy", "=", "append", "(", "policy", ",", "param", ".", "(", "string", ")", ")", "\n", "}", "\n\n", "ruleAdded", "=", "e", ".", "addPolicy", "(", "\"", "\"", ",", "ptype", ",", "policy", ")", "\n", "}", "\n\n", "if", "e", ".", "autoBuildRoleLinks", "{", "e", ".", "BuildRoleLinks", "(", ")", "\n", "}", "\n", "return", "ruleAdded", "\n", "}" ]

[ "AddNamedGroupingPolicy", "adds", "a", "named", "role", "inheritance", "rule", "to", "the", "current", "policy", ".", "If", "the", "rule", "already", "exists", "the", "function", "returns", "false", "and", "the", "rule", "will", "not", "be", "added", ".", "Otherwise", "the", "function", "returns", "true", "by", "adding", "the", "new", "rule", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveFilteredGroupingPolicy", "(", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "bool", "{", "return", "e", ".", "RemoveFilteredNamedGroupingPolicy", "(", "\"", "\"", ",", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "}" ]

[ "RemoveFilteredGroupingPolicy", "removes", "a", "role", "inheritance", "rule", "from", "the", "current", "policy", "field", "filters", "can", "be", "specified", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveFilteredNamedGroupingPolicy", "(", "ptype", "string", ",", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "bool", "{", "ruleRemoved", ":=", "e", ".", "removeFilteredPolicy", "(", "\"", "\"", ",", "ptype", ",", "fieldIndex", ",", "fieldValues", "...", ")", "\n\n", "if", "e", ".", "autoBuildRoleLinks", "{", "e", ".", "BuildRoleLinks", "(", ")", "\n", "}", "\n", "return", "ruleRemoved", "\n", "}" ]

[ "RemoveFilteredNamedGroupingPolicy", "removes", "a", "role", "inheritance", "rule", "from", "the", "current", "named", "policy", "field", "filters", "can", "be", "specified", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "AddFunction", "(", "name", "string", ",", "function", "func", "(", "args", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", ")", "{", "e", ".", "fm", ".", "AddFunction", "(", "name", ",", "function", ")", "\n", "}" ]

[ "AddFunction", "adds", "a", "customized", "function", "." ]

[ "func", "NewSyncedEnforcer", "(", "params", "...", "interface", "{", "}", ")", "*", "SyncedEnforcer", "{", "e", ":=", "&", "SyncedEnforcer", "{", "}", "\n", "e", ".", "Enforcer", "=", "NewEnforcer", "(", "params", "...", ")", "\n", "e", ".", "autoLoad", "=", "false", "\n", "return", "e", "\n", "}" ]

[ "NewSyncedEnforcer", "creates", "a", "synchronized", "enforcer", "via", "file", "or", "DB", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "StartAutoLoadPolicy", "(", "d", "time", ".", "Duration", ")", "{", "e", ".", "autoLoad", "=", "true", "\n", "go", "func", "(", ")", "{", "n", ":=", "1", "\n", "log", ".", "Print", "(", "\"", "\"", ")", "\n", "for", "{", "if", "!", "e", ".", "autoLoad", "{", "log", ".", "Print", "(", "\"", "\"", ")", "\n", "break", "\n", "}", "\n\n", "// error intentionally ignored", "e", ".", "LoadPolicy", "(", ")", "\n", "// Uncomment this line to see when the policy is loaded.", "// log.Print(\"Load policy for time: \", n)", "n", "++", "\n", "time", ".", "Sleep", "(", "d", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "StartAutoLoadPolicy", "starts", "a", "go", "routine", "that", "will", "every", "specified", "duration", "call", "LoadPolicy" ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "SetWatcher", "(", "watcher", "persist", ".", "Watcher", ")", "{", "e", ".", "watcher", "=", "watcher", "\n", "// error intentionally ignored", "watcher", ".", "SetUpdateCallback", "(", "func", "(", "string", ")", "{", "e", ".", "LoadPolicy", "(", ")", "}", ")", "\n", "}" ]

[ "SetWatcher", "sets", "the", "current", "watcher", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "ClearPolicy", "(", ")", "{", "e", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "m", ".", "Unlock", "(", ")", "\n", "e", ".", "Enforcer", ".", "ClearPolicy", "(", ")", "\n", "}" ]

[ "ClearPolicy", "clears", "all", "policy", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetAllSubjects", "(", ")", "[", "]", "string", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetAllSubjects", "(", ")", "\n", "}" ]

[ "GetAllSubjects", "gets", "the", "list", "of", "subjects", "that", "show", "up", "in", "the", "current", "policy", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetAllObjects", "(", ")", "[", "]", "string", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetAllObjects", "(", ")", "\n", "}" ]

[ "GetAllObjects", "gets", "the", "list", "of", "objects", "that", "show", "up", "in", "the", "current", "policy", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetAllActions", "(", ")", "[", "]", "string", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetAllActions", "(", ")", "\n", "}" ]

[ "GetAllActions", "gets", "the", "list", "of", "actions", "that", "show", "up", "in", "the", "current", "policy", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetAllRoles", "(", ")", "[", "]", "string", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetAllRoles", "(", ")", "\n", "}" ]

[ "GetAllRoles", "gets", "the", "list", "of", "roles", "that", "show", "up", "in", "the", "current", "policy", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetPolicy", "(", ")", "[", "]", "[", "]", "string", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetPolicy", "(", ")", "\n", "}" ]

[ "GetPolicy", "gets", "all", "the", "authorization", "rules", "in", "the", "policy", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetFilteredPolicy", "(", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "[", "]", "[", "]", "string", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetFilteredPolicy", "(", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "}" ]

[ "GetFilteredPolicy", "gets", "all", "the", "authorization", "rules", "in", "the", "policy", "field", "filters", "can", "be", "specified", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetGroupingPolicy", "(", ")", "[", "]", "[", "]", "string", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetGroupingPolicy", "(", ")", "\n", "}" ]

[ "GetGroupingPolicy", "gets", "all", "the", "role", "inheritance", "rules", "in", "the", "policy", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "AddPolicy", "(", "params", "...", "interface", "{", "}", ")", "bool", "{", "e", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "m", ".", "Unlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "AddPolicy", "(", "params", "...", ")", "\n", "}" ]

[ "AddPolicy", "adds", "an", "authorization", "rule", "to", "the", "current", "policy", ".", "If", "the", "rule", "already", "exists", "the", "function", "returns", "false", "and", "the", "rule", "will", "not", "be", "added", ".", "Otherwise", "the", "function", "returns", "true", "by", "adding", "the", "new", "rule", "." ]