Datasets:

---

qiaoruiyt

/

csn

like 0

[ "func", "(", "a", "AptLayerAnalyzer", ")", "Diff", "(", "image1", ",", "image2", "pkgutil", ".", "Image", ")", "(", "util", ".", "Result", ",", "error", ")", "{", "diff", ",", "err", ":=", "singleVersionLayerDiff", "(", "image1", ",", "image2", ",", "a", ")", "\n", "return", "diff", ",", "err", "\n", "}" ]

[ "AptDiff", "compares", "the", "packages", "installed", "by", "apt", "-", "get", "." ]

[ "func", "(", "a", "SizeAnalyzer", ")", "Diff", "(", "image1", ",", "image2", "pkgutil", ".", "Image", ")", "(", "util", ".", "Result", ",", "error", ")", "{", "diff", ":=", "[", "]", "util", ".", "SizeDiff", "{", "}", "\n", "size1", ":=", "pkgutil", ".", "GetSize", "(", "image1", ".", "FSPath", ")", "\n", "size2", ":=", "pkgutil", ".", "GetSize", "(", "image2", ".", "FSPath", ")", "\n\n", "if", "size1", "!=", "size2", "{", "diff", "=", "append", "(", "diff", ",", "util", ".", "SizeDiff", "{", "Size1", ":", "size1", ",", "Size2", ":", "size2", ",", "}", ")", "\n", "}", "\n\n", "return", "&", "util", ".", "SizeDiffResult", "{", "Image1", ":", "image1", ".", "Source", ",", "Image2", ":", "image2", ".", "Source", ",", "DiffType", ":", "\"", "\"", ",", "Diff", ":", "diff", ",", "}", ",", "nil", "\n", "}" ]

[ "SizeDiff", "diffs", "two", "images", "and", "compares", "their", "size" ]

[ "func", "(", "a", "SizeLayerAnalyzer", ")", "Diff", "(", "image1", ",", "image2", "pkgutil", ".", "Image", ")", "(", "util", ".", "Result", ",", "error", ")", "{", "var", "layerDiffs", "[", "]", "util", ".", "SizeDiff", "\n\n", "maxLayer", ":=", "len", "(", "image1", ".", "Layers", ")", "\n", "if", "len", "(", "image2", ".", "Layers", ")", ">", "maxLayer", "{", "maxLayer", "=", "len", "(", "image2", ".", "Layers", ")", "\n", "}", "\n\n", "for", "index", ":=", "0", ";", "index", "<", "maxLayer", ";", "index", "++", "{", "var", "size1", ",", "size2", "int64", "=", "-", "1", ",", "-", "1", "\n", "if", "index", "<", "len", "(", "image1", ".", "Layers", ")", "{", "size1", "=", "pkgutil", ".", "GetSize", "(", "image1", ".", "Layers", "[", "index", "]", ".", "FSPath", ")", "\n", "}", "\n", "if", "index", "<", "len", "(", "image2", ".", "Layers", ")", "{", "size2", "=", "pkgutil", ".", "GetSize", "(", "image2", ".", "Layers", "[", "index", "]", ".", "FSPath", ")", "\n", "}", "\n\n", "if", "size1", "!=", "size2", "{", "diff", ":=", "util", ".", "SizeDiff", "{", "Name", ":", "strconv", ".", "Itoa", "(", "index", ")", ",", "Size1", ":", "size1", ",", "Size2", ":", "size2", ",", "}", "\n", "layerDiffs", "=", "append", "(", "layerDiffs", ",", "diff", ")", "\n", "}", "\n", "}", "\n\n", "return", "&", "util", ".", "SizeLayerDiffResult", "{", "Image1", ":", "image1", ".", "Source", ",", "Image2", ":", "image2", ".", "Source", ",", "DiffType", ":", "\"", "\"", ",", "Diff", ":", "layerDiffs", ",", "}", ",", "nil", "\n", "}" ]

[ "SizeLayerDiff", "diffs", "the", "layers", "of", "two", "images", "and", "compares", "their", "size" ]

[ "func", "StructMapToStringMap", "(", "m", "map", "[", "string", "]", "struct", "{", "}", ")", "map", "[", "string", "]", "string", "{", "newMap", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "k", ":=", "range", "m", "{", "newMap", "[", "k", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "m", "[", "k", "]", ")", "\n", "}", "\n", "return", "newMap", "\n", "}" ]

[ "StructMapToStringMap", "converts", "map", "[", "string", "]", "struct", "{}", "to", "map", "[", "string", "]", "string", "knowing", "that", "the", "struct", "in", "the", "value", "is", "always", "empty" ]

[ "func", "(", "a", "FileAnalyzer", ")", "Diff", "(", "image1", ",", "image2", "pkgutil", ".", "Image", ")", "(", "util", ".", "Result", ",", "error", ")", "{", "diff", ",", "err", ":=", "diffImageFiles", "(", "image1", ".", "FSPath", ",", "image2", ".", "FSPath", ")", "\n", "return", "&", "util", ".", "DirDiffResult", "{", "Image1", ":", "image1", ".", "Source", ",", "Image2", ":", "image2", ".", "Source", ",", "DiffType", ":", "\"", "\"", ",", "Diff", ":", "diff", ",", "}", ",", "err", "\n", "}" ]

[ "FileDiff", "diffs", "two", "packages", "and", "compares", "their", "contents" ]

[ "func", "(", "a", "FileLayerAnalyzer", ")", "Diff", "(", "image1", ",", "image2", "pkgutil", ".", "Image", ")", "(", "util", ".", "Result", ",", "error", ")", "{", "var", "dirDiffs", "[", "]", "util", ".", "DirDiff", "\n\n", "// Go through each layer of the first image...", "for", "index", ",", "layer", ":=", "range", "image1", ".", "Layers", "{", "if", "index", ">=", "len", "(", "image2", ".", "Layers", ")", "{", "continue", "\n", "}", "\n", "// ...else, diff as usual", "layer2", ":=", "image2", ".", "Layers", "[", "index", "]", "\n", "diff", ",", "err", ":=", "diffImageFiles", "(", "layer", ".", "FSPath", ",", "layer2", ".", "FSPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "util", ".", "MultipleDirDiffResult", "{", "}", ",", "err", "\n", "}", "\n", "dirDiffs", "=", "append", "(", "dirDiffs", ",", "diff", ")", "\n", "}", "\n\n", "// check if there are any additional layers in either image", "if", "len", "(", "image1", ".", "Layers", ")", "!=", "len", "(", "image2", ".", "Layers", ")", "{", "if", "len", "(", "image1", ".", "Layers", ")", ">", "len", "(", "image2", ".", "Layers", ")", "{", "logrus", ".", "Infof", "(", "\"", "\"", ",", "image1", ".", "Source", ")", "\n", "}", "else", "{", "logrus", ".", "Infof", "(", "\"", "\"", ",", "image2", ".", "Source", ")", "\n", "}", "\n", "}", "\n", "return", "&", "util", ".", "MultipleDirDiffResult", "{", "Image1", ":", "image1", ".", "Source", ",", "Image2", ":", "image2", ".", "Source", ",", "DiffType", ":", "\"", "\"", ",", "Diff", ":", "util", ".", "MultipleDirDiff", "{", "DirDiffs", ":", "dirDiffs", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "FileDiff", "diffs", "two", "packages", "and", "compares", "their", "contents" ]

[ "func", "singleVersionLayerDiff", "(", "image1", ",", "image2", "pkgutil", ".", "Image", ",", "differ", "SingleVersionPackageLayerAnalyzer", ")", "(", "*", "util", ".", "SingleVersionPackageLayerDiffResult", ",", "error", ")", "{", "logrus", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "&", "util", ".", "SingleVersionPackageLayerDiffResult", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "singleVersionLayerDiff", "returns", "an", "error", "as", "this", "diff", "is", "not", "supported", "as", "it", "is", "far", "from", "obvious", "to", "define", "it", "in", "meaningful", "way" ]

[ "func", "singleVersionLayerAnalysis", "(", "image", "pkgutil", ".", "Image", ",", "analyzer", "SingleVersionPackageLayerAnalyzer", ")", "(", "*", "util", ".", "SingleVersionPackageLayerAnalyzeResult", ",", "error", ")", "{", "pack", ",", "err", ":=", "analyzer", ".", "getPackages", "(", "image", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "util", ".", "SingleVersionPackageLayerAnalyzeResult", "{", "}", ",", "err", "\n", "}", "\n", "var", "pkgDiffs", "[", "]", "util", ".", "PackageDiff", "\n\n", "// Each layer with modified packages includes a complete list of packages", "// in its package database. Thus we diff the current layer with the", "// previous one that contains a package database. Layers that do not", "// include a package database are omitted.", "preInd", ":=", "-", "1", "\n", "for", "i", ":=", "range", "pack", "{", "var", "pkgDiff", "util", ".", "PackageDiff", "\n", "if", "preInd", "<", "0", "&&", "len", "(", "pack", "[", "i", "]", ")", ">", "0", "{", "pkgDiff", "=", "util", ".", "GetMapDiff", "(", "make", "(", "map", "[", "string", "]", "util", ".", "PackageInfo", ")", ",", "pack", "[", "i", "]", ")", "\n", "preInd", "=", "i", "\n", "}", "else", "if", "preInd", ">=", "0", "&&", "len", "(", "pack", "[", "i", "]", ")", ">", "0", "{", "pkgDiff", "=", "util", ".", "GetMapDiff", "(", "pack", "[", "preInd", "]", ",", "pack", "[", "i", "]", ")", "\n", "preInd", "=", "i", "\n", "}", "\n\n", "pkgDiffs", "=", "append", "(", "pkgDiffs", ",", "pkgDiff", ")", "\n", "}", "\n\n", "return", "&", "util", ".", "SingleVersionPackageLayerAnalyzeResult", "{", "Image", ":", "image", ".", "Source", ",", "AnalyzeType", ":", "strings", ".", "TrimSuffix", "(", "analyzer", ".", "Name", "(", ")", ",", "\"", "\"", ")", ",", "Analysis", ":", "util", ".", "PackageLayerDiff", "{", "PackageDiffs", ":", "pkgDiffs", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "singleVersionLayerAnalysis", "returns", "the", "packages", "included", "deleted", "or", "updated", "in", "each", "layer" ]

[ "func", "GetImage", "(", "imageName", "string", ",", "includeLayers", "bool", ",", "cacheDir", "string", ")", "(", "Image", ",", "error", ")", "{", "logrus", ".", "Infof", "(", "\"", "\"", ",", "imageName", ")", "\n", "var", "img", "v1", ".", "Image", "\n", "var", "err", "error", "\n", "if", "IsTar", "(", "imageName", ")", "{", "start", ":=", "time", ".", "Now", "(", ")", "\n", "img", ",", "err", "=", "tarball", ".", "ImageFromPath", "(", "imageName", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "elapsed", ":=", "time", ".", "Now", "(", ")", ".", "Sub", "(", "start", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "elapsed", ".", "Seconds", "(", ")", ")", "\n", "}", "else", "if", "strings", ".", "HasPrefix", "(", "imageName", ",", "daemonPrefix", ")", "{", "// remove the daemon prefix", "imageName", "=", "strings", ".", "Replace", "(", "imageName", ",", "daemonPrefix", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "ref", ",", "err", ":=", "name", ".", "ParseReference", "(", "imageName", ",", "name", ".", "WeakValidation", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "// TODO(nkubala): specify gzip.NoCompression here when functional options are supported", "img", ",", "err", "=", "daemon", ".", "Image", "(", "ref", ",", "daemon", ".", "WithBufferedOpener", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "elapsed", ":=", "time", ".", "Now", "(", ")", ".", "Sub", "(", "start", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "elapsed", ".", "Seconds", "(", ")", ")", "\n", "}", "else", "{", "// either has remote prefix or has no prefix, in which case we force remote", "imageName", "=", "strings", ".", "Replace", "(", "imageName", ",", "remotePrefix", ",", "\"", "\"", ",", "-", "1", ")", "\n", "ref", ",", "err", ":=", "name", ".", "ParseReference", "(", "imageName", ",", "name", ".", "WeakValidation", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "auth", ",", "err", ":=", "authn", ".", "DefaultKeychain", ".", "Resolve", "(", "ref", ".", "Context", "(", ")", ".", "Registry", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "img", ",", "err", "=", "remote", ".", "Image", "(", "ref", ",", "remote", ".", "WithAuth", "(", "auth", ")", ",", "remote", ".", "WithTransport", "(", "http", ".", "DefaultTransport", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "elapsed", ":=", "time", ".", "Now", "(", ")", ".", "Sub", "(", "start", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "elapsed", ".", "Seconds", "(", ")", ")", "\n", "}", "\n\n", "// create tempdir and extract fs into it", "var", "layers", "[", "]", "Layer", "\n", "if", "includeLayers", "{", "start", ":=", "time", ".", "Now", "(", ")", "\n", "imgLayers", ",", "err", ":=", "img", ".", "Layers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "layer", ":=", "range", "imgLayers", "{", "layerStart", ":=", "time", ".", "Now", "(", ")", "\n", "digest", ",", "err", ":=", "layer", ".", "Digest", "(", ")", "\n", "path", ",", "err", ":=", "getExtractPathForName", "(", "digest", ".", "String", "(", ")", ",", "cacheDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "Layers", ":", "layers", ",", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "GetFileSystemForLayer", "(", "layer", ",", "path", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "Image", "{", "Layers", ":", "layers", ",", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "layers", "=", "append", "(", "layers", ",", "Layer", "{", "FSPath", ":", "path", ",", "Digest", ":", "digest", ",", "}", ")", "\n", "elapsed", ":=", "time", ".", "Now", "(", ")", ".", "Sub", "(", "layerStart", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "elapsed", ".", "Seconds", "(", ")", ")", "\n", "}", "\n", "elapsed", ":=", "time", ".", "Now", "(", ")", ".", "Sub", "(", "start", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "elapsed", ".", "Seconds", "(", ")", ")", "\n", "}", "\n\n", "imageDigest", ",", "err", ":=", "getImageDigest", "(", "img", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "err", "\n", "}", "\n", "path", ",", "err", ":=", "getExtractPathForName", "(", "RemoveTag", "(", "imageName", ")", "+", "\"", "\"", "+", "imageDigest", ".", "String", "(", ")", ",", "cacheDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Image", "{", "}", ",", "err", "\n", "}", "\n", "// extract fs into provided dir", "if", "err", ":=", "GetFileSystemForImage", "(", "img", ",", "path", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "Image", "{", "FSPath", ":", "path", ",", "Layers", ":", "layers", ",", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "Image", "{", "Image", ":", "img", ",", "Source", ":", "imageName", ",", "FSPath", ":", "path", ",", "Digest", ":", "imageDigest", ",", "Layers", ":", "layers", ",", "}", ",", "nil", "\n", "}" ]

[ "GetImage", "infers", "the", "source", "of", "an", "image", "and", "retrieves", "a", "v1", ".", "Image", "reference", "to", "it", ".", "Once", "a", "reference", "is", "obtained", "it", "attempts", "to", "unpack", "the", "v1", ".", "Image", "s", "reader", "s", "contents", "into", "a", "temp", "directory", "on", "the", "local", "filesystem", "." ]

[ "func", "GetFileSystemForLayer", "(", "layer", "v1", ".", "Layer", ",", "root", "string", ",", "whitelist", "[", "]", "string", ")", "error", "{", "empty", ",", "err", ":=", "DirIsEmpty", "(", "root", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "empty", "{", "logrus", ".", "Infof", "(", "\"", "\"", ",", "root", ")", "\n", "return", "nil", "\n", "}", "\n", "contents", ",", "err", ":=", "layer", ".", "Uncompressed", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "unpackTar", "(", "tar", ".", "NewReader", "(", "contents", ")", ",", "root", ",", "whitelist", ")", "\n", "}" ]

[ "GetFileSystemForLayer", "unpacks", "a", "layer", "to", "local", "disk" ]

[ "func", "GetFileSystemForImage", "(", "image", "v1", ".", "Image", ",", "root", "string", ",", "whitelist", "[", "]", "string", ")", "error", "{", "empty", ",", "err", ":=", "DirIsEmpty", "(", "root", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "empty", "{", "logrus", ".", "Infof", "(", "\"", "\"", ",", "root", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "unpackTar", "(", "tar", ".", "NewReader", "(", "mutate", ".", "Extract", "(", "image", ")", ")", ",", "root", ",", "whitelist", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "unpack", "image", "filesystem", "to", "local", "disk", "if", "provided", "directory", "is", "not", "empty", "do", "nothing" ]

[ "func", "HasTag", "(", "image", "string", ")", "bool", "{", "tagRegex", ":=", "regexp", ".", "MustCompile", "(", "tagRegexStr", ")", "\n", "return", "tagRegex", ".", "MatchString", "(", "image", ")", "\n", "}" ]

[ "checks", "to", "see", "if", "an", "image", "string", "contains", "a", "tag", "." ]

[ "func", "RemoveTag", "(", "image", "string", ")", "string", "{", "if", "!", "HasTag", "(", "image", ")", "{", "return", "image", "\n", "}", "\n", "tagRegex", ":=", "regexp", ".", "MustCompile", "(", "tagRegexStr", ")", "\n", "parts", ":=", "tagRegex", ".", "FindStringSubmatch", "(", "image", ")", "\n", "tag", ":=", "parts", "[", "len", "(", "parts", ")", "-", "1", "]", "\n", "return", "image", "[", "0", ":", "len", "(", "image", ")", "-", "len", "(", "tag", ")", "-", "1", "]", "\n", "}" ]

[ "returns", "a", "raw", "image", "name", "with", "the", "tag", "removed" ]

[ "func", "(", "d", "*", "diffTypes", ")", "Set", "(", "value", "string", ")", "error", "{", "// Dedupe repeated elements.", "for", "_", ",", "t", ":=", "range", "*", "d", "{", "if", "t", "==", "value", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "*", "d", "=", "append", "(", "*", "d", ",", "value", ")", "\n", "return", "nil", "\n", "}" ]

[ "The", "second", "method", "is", "Set", "(", "value", "string", ")", "error" ]

[ "func", "GetAdditions", "(", "a", ",", "b", "[", "]", "string", ")", "[", "]", "string", "{", "matcher", ":=", "difflib", ".", "NewMatcher", "(", "a", ",", "b", ")", "\n", "differences", ":=", "matcher", ".", "GetGroupedOpCodes", "(", "0", ")", "\n\n", "adds", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "group", ":=", "range", "differences", "{", "for", "_", ",", "opCode", ":=", "range", "group", "{", "j1", ",", "j2", ":=", "opCode", ".", "J1", ",", "opCode", ".", "J2", "\n", "if", "opCode", ".", "Tag", "==", "'r'", "||", "opCode", ".", "Tag", "==", "'i'", "{", "for", "_", ",", "line", ":=", "range", "b", "[", "j1", ":", "j2", "]", "{", "adds", "=", "append", "(", "adds", ",", "line", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "adds", "\n", "}" ]

[ "Modification", "of", "difflib", "s", "unified", "differ" ]

[ "func", "DiffDirectory", "(", "d1", ",", "d2", "pkgutil", ".", "Directory", ")", "(", "DirDiff", ",", "bool", ")", "{", "adds", ":=", "GetAddedEntries", "(", "d1", ",", "d2", ")", "\n", "sort", ".", "Strings", "(", "adds", ")", "\n", "addedEntries", ":=", "pkgutil", ".", "CreateDirectoryEntries", "(", "d2", ".", "Root", ",", "adds", ")", "\n\n", "dels", ":=", "GetDeletedEntries", "(", "d1", ",", "d2", ")", "\n", "sort", ".", "Strings", "(", "dels", ")", "\n", "deletedEntries", ":=", "pkgutil", ".", "CreateDirectoryEntries", "(", "d1", ".", "Root", ",", "dels", ")", "\n\n", "mods", ":=", "GetModifiedEntries", "(", "d1", ",", "d2", ")", "\n", "sort", ".", "Strings", "(", "mods", ")", "\n", "modifiedEntries", ":=", "createEntryDiffs", "(", "d1", ".", "Root", ",", "d2", ".", "Root", ",", "mods", ")", "\n\n", "var", "same", "bool", "\n", "if", "len", "(", "adds", ")", "==", "0", "&&", "len", "(", "dels", ")", "==", "0", "&&", "len", "(", "mods", ")", "==", "0", "{", "same", "=", "true", "\n", "}", "else", "{", "same", "=", "false", "\n", "}", "\n\n", "return", "DirDiff", "{", "addedEntries", ",", "deletedEntries", ",", "modifiedEntries", "}", ",", "same", "\n", "}" ]

[ "DiffDirectory", "takes", "the", "diff", "of", "two", "directories", "assuming", "both", "are", "completely", "unpacked" ]

[ "func", "GetModifiedEntries", "(", "d1", ",", "d2", "pkgutil", ".", "Directory", ")", "[", "]", "string", "{", "d1files", ":=", "d1", ".", "Content", "\n", "d2files", ":=", "d2", ".", "Content", "\n\n", "filematches", ":=", "GetMatches", "(", "d1files", ",", "d2files", ")", "\n\n", "modified", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "f", ":=", "range", "filematches", "{", "f1path", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "d1", ".", "Root", ",", "f", ")", "\n", "f2path", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "d2", ".", "Root", ",", "f", ")", "\n\n", "f1stat", ",", "err", ":=", "os", ".", "Lstat", "(", "f1path", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "f", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "f2stat", ",", "err", ":=", "os", ".", "Lstat", "(", "f2path", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "f", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "// If the directory entry is a symlink, make sure the symlinks point to the same place", "if", "f1stat", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "!=", "0", "&&", "f2stat", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "!=", "0", "{", "same", ",", "err", ":=", "pkgutil", ".", "CheckSameSymlink", "(", "f1path", ",", "f2path", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "f1path", ",", "f2path", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "!", "same", "{", "modified", "=", "append", "(", "modified", ",", "f", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "// If the directory entry in question is a tar, verify that the two have the same size", "if", "pkgutil", ".", "IsTar", "(", "f1path", ")", "{", "if", "f1stat", ".", "Size", "(", ")", "!=", "f2stat", ".", "Size", "(", ")", "{", "modified", "=", "append", "(", "modified", ",", "f", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "// If the directory entry is not a tar and not a directory, then it's a file so make sure the file contents are the same", "// Note: We skip over directory entries because to compare directories, we compare their contents", "if", "!", "f1stat", ".", "IsDir", "(", ")", "{", "same", ",", "err", ":=", "pkgutil", ".", "CheckSameFile", "(", "f1path", ",", "f2path", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "f1path", ",", "f2path", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "!", "same", "{", "modified", "=", "append", "(", "modified", ",", "f", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "modified", "\n", "}" ]

[ "Checks", "for", "content", "differences", "between", "files", "of", "the", "same", "name", "from", "different", "directories" ]

[ "func", "GetFileContents", "(", "path", "string", ")", "(", "*", "string", ",", "error", ")", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "contents", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "strContents", ":=", "string", "(", "contents", ")", "\n", "//If file is empty, return nil", "if", "strContents", "==", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "&", "strContents", ",", "nil", "\n", "}" ]

[ "GetFileContents", "returns", "the", "contents", "of", "a", "file", "at", "the", "specified", "path" ]

[ "func", "GetDirectory", "(", "path", "string", ",", "deep", "bool", ")", "(", "Directory", ",", "error", ")", "{", "var", "directory", "Directory", "\n", "directory", ".", "Root", "=", "path", "\n", "var", "err", "error", "\n", "if", "deep", "{", "walkFn", ":=", "func", "(", "currPath", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "newContent", ":=", "strings", ".", "TrimPrefix", "(", "currPath", ",", "directory", ".", "Root", ")", "\n", "if", "newContent", "!=", "\"", "\"", "{", "directory", ".", "Content", "=", "append", "(", "directory", ".", "Content", ",", "newContent", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "err", "=", "filepath", ".", "Walk", "(", "path", ",", "walkFn", ")", "\n", "}", "else", "{", "contents", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "directory", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "file", ":=", "range", "contents", "{", "fileName", ":=", "\"", "\"", "+", "file", ".", "Name", "(", ")", "\n", "directory", ".", "Content", "=", "append", "(", "directory", ".", "Content", ",", "fileName", ")", "\n", "}", "\n", "}", "\n", "return", "directory", ",", "err", "\n", "}" ]

[ "GetDirectoryContents", "converts", "the", "directory", "starting", "at", "the", "provided", "path", "into", "a", "Directory", "struct", "." ]

[ "func", "HasFilepathPrefix", "(", "path", ",", "prefix", "string", ")", "bool", "{", "path", "=", "filepath", ".", "Clean", "(", "path", ")", "\n", "prefix", "=", "filepath", ".", "Clean", "(", "prefix", ")", "\n", "pathArray", ":=", "strings", ".", "Split", "(", "path", ",", "\"", "\"", ")", "\n", "prefixArray", ":=", "strings", ".", "Split", "(", "prefix", ",", "\"", "\"", ")", "\n\n", "if", "len", "(", "pathArray", ")", "<", "len", "(", "prefixArray", ")", "{", "return", "false", "\n", "}", "\n", "for", "index", ":=", "range", "prefixArray", "{", "if", "prefixArray", "[", "index", "]", "==", "pathArray", "[", "index", "]", "{", "continue", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "HasFilepathPrefix", "checks", "if", "the", "given", "file", "path", "begins", "with", "prefix" ]

[ "func", "CleanFilePath", "(", "dirtyPath", "string", ")", "string", "{", "var", "windowsReplacements", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "replacer", ":=", "strings", ".", "NewReplacer", "(", "windowsReplacements", "...", ")", "\n", "return", "filepath", ".", "Clean", "(", "replacer", ".", "Replace", "(", "dirtyPath", ")", ")", "\n", "}" ]

[ "CleanFilePath", "removes", "characters", "from", "a", "given", "path", "that", "cannot", "be", "used", "in", "paths", "by", "the", "underlying", "platform", "(", "e", ".", "g", ".", "Windows", ")" ]

[ "func", "GetSrcPath", "(", "importPath", "string", ")", "(", "appPath", "string", ",", "err", "error", ")", "{", "paths", ":=", "GetGOPATHs", "(", ")", "\n", "for", "_", ",", "p", ":=", "range", "paths", "{", "if", "IsExist", "(", "p", "+", "\"", "\"", "+", "importPath", "+", "\"", "\"", ")", "{", "appPath", "=", "p", "+", "\"", "\"", "+", "importPath", "+", "\"", "\"", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "appPath", ")", "==", "0", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "appPath", "=", "filepath", ".", "Dir", "(", "appPath", ")", "+", "\"", "\"", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "// Replace all '\\' to '/'.", "appPath", "=", "strings", ".", "Replace", "(", "appPath", ",", "\"", "\\\\", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "}", "\n\n", "return", "appPath", ",", "nil", "\n", "}" ]

[ "GetSrcPath", "returns", "app", ".", "source", "code", "path", ".", "It", "only", "works", "when", "you", "have", "src", ".", "folder", "in", "GOPATH", "it", "returns", "error", "not", "able", "to", "locate", "source", "folder", "path", "." ]

[ "func", "getColorLevel", "(", "level", "string", ")", "string", "{", "level", "=", "strings", ".", "ToUpper", "(", "level", ")", "\n", "switch", "level", "{", "case", "\"", "\"", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\\033", "\\033", "\"", ",", "Blue", ",", "level", ")", "\n", "case", "\"", "\"", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\\033", "\\033", "\"", ",", "Red", ",", "level", ")", "\n", "case", "\"", "\"", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\\033", "\\033", "\"", ",", "Magenta", ",", "level", ")", "\n", "case", "\"", "\"", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\\033", "\\033", "\"", ",", "Green", ",", "level", ")", "\n", "default", ":", "return", "level", "\n", "}", "\n", "}" ]

[ "getColorLevel", "returns", "colored", "level", "string", "by", "given", "level", "." ]

[ "func", "ColorLogS", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "string", "{", "log", ":=", "fmt", ".", "Sprintf", "(", "format", ",", "a", "...", ")", "\n\n", "var", "clog", "string", "\n\n", "if", "runtime", ".", "GOOS", "!=", "\"", "\"", "{", "// Level.", "i", ":=", "strings", ".", "Index", "(", "log", ",", "\"", "\"", ")", "\n", "if", "log", "[", "0", "]", "==", "'['", "&&", "i", ">", "-", "1", "{", "clog", "+=", "\"", "\"", "+", "getColorLevel", "(", "log", "[", "1", ":", "i", "]", ")", "+", "\"", "\"", "\n", "}", "\n\n", "log", "=", "log", "[", "i", "+", "1", ":", "]", "\n\n", "// Error.", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\\033", "\"", ",", "Red", ")", ",", "-", "1", ")", "\n", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "EndColor", "+", "\"", "\"", ",", "-", "1", ")", "\n\n", "// Path.", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\\033", "\"", ",", "Yellow", ")", ",", "-", "1", ")", "\n", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "EndColor", "+", "\"", "\"", ",", "-", "1", ")", "\n\n", "// Highlights.", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\\033", "\"", ",", "Gray", ")", ",", "-", "1", ")", "\n", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "EndColor", ",", "-", "1", ")", "\n\n", "}", "else", "{", "// Level.", "i", ":=", "strings", ".", "Index", "(", "log", ",", "\"", "\"", ")", "\n", "if", "log", "[", "0", "]", "==", "'['", "&&", "i", ">", "-", "1", "{", "clog", "+=", "\"", "\"", "+", "log", "[", "1", ":", "i", "]", "+", "\"", "\"", "\n", "}", "\n\n", "log", "=", "log", "[", "i", "+", "1", ":", "]", "\n\n", "// Error.", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "// Path.", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "// Highlights.", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "log", "=", "strings", ".", "Replace", "(", "log", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "}", "\n", "return", "clog", "+", "log", "\n", "}" ]

[ "ColorLogS", "colors", "log", "and", "return", "colored", "content", ".", "Log", "format", ":", "<level", ">", "<content", "[", "highlight", "]", "[", "path", "]", ">", "[", "error", "]", ".", "Level", ":", "TRAC", "-", ">", "blue", ";", "ERRO", "-", ">", "red", ";", "WARN", "-", ">", "Magenta", ";", "SUCC", "-", ">", "green", ";", "others", "-", ">", "default", ".", "Content", ":", "default", ";", "path", ":", "yellow", ";", "error", "-", ">", "red", ".", "Level", "has", "to", "be", "surrounded", "by", "[", "and", "]", ".", "Highlights", "have", "to", "be", "surrounded", "by", "#", "and", "#", "(", "space", ")", "#", "will", "be", "deleted", ".", "Paths", "have", "to", "be", "surrounded", "by", "(", "and", ")", "(", "space", ")", ".", "Errors", "have", "to", "be", "surrounded", "by", "[", "and", "]", "(", "space", ")", ".", "Note", ":", "it", "hasn", "t", "support", "windows", "yet", "contribute", "is", "welcome", "." ]

[ "func", "AESGCMEncrypt", "(", "key", ",", "plaintext", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "block", ",", "err", ":=", "aes", ".", "NewCipher", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "gcm", ",", "err", ":=", "cipher", ".", "NewGCM", "(", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "nonce", ":=", "make", "(", "[", "]", "byte", ",", "gcm", ".", "NonceSize", "(", ")", ")", "\n", "if", "_", ",", "err", ":=", "rand", ".", "Read", "(", "nonce", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ciphertext", ":=", "gcm", ".", "Seal", "(", "nil", ",", "nonce", ",", "plaintext", ",", "nil", ")", "\n", "return", "append", "(", "nonce", ",", "ciphertext", "...", ")", ",", "nil", "\n", "}" ]

[ "AESGCMEncrypt", "encrypts", "plaintext", "with", "the", "given", "key", "using", "AES", "in", "GCM", "mode", "." ]

[ "func", "AESGCMDecrypt", "(", "key", ",", "ciphertext", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "block", ",", "err", ":=", "aes", ".", "NewCipher", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "gcm", ",", "err", ":=", "cipher", ".", "NewGCM", "(", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "size", ":=", "gcm", ".", "NonceSize", "(", ")", "\n", "if", "len", "(", "ciphertext", ")", "-", "size", "<=", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "nonce", ":=", "ciphertext", "[", ":", "size", "]", "\n", "ciphertext", "=", "ciphertext", "[", "size", ":", "]", "\n\n", "plainText", ",", "err", ":=", "gcm", ".", "Open", "(", "nil", ",", "nonce", ",", "ciphertext", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "plainText", ",", "nil", "\n", "}" ]

[ "AESGCMDecrypt", "decrypts", "ciphertext", "with", "the", "given", "key", "using", "AES", "in", "GCM", "mode", "." ]

[ "func", "IsLetter", "(", "l", "uint8", ")", "bool", "{", "n", ":=", "(", "l", "|", "0x20", ")", "-", "'a'", "\n", "if", "n", ">=", "0", "&&", "n", "<", "26", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsLetter", "returns", "true", "if", "the", "l", "is", "an", "English", "letter", "." ]

[ "func", "Reverse", "(", "s", "string", ")", "string", "{", "n", ":=", "len", "(", "s", ")", "\n", "runes", ":=", "make", "(", "[", "]", "rune", ",", "n", ")", "\n", "for", "_", ",", "rune", ":=", "range", "s", "{", "n", "--", "\n", "runes", "[", "n", "]", "=", "rune", "\n", "}", "\n", "return", "string", "(", "runes", "[", "n", ":", "]", ")", "\n", "}" ]

[ "Reverse", "s", "string", "support", "unicode" ]

[ "func", "Date", "(", "ti", "int64", ",", "format", "string", ")", "string", "{", "t", ":=", "time", ".", "Unix", "(", "int64", "(", "ti", ")", ",", "0", ")", "\n", "return", "DateT", "(", "t", ",", "format", ")", "\n", "}" ]

[ "Format", "unix", "time", "int64", "to", "string" ]

[ "func", "DateS", "(", "ts", "string", ",", "format", "string", ")", "string", "{", "i", ",", "_", ":=", "strconv", ".", "ParseInt", "(", "ts", ",", "10", ",", "64", ")", "\n", "return", "Date", "(", "i", ",", "format", ")", "\n", "}" ]

[ "Format", "unix", "time", "string", "to", "string" ]

[ "func", "DateT", "(", "t", "time", ".", "Time", ",", "format", "string", ")", "string", "{", "res", ":=", "strings", ".", "Replace", "(", "format", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "t", ".", "Hour", "(", ")", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "t", ".", "Hour", "(", ")", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "res", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\"", ",", "t", ".", "Format", "(", "\"", "\"", ")", ",", "-", "1", ")", "\n", "return", "res", "\n", "}" ]

[ "Format", "time", ".", "Time", "struct", "to", "string", "MM", "-", "month", "-", "01", "M", "-", "month", "-", "1", "single", "bit", "DD", "-", "day", "-", "02", "D", "-", "day", "2", "YYYY", "-", "year", "-", "2006", "YY", "-", "year", "-", "06", "HH", "-", "24", "hours", "-", "03", "H", "-", "24", "hours", "-", "3", "hh", "-", "12", "hours", "-", "03", "h", "-", "12", "hours", "-", "3", "mm", "-", "minute", "-", "04", "m", "-", "minute", "-", "4", "ss", "-", "second", "-", "05", "s", "-", "second", "=", "5" ]

[ "func", "DateParse", "(", "dateString", ",", "format", "string", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "replacer", ":=", "strings", ".", "NewReplacer", "(", "datePatterns", "...", ")", "\n", "format", "=", "replacer", ".", "Replace", "(", "format", ")", "\n", "return", "time", ".", "ParseInLocation", "(", "format", ",", "dateString", ",", "time", ".", "Local", ")", "\n", "}" ]

[ "Parse", "Date", "use", "PHP", "time", "format", "." ]

[ "func", "StatDir", "(", "rootPath", "string", ",", "includeDir", "...", "bool", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "!", "IsDir", "(", "rootPath", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", "+", "rootPath", ")", "\n", "}", "\n\n", "isIncludeDir", ":=", "false", "\n", "if", "len", "(", "includeDir", ")", ">=", "1", "{", "isIncludeDir", "=", "includeDir", "[", "0", "]", "\n", "}", "\n", "return", "statDir", "(", "rootPath", ",", "\"", "\"", ",", "isIncludeDir", ",", "false", ",", "false", ")", "\n", "}" ]

[ "StatDir", "gathers", "information", "of", "given", "directory", "by", "depth", "-", "first", ".", "It", "returns", "slice", "of", "file", "list", "and", "includes", "subdirectories", "if", "enabled", ";", "it", "returns", "error", "and", "nil", "slice", "when", "error", "occurs", "in", "underlying", "functions", "or", "given", "path", "is", "not", "a", "directory", "or", "does", "not", "exist", ".", "Slice", "does", "not", "include", "given", "path", "itself", ".", "If", "subdirectories", "is", "enabled", "they", "will", "have", "suffix", "/", "." ]

[ "func", "GetAllSubDirs", "(", "rootPath", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "!", "IsDir", "(", "rootPath", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", "+", "rootPath", ")", "\n", "}", "\n", "return", "statDir", "(", "rootPath", ",", "\"", "\"", ",", "true", ",", "true", ",", "false", ")", "\n", "}" ]

[ "GetAllSubDirs", "returns", "all", "subdirectories", "of", "given", "root", "path", ".", "Slice", "does", "not", "include", "given", "path", "itself", "." ]

[ "func", "GetFileListBySuffix", "(", "dirPath", ",", "suffix", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "!", "IsExist", "(", "dirPath", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dirPath", ")", "\n", "}", "else", "if", "IsFile", "(", "dirPath", ")", "{", "return", "[", "]", "string", "{", "dirPath", "}", ",", "nil", "\n", "}", "\n\n", "// Given path is a directory.", "dir", ",", "err", ":=", "os", ".", "Open", "(", "dirPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "fis", ",", "err", ":=", "dir", ".", "Readdir", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "files", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "fis", ")", ")", "\n", "for", "_", ",", "fi", ":=", "range", "fis", "{", "if", "strings", ".", "HasSuffix", "(", "fi", ".", "Name", "(", ")", ",", "suffix", ")", "{", "files", "=", "append", "(", "files", ",", "path", ".", "Join", "(", "dirPath", ",", "fi", ".", "Name", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "files", ",", "nil", "\n", "}" ]

[ "GetFileListBySuffix", "returns", "an", "ordered", "list", "of", "file", "paths", ".", "It", "recognize", "if", "given", "path", "is", "a", "file", "and", "don", "t", "do", "recursive", "find", "." ]

[ "func", "AppendStr", "(", "strs", "[", "]", "string", ",", "str", "string", ")", "[", "]", "string", "{", "for", "_", ",", "s", ":=", "range", "strs", "{", "if", "s", "==", "str", "{", "return", "strs", "\n", "}", "\n", "}", "\n", "return", "append", "(", "strs", ",", "str", ")", "\n", "}" ]

[ "AppendStr", "appends", "string", "to", "slice", "with", "no", "duplicates", "." ]

[ "func", "CompareSliceStrU", "(", "s1", ",", "s2", "[", "]", "string", ")", "bool", "{", "if", "len", "(", "s1", ")", "!=", "len", "(", "s2", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "i", ":=", "range", "s1", "{", "for", "j", ":=", "len", "(", "s2", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", "{", "if", "s1", "[", "i", "]", "==", "s2", "[", "j", "]", "{", "s2", "=", "append", "(", "s2", "[", ":", "j", "]", ",", "s2", "[", "j", "+", "1", ":", "]", "...", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "len", "(", "s2", ")", ">", "0", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "CompareSliceStrU", "compares", "two", "string", "type", "slices", ".", "It", "returns", "true", "if", "elements", "are", "the", "same", "and", "ignores", "the", "order", "." ]

[ "func", "IsSliceContainsInt64", "(", "sl", "[", "]", "int64", ",", "i", "int64", ")", "bool", "{", "for", "_", ",", "s", ":=", "range", "sl", "{", "if", "s", "==", "i", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsSliceContainsInt64", "returns", "true", "if", "the", "int64", "exists", "in", "given", "slice", "." ]

[ "func", "FileMTime", "(", "file", "string", ")", "(", "int64", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Stat", "(", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "f", ".", "ModTime", "(", ")", ".", "Unix", "(", ")", ",", "nil", "\n", "}" ]

[ "FileMTime", "returns", "file", "modified", "time", "and", "possible", "error", "." ]

[ "func", "FileSize", "(", "file", "string", ")", "(", "int64", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Stat", "(", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "f", ".", "Size", "(", ")", ",", "nil", "\n", "}" ]

[ "FileSize", "returns", "file", "size", "in", "bytes", "and", "possible", "error", "." ]

[ "func", "WriteFile", "(", "filename", "string", ",", "data", "[", "]", "byte", ")", "error", "{", "os", ".", "MkdirAll", "(", "path", ".", "Dir", "(", "filename", ")", ",", "os", ".", "ModePerm", ")", "\n", "return", "ioutil", ".", "WriteFile", "(", "filename", ",", "data", ",", "0655", ")", "\n", "}" ]

[ "WriteFile", "writes", "data", "to", "a", "file", "named", "by", "filename", ".", "If", "the", "file", "does", "not", "exist", "WriteFile", "creates", "it", "and", "its", "upper", "level", "paths", "." ]

[ "func", "HttpGet", "(", "client", "*", "http", ".", "Client", ",", "url", "string", ",", "header", "http", ".", "Header", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "return", "HttpCall", "(", "client", ",", "\"", "\"", ",", "url", ",", "header", ",", "nil", ")", "\n", "}" ]

[ "HttpGet", "gets", "the", "specified", "resource", ".", "ErrNotFound", "is", "returned", "if", "the", "server", "responds", "with", "status", "404", "." ]

[ "func", "HttpPost", "(", "client", "*", "http", ".", "Client", ",", "url", "string", ",", "header", "http", ".", "Header", ",", "body", "[", "]", "byte", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "return", "HttpCall", "(", "client", ",", "\"", "\"", ",", "url", ",", "header", ",", "bytes", ".", "NewBuffer", "(", "body", ")", ")", "\n", "}" ]

[ "HttpPost", "posts", "the", "specified", "resource", ".", "ErrNotFound", "is", "returned", "if", "the", "server", "responds", "with", "status", "404", "." ]

[ "func", "HttpGetToFile", "(", "client", "*", "http", ".", "Client", ",", "url", "string", ",", "header", "http", ".", "Header", ",", "fileName", "string", ")", "error", "{", "rc", ",", "err", ":=", "HttpGet", "(", "client", ",", "url", ",", "header", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "rc", ".", "Close", "(", ")", "\n\n", "os", ".", "MkdirAll", "(", "path", ".", "Dir", "(", "fileName", ")", ",", "os", ".", "ModePerm", ")", "\n", "f", ",", "err", ":=", "os", ".", "Create", "(", "fileName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "f", ",", "rc", ")", "\n", "return", "err", "\n", "}" ]

[ "HttpGetToFile", "gets", "the", "specified", "resource", "and", "writes", "to", "file", ".", "ErrNotFound", "is", "returned", "if", "the", "server", "responds", "with", "status", "404", "." ]

[ "func", "HttpPostJSON", "(", "client", "*", "http", ".", "Client", ",", "url", "string", ",", "body", ",", "v", "interface", "{", "}", ")", "error", "{", "data", ",", "err", ":=", "json", ".", "Marshal", "(", "body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "rc", ",", "err", ":=", "HttpPost", "(", "client", ",", "url", ",", "http", ".", "Header", "{", "\"", "\"", ":", "[", "]", "string", "{", "\"", "\"", "}", "}", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "rc", ".", "Close", "(", ")", "\n", "err", "=", "json", ".", "NewDecoder", "(", "rc", ")", ".", "Decode", "(", "v", ")", "\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "json", ".", "SyntaxError", ")", ";", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "HttpPostJSON", "posts", "the", "specified", "resource", "with", "struct", "values", "and", "maps", "results", "to", "struct", ".", "ErrNotFound", "is", "returned", "if", "the", "server", "responds", "with", "status", "404", "." ]

[ "func", "FetchFiles", "(", "client", "*", "http", ".", "Client", ",", "files", "[", "]", "RawFile", ",", "header", "http", ".", "Header", ")", "error", "{", "ch", ":=", "make", "(", "chan", "error", ",", "len", "(", "files", ")", ")", "\n", "for", "i", ":=", "range", "files", "{", "go", "func", "(", "i", "int", ")", "{", "p", ",", "err", ":=", "HttpGetBytes", "(", "client", ",", "files", "[", "i", "]", ".", "RawUrl", "(", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "ch", "<-", "err", "\n", "return", "\n", "}", "\n", "files", "[", "i", "]", ".", "SetData", "(", "p", ")", "\n", "ch", "<-", "nil", "\n", "}", "(", "i", ")", "\n", "}", "\n", "for", "_", "=", "range", "files", "{", "if", "err", ":=", "<-", "ch", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "FetchFiles", "fetches", "files", "specified", "by", "the", "rawURL", "field", "in", "parallel", "." ]

[ "func", "PowInt", "(", "x", "int", ",", "y", "int", ")", "int", "{", "if", "y", "<=", "0", "{", "return", "1", "\n", "}", "else", "{", "if", "y", "%", "2", "==", "0", "{", "sqrt", ":=", "PowInt", "(", "x", ",", "y", "/", "2", ")", "\n", "return", "sqrt", "*", "sqrt", "\n", "}", "else", "{", "return", "PowInt", "(", "x", ",", "y", "-", "1", ")", "*", "x", "\n", "}", "\n", "}", "\n", "}" ]

[ "PowInt", "is", "int", "type", "of", "math", ".", "Pow", "function", "." ]

[ "func", "Base64Decode", "(", "str", "string", ")", "(", "string", ",", "error", ")", "{", "s", ",", "e", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "str", ")", "\n", "return", "string", "(", "s", ")", ",", "e", "\n", "}" ]

[ "base64", "decode" ]

[ "func", "HexStr2int", "(", "hexStr", "string", ")", "(", "int", ",", "error", ")", "{", "num", ":=", "0", "\n", "length", ":=", "len", "(", "hexStr", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "length", ";", "i", "++", "{", "char", ":=", "hexStr", "[", "length", "-", "i", "-", "1", "]", "\n", "factor", ":=", "-", "1", "\n\n", "switch", "{", "case", "char", ">=", "'0'", "&&", "char", "<=", "'9'", ":", "factor", "=", "int", "(", "char", ")", "-", "'0'", "\n", "case", "char", ">=", "'a'", "&&", "char", "<=", "'f'", ":", "factor", "=", "int", "(", "char", ")", "-", "'a'", "+", "10", "\n", "default", ":", "return", "-", "1", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "char", ")", ")", "\n", "}", "\n\n", "num", "+=", "factor", "*", "PowInt", "(", "16", ",", "i", ")", "\n", "}", "\n", "return", "num", ",", "nil", "\n", "}" ]

[ "HexStr2int", "converts", "hex", "format", "string", "to", "decimal", "number", "." ]

[ "func", "Html2JS", "(", "data", "[", "]", "byte", ")", "[", "]", "byte", "{", "s", ":=", "string", "(", "data", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "`\\`", ",", "`\\\\`", ",", "-", "1", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\\n", "\"", ",", "`\\n`", ",", "-", "1", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\\r", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\\\"", "\"", ",", "`\\\"`", ",", "-", "1", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "return", "[", "]", "byte", "(", "s", ")", "\n", "}" ]

[ "Html2JS", "converts", "[]", "byte", "type", "of", "HTML", "content", "into", "JS", "format", "." ]

[ "func", "StripTags", "(", "src", "string", ")", "string", "{", "//去除style,script,html tag", "re", ":=", "regexp", ".", "MustCompile", "(", "`(?s)<(?:style|script)[^<>]*>.*?</(?:style|script)>|</?[a-z][a-z0-9]*[^<>]*>|<!--.*?-->`", ")", "\n", "src", "=", "re", ".", "ReplaceAllString", "(", "src", ",", "\"", "\"", ")", "\n\n", "//trim all spaces(2+) into \\n", "re", "=", "regexp", ".", "MustCompile", "(", "`\\s{2,}`", ")", "\n", "src", "=", "re", ".", "ReplaceAllString", "(", "src", ",", "\"", "\\n", "\"", ")", "\n\n", "return", "strings", ".", "TrimSpace", "(", "src", ")", "\n", "}" ]

[ "strip", "tags", "in", "html", "string" ]

[ "func", "(", "conf", "*", "Config", ")", "OpenPartition", "(", "colPath", ",", "lookupPath", "string", ")", "(", "part", "*", "Partition", ",", "err", "error", ")", "{", "part", "=", "conf", ".", "newPartition", "(", ")", "\n", "part", ".", "CalculateConfigConstants", "(", ")", "\n", "if", "part", ".", "col", ",", "err", "=", "conf", ".", "OpenCollection", "(", "colPath", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "if", "part", ".", "lookup", ",", "err", "=", "conf", ".", "OpenHashTable", "(", "lookupPath", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "\n", "}" ]

[ "Open", "a", "collection", "partition", "." ]

[ "func", "(", "part", "*", "Partition", ")", "Insert", "(", "id", "int", ",", "data", "[", "]", "byte", ")", "(", "physID", "int", ",", "err", "error", ")", "{", "physID", ",", "err", "=", "part", ".", "col", ".", "Insert", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "part", ".", "lookup", ".", "Put", "(", "id", ",", "physID", ")", "\n", "return", "\n", "}" ]

[ "Insert", "a", "document", ".", "The", "ID", "may", "be", "used", "to", "retrieve", "/", "update", "/", "delete", "the", "document", "later", "on", "." ]

[ "func", "(", "part", "*", "Partition", ")", "Read", "(", "id", "int", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "physID", ":=", "part", ".", "lookup", ".", "Get", "(", "id", ",", "1", ")", "\n\n", "if", "len", "(", "physID", ")", "==", "0", "{", "return", "nil", ",", "dberr", ".", "New", "(", "dberr", ".", "ErrorNoDoc", ",", "id", ")", "\n", "}", "\n\n", "data", ":=", "part", ".", "col", ".", "Read", "(", "physID", "[", "0", "]", ")", "\n\n", "if", "data", "==", "nil", "{", "return", "nil", ",", "dberr", ".", "New", "(", "dberr", ".", "ErrorNoDoc", ",", "id", ")", "\n", "}", "\n\n", "return", "data", ",", "nil", "\n", "}" ]

[ "Find", "and", "retrieve", "a", "document", "by", "ID", "." ]

[ "func", "(", "part", "*", "Partition", ")", "Update", "(", "id", "int", ",", "data", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "physID", ":=", "part", ".", "lookup", ".", "Get", "(", "id", ",", "1", ")", "\n", "if", "len", "(", "physID", ")", "==", "0", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorNoDoc", ",", "id", ")", "\n", "}", "\n", "newID", ",", "err", ":=", "part", ".", "col", ".", "Update", "(", "physID", "[", "0", "]", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "newID", "!=", "physID", "[", "0", "]", "{", "part", ".", "lookup", ".", "Remove", "(", "id", ",", "physID", "[", "0", "]", ")", "\n", "part", ".", "lookup", ".", "Put", "(", "id", ",", "newID", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Update", "a", "document", "." ]

[ "func", "(", "part", "*", "Partition", ")", "LockUpdate", "(", "id", "int", ")", "{", "for", "{", "part", ".", "exclUpdateLock", ".", "Lock", "(", ")", "\n", "ch", ",", "ok", ":=", "part", ".", "exclUpdate", "[", "id", "]", "\n", "if", "!", "ok", "{", "part", ".", "exclUpdate", "[", "id", "]", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "}", "\n", "part", ".", "exclUpdateLock", ".", "Unlock", "(", ")", "\n", "if", "ok", "{", "<-", "ch", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n", "}" ]

[ "Lock", "a", "document", "for", "exclusive", "update", "." ]

[ "func", "(", "part", "*", "Partition", ")", "UnlockUpdate", "(", "id", "int", ")", "{", "part", ".", "exclUpdateLock", ".", "Lock", "(", ")", "\n", "ch", ":=", "part", ".", "exclUpdate", "[", "id", "]", "\n", "delete", "(", "part", ".", "exclUpdate", ",", "id", ")", "\n", "part", ".", "exclUpdateLock", ".", "Unlock", "(", ")", "\n", "close", "(", "ch", ")", "\n", "}" ]

[ "Unlock", "a", "document", "to", "make", "it", "ready", "for", "the", "next", "update", "." ]

[ "func", "(", "part", "*", "Partition", ")", "Delete", "(", "id", "int", ")", "(", "err", "error", ")", "{", "physID", ":=", "part", ".", "lookup", ".", "Get", "(", "id", ",", "1", ")", "\n", "if", "len", "(", "physID", ")", "==", "0", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorNoDoc", ",", "id", ")", "\n", "}", "\n", "part", ".", "col", ".", "Delete", "(", "physID", "[", "0", "]", ")", "\n", "part", ".", "lookup", ".", "Remove", "(", "id", ",", "physID", "[", "0", "]", ")", "\n", "return", "\n", "}" ]

[ "Delete", "a", "document", "." ]

[ "func", "(", "part", "*", "Partition", ")", "ForEachDoc", "(", "partNum", ",", "totalPart", "int", ",", "fun", "func", "(", "id", "int", ",", "doc", "[", "]", "byte", ")", "bool", ")", "(", "moveOn", "bool", ")", "{", "ids", ",", "physIDs", ":=", "part", ".", "lookup", ".", "GetPartition", "(", "partNum", ",", "totalPart", ")", "\n", "for", "i", ",", "id", ":=", "range", "ids", "{", "data", ":=", "part", ".", "col", ".", "Read", "(", "physIDs", "[", "i", "]", ")", "\n", "if", "data", "!=", "nil", "{", "if", "!", "fun", "(", "id", ",", "data", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Partition", "documents", "into", "roughly", "equally", "sized", "portions", "and", "run", "the", "function", "on", "every", "document", "in", "the", "portion", "." ]

[ "func", "(", "part", "*", "Partition", ")", "ApproxDocCount", "(", ")", "int", "{", "totalPart", ":=", "24", "// not magic; a larger number makes estimation less accurate, but improves performance", "\n", "for", "{", "keys", ",", "_", ":=", "part", ".", "lookup", ".", "GetPartition", "(", "0", ",", "totalPart", ")", "\n", "if", "len", "(", "keys", ")", "==", "0", "{", "if", "totalPart", "<", "8", "{", "return", "0", "// the hash table is really really empty", "\n", "}", "\n", "// Try a larger partition size", "totalPart", "=", "totalPart", "/", "2", "\n", "}", "else", "{", "return", "int", "(", "float64", "(", "len", "(", "keys", ")", ")", "*", "float64", "(", "totalPart", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Return", "approximate", "number", "of", "documents", "in", "the", "partition", "." ]

[ "func", "(", "part", "*", "Partition", ")", "Close", "(", ")", "error", "{", "var", "err", "error", "\n\n", "if", "e", ":=", "part", ".", "col", ".", "Close", "(", ")", ";", "e", "!=", "nil", "{", "tdlog", ".", "CritNoRepeat", "(", "\"", "\"", ",", "part", ".", "col", ".", "Path", ",", "e", ")", "\n", "err", "=", "dberr", ".", "New", "(", "dberr", ".", "ErrorIO", ")", "\n", "}", "\n", "if", "e", ":=", "part", ".", "lookup", ".", "Close", "(", ")", ";", "e", "!=", "nil", "{", "tdlog", ".", "CritNoRepeat", "(", "\"", "\"", ",", "part", ".", "lookup", ".", "Path", ",", "e", ")", "\n", "err", "=", "dberr", ".", "New", "(", "dberr", ".", "ErrorIO", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Close", "all", "file", "handles", "." ]

[ "func", "Map", "(", "f", "*", "os", ".", "File", ")", "(", "MMap", ",", "error", ")", "{", "fd", ":=", "uintptr", "(", "f", ".", "Fd", "(", ")", ")", "\n", "fi", ",", "err", ":=", "f", ".", "Stat", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "length", ":=", "int", "(", "fi", ".", "Size", "(", ")", ")", "\n", "if", "int64", "(", "length", ")", "!=", "fi", ".", "Size", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "mmap", "(", "length", ",", "fd", ")", "\n", "}" ]

[ "Map", "maps", "an", "entire", "file", "into", "memory", ".", "Note", "that", "because", "of", "runtime", "limitations", "no", "file", "larger", "than", "about", "2GB", "can", "be", "completely", "mapped", "into", "memory", "." ]

[ "func", "(", "m", "*", "MMap", ")", "Unmap", "(", ")", "error", "{", "dh", ":=", "m", ".", "header", "(", ")", "\n", "err", ":=", "unmap", "(", "dh", ".", "Data", ",", "uintptr", "(", "dh", ".", "Len", ")", ")", "\n", "*", "m", "=", "nil", "\n", "return", "err", "\n", "}" ]

[ "Unmap", "deletes", "the", "memory", "mapped", "region", "flushes", "any", "remaining", "changes", "and", "sets", "m", "to", "nil", ".", "Trying", "to", "read", "or", "write", "any", "remaining", "references", "to", "m", "after", "Unmap", "is", "called", "will", "result", "in", "undefined", "behavior", ".", "Unmap", "should", "only", "be", "called", "on", "the", "slice", "value", "that", "was", "originally", "returned", "from", "a", "call", "to", "Map", ".", "Calling", "Unmap", "on", "a", "derived", "slice", "may", "cause", "errors", "." ]

[ "func", "Query", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "var", "col", ",", "q", "string", "\n", "if", "!", "Require", "(", "w", ",", "r", ",", "\"", "\"", ",", "&", "col", ")", "{", "return", "\n", "}", "\n", "if", "!", "Require", "(", "w", ",", "r", ",", "\"", "\"", ",", "&", "q", ")", "{", "return", "\n", "}", "\n", "var", "qJson", "interface", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "q", ")", ",", "&", "qJson", ")", ";", "err", "!=", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "q", ")", ",", "400", ")", "\n", "return", "\n", "}", "\n", "dbcol", ":=", "HttpDB", ".", "Use", "(", "col", ")", "\n", "if", "dbcol", "==", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "col", ")", ",", "400", ")", "\n", "return", "\n", "}", "\n", "// Evaluate the query", "queryResult", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "if", "err", ":=", "db", ".", "EvalQuery", "(", "qJson", ",", "dbcol", ",", "&", "queryResult", ")", ";", "err", "!=", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprint", "(", "err", ")", ",", "400", ")", "\n", "return", "\n", "}", "\n", "// Construct array of result", "resultDocs", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "len", "(", "queryResult", ")", ")", "\n", "counter", ":=", "0", "\n", "for", "docID", ":=", "range", "queryResult", "{", "doc", ",", "_", ":=", "dbcol", ".", "Read", "(", "docID", ")", "\n", "if", "doc", "!=", "nil", "{", "resultDocs", "[", "strconv", ".", "Itoa", "(", "docID", ")", "]", "=", "doc", "\n", "counter", "++", "\n", "}", "\n", "}", "\n", "// Serialize the array", "resp", ",", "err", ":=", "json", ".", "Marshal", "(", "resultDocs", ")", "\n", "if", "err", "!=", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ")", ",", "500", ")", "\n", "return", "\n", "}", "\n", "w", ".", "Write", "(", "[", "]", "byte", "(", "string", "(", "resp", ")", ")", ")", "\n", "}" ]

[ "Execute", "a", "query", "and", "return", "documents", "from", "the", "result", "." ]

[ "func", "Count", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "var", "col", ",", "q", "string", "\n", "if", "!", "Require", "(", "w", ",", "r", ",", "\"", "\"", ",", "&", "col", ")", "{", "return", "\n", "}", "\n", "if", "!", "Require", "(", "w", ",", "r", ",", "\"", "\"", ",", "&", "q", ")", "{", "return", "\n", "}", "\n", "var", "qJson", "interface", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "q", ")", ",", "&", "qJson", ")", ";", "err", "!=", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "q", ")", ",", "400", ")", "\n", "return", "\n", "}", "\n", "dbcol", ":=", "HttpDB", ".", "Use", "(", "col", ")", "\n", "if", "dbcol", "==", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "col", ")", ",", "400", ")", "\n", "return", "\n", "}", "\n", "queryResult", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "if", "err", ":=", "db", ".", "EvalQuery", "(", "qJson", ",", "dbcol", ",", "&", "queryResult", ")", ";", "err", "!=", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprint", "(", "err", ")", ",", "400", ")", "\n", "return", "\n", "}", "\n", "w", ".", "Write", "(", "[", "]", "byte", "(", "strconv", ".", "Itoa", "(", "len", "(", "queryResult", ")", ")", ")", ")", "\n", "}" ]

[ "Execute", "a", "query", "and", "return", "number", "of", "documents", "from", "the", "result", "." ]

[ "func", "OpenCol", "(", "db", "*", "DB", ",", "name", "string", ")", "(", "*", "Col", ",", "error", ")", "{", "col", ":=", "&", "Col", "{", "db", ":", "db", ",", "name", ":", "name", "}", "\n", "return", "col", ",", "col", ".", "load", "(", ")", "\n", "}" ]

[ "Open", "a", "collection", "and", "load", "all", "indexes", "." ]

[ "func", "(", "col", "*", "Col", ")", "load", "(", ")", "error", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "path", ".", "Join", "(", "col", ".", "db", ".", "path", ",", "col", ".", "name", ")", ",", "0700", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "col", ".", "parts", "=", "make", "(", "[", "]", "*", "data", ".", "Partition", ",", "col", ".", "db", ".", "numParts", ")", "\n", "col", ".", "hts", "=", "make", "(", "[", "]", "map", "[", "string", "]", "*", "data", ".", "HashTable", ",", "col", ".", "db", ".", "numParts", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "col", ".", "db", ".", "numParts", ";", "i", "++", "{", "col", ".", "hts", "[", "i", "]", "=", "make", "(", "map", "[", "string", "]", "*", "data", ".", "HashTable", ")", "\n", "}", "\n", "col", ".", "indexPaths", "=", "make", "(", "map", "[", "string", "]", "[", "]", "string", ")", "\n", "// Open collection document partitions", "for", "i", ":=", "0", ";", "i", "<", "col", ".", "db", ".", "numParts", ";", "i", "++", "{", "var", "err", "error", "\n", "if", "col", ".", "parts", "[", "i", "]", ",", "err", "=", "col", ".", "db", ".", "Config", ".", "OpenPartition", "(", "path", ".", "Join", "(", "col", ".", "db", ".", "path", ",", "col", ".", "name", ",", "DOC_DATA_FILE", "+", "strconv", ".", "Itoa", "(", "i", ")", ")", ",", "path", ".", "Join", "(", "col", ".", "db", ".", "path", ",", "col", ".", "name", ",", "DOC_LOOKUP_FILE", "+", "strconv", ".", "Itoa", "(", "i", ")", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "// Look for index directories", "colDirContent", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "path", ".", "Join", "(", "col", ".", "db", ".", "path", ",", "col", ".", "name", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "htDir", ":=", "range", "colDirContent", "{", "if", "!", "htDir", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n", "// Open index partitions", "idxName", ":=", "htDir", ".", "Name", "(", ")", "\n", "idxPath", ":=", "strings", ".", "Split", "(", "idxName", ",", "INDEX_PATH_SEP", ")", "\n", "col", ".", "indexPaths", "[", "idxName", "]", "=", "idxPath", "\n", "for", "i", ":=", "0", ";", "i", "<", "col", ".", "db", ".", "numParts", ";", "i", "++", "{", "if", "col", ".", "hts", "[", "i", "]", "[", "idxName", "]", ",", "err", "=", "col", ".", "db", ".", "Config", ".", "OpenHashTable", "(", "path", ".", "Join", "(", "col", ".", "db", ".", "path", ",", "col", ".", "name", ",", "idxName", ",", "strconv", ".", "Itoa", "(", "i", ")", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Load", "collection", "schema", "including", "index", "schema", "." ]

[ "func", "(", "col", "*", "Col", ")", "close", "(", ")", "error", "{", "errs", ":=", "make", "(", "[", "]", "error", ",", "0", ",", "0", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "col", ".", "db", ".", "numParts", ";", "i", "++", "{", "col", ".", "parts", "[", "i", "]", ".", "DataLock", ".", "Lock", "(", ")", "\n", "if", "err", ":=", "col", ".", "parts", "[", "i", "]", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "\n", "for", "_", ",", "ht", ":=", "range", "col", ".", "hts", "[", "i", "]", "{", "if", "err", ":=", "ht", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "\n", "}", "\n", "col", ".", "parts", "[", "i", "]", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "len", "(", "errs", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "errs", ")", "\n", "}" ]

[ "Close", "all", "collection", "files", ".", "Do", "not", "use", "the", "collection", "afterwards!" ]

[ "func", "(", "col", "*", "Col", ")", "ForEachDoc", "(", "fun", "func", "(", "id", "int", ",", "doc", "[", "]", "byte", ")", "(", "moveOn", "bool", ")", ")", "{", "col", ".", "forEachDoc", "(", "fun", ",", "true", ")", "\n", "}" ]

[ "Do", "fun", "for", "all", "documents", "in", "the", "collection", "." ]

[ "func", "(", "col", "*", "Col", ")", "Index", "(", "idxPath", "[", "]", "string", ")", "(", "err", "error", ")", "{", "col", ".", "db", ".", "schemaLock", ".", "Lock", "(", ")", "\n", "defer", "col", ".", "db", ".", "schemaLock", ".", "Unlock", "(", ")", "\n", "idxName", ":=", "strings", ".", "Join", "(", "idxPath", ",", "INDEX_PATH_SEP", ")", "\n", "if", "_", ",", "exists", ":=", "col", ".", "indexPaths", "[", "idxName", "]", ";", "exists", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "idxPath", ")", "\n", "}", "\n", "col", ".", "indexPaths", "[", "idxName", "]", "=", "idxPath", "\n", "idxDir", ":=", "path", ".", "Join", "(", "col", ".", "db", ".", "path", ",", "col", ".", "name", ",", "idxName", ")", "\n", "if", "err", "=", "os", ".", "MkdirAll", "(", "idxDir", ",", "0700", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "col", ".", "db", ".", "numParts", ";", "i", "++", "{", "if", "col", ".", "hts", "[", "i", "]", "[", "idxName", "]", ",", "err", "=", "col", ".", "db", ".", "Config", ".", "OpenHashTable", "(", "path", ".", "Join", "(", "idxDir", ",", "strconv", ".", "Itoa", "(", "i", ")", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "// Put all documents on the new index", "col", ".", "forEachDoc", "(", "func", "(", "id", "int", ",", "doc", "[", "]", "byte", ")", "(", "moveOn", "bool", ")", "{", "var", "docObj", "map", "[", "string", "]", "interface", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "doc", ",", "&", "docObj", ")", ";", "err", "!=", "nil", "{", "// Skip corrupted document", "return", "true", "\n", "}", "\n", "for", "_", ",", "idxVal", ":=", "range", "GetIn", "(", "docObj", ",", "idxPath", ")", "{", "if", "idxVal", "!=", "nil", "{", "hashKey", ":=", "StrHash", "(", "fmt", ".", "Sprint", "(", "idxVal", ")", ")", "\n", "col", ".", "hts", "[", "hashKey", "%", "col", ".", "db", ".", "numParts", "]", "[", "idxName", "]", ".", "Put", "(", "hashKey", ",", "id", ")", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", ",", "false", ")", "\n", "return", "\n", "}" ]

[ "Create", "an", "index", "on", "the", "path", "." ]

[ "func", "(", "col", "*", "Col", ")", "AllIndexes", "(", ")", "(", "ret", "[", "]", "[", "]", "string", ")", "{", "col", ".", "db", ".", "schemaLock", ".", "RLock", "(", ")", "\n", "defer", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "ret", "=", "make", "(", "[", "]", "[", "]", "string", ",", "0", ",", "len", "(", "col", ".", "indexPaths", ")", ")", "\n", "for", "_", ",", "path", ":=", "range", "col", ".", "indexPaths", "{", "pathCopy", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "path", ")", ")", "\n", "for", "i", ",", "p", ":=", "range", "path", "{", "pathCopy", "[", "i", "]", "=", "p", "\n", "}", "\n", "ret", "=", "append", "(", "ret", ",", "pathCopy", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Return", "all", "indexed", "paths", "." ]

[ "func", "(", "col", "*", "Col", ")", "Unindex", "(", "idxPath", "[", "]", "string", ")", "error", "{", "col", ".", "db", ".", "schemaLock", ".", "Lock", "(", ")", "\n", "defer", "col", ".", "db", ".", "schemaLock", ".", "Unlock", "(", ")", "\n", "idxName", ":=", "strings", ".", "Join", "(", "idxPath", ",", "INDEX_PATH_SEP", ")", "\n", "if", "_", ",", "exists", ":=", "col", ".", "indexPaths", "[", "idxName", "]", ";", "!", "exists", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "idxPath", ")", "\n", "}", "\n", "delete", "(", "col", ".", "indexPaths", ",", "idxName", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "col", ".", "db", ".", "numParts", ";", "i", "++", "{", "col", ".", "hts", "[", "i", "]", "[", "idxName", "]", ".", "Close", "(", ")", "\n", "delete", "(", "col", ".", "hts", "[", "i", "]", ",", "idxName", ")", "\n", "}", "\n", "if", "err", ":=", "os", ".", "RemoveAll", "(", "path", ".", "Join", "(", "col", ".", "db", ".", "path", ",", "col", ".", "name", ",", "idxName", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Remove", "an", "index", "." ]

[ "func", "(", "col", "*", "Col", ")", "ForEachDocInPage", "(", "page", ",", "total", "int", ",", "fun", "func", "(", "id", "int", ",", "doc", "[", "]", "byte", ")", "bool", ")", "{", "col", ".", "db", ".", "schemaLock", ".", "RLock", "(", ")", "\n", "defer", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "for", "iteratePart", ":=", "0", ";", "iteratePart", "<", "col", ".", "db", ".", "numParts", ";", "iteratePart", "++", "{", "part", ":=", "col", ".", "parts", "[", "iteratePart", "]", "\n", "part", ".", "DataLock", ".", "RLock", "(", ")", "\n", "if", "!", "part", ".", "ForEachDoc", "(", "page", ",", "total", ",", "fun", ")", "{", "part", ".", "DataLock", ".", "RUnlock", "(", ")", "\n", "return", "\n", "}", "\n", "part", ".", "DataLock", ".", "RUnlock", "(", ")", "\n", "}", "\n", "}" ]

[ "Divide", "the", "collection", "into", "roughly", "equally", "sized", "pages", "and", "do", "fun", "on", "all", "documents", "in", "the", "specified", "page", "." ]

[ "func", "GetIn", "(", "doc", "interface", "{", "}", ",", "path", "[", "]", "string", ")", "(", "ret", "[", "]", "interface", "{", "}", ")", "{", "docMap", ",", "ok", ":=", "doc", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n", "var", "thing", "interface", "{", "}", "=", "docMap", "\n", "// Get into each path segment", "for", "i", ",", "seg", ":=", "range", "path", "{", "if", "aMap", ",", "ok", ":=", "thing", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ";", "ok", "{", "thing", "=", "aMap", "[", "seg", "]", "\n", "}", "else", "if", "anArray", ",", "ok", ":=", "thing", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "for", "_", ",", "element", ":=", "range", "anArray", "{", "ret", "=", "append", "(", "ret", ",", "GetIn", "(", "element", ",", "path", "[", "i", ":", "]", ")", "...", ")", "\n", "}", "\n", "return", "ret", "\n", "}", "else", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "switch", "thing", ":=", "thing", ".", "(", "type", ")", "{", "case", "[", "]", "interface", "{", "}", ":", "return", "append", "(", "ret", ",", "thing", "...", ")", "\n", "default", ":", "return", "append", "(", "ret", ",", "thing", ")", "\n", "}", "\n", "}" ]

[ "Resolve", "the", "attribute", "(", "s", ")", "in", "the", "document", "structure", "along", "the", "given", "path", "." ]

[ "func", "StrHash", "(", "str", "string", ")", "int", "{", "var", "hash", "int", "\n", "for", "_", ",", "c", ":=", "range", "str", "{", "hash", "=", "int", "(", "c", ")", "+", "(", "hash", "<<", "6", ")", "+", "(", "hash", "<<", "16", ")", "-", "hash", "\n", "}", "\n", "if", "hash", "<", "0", "{", "return", "-", "hash", "\n", "}", "\n", "return", "hash", "\n", "}" ]

[ "Hash", "a", "string", "using", "sdbm", "algorithm", "." ]

[ "func", "(", "col", "*", "Col", ")", "indexDoc", "(", "id", "int", ",", "doc", "map", "[", "string", "]", "interface", "{", "}", ")", "{", "for", "idxName", ",", "idxPath", ":=", "range", "col", ".", "indexPaths", "{", "for", "_", ",", "idxVal", ":=", "range", "GetIn", "(", "doc", ",", "idxPath", ")", "{", "if", "idxVal", "!=", "nil", "{", "hashKey", ":=", "StrHash", "(", "fmt", ".", "Sprint", "(", "idxVal", ")", ")", "\n", "partNum", ":=", "hashKey", "%", "col", ".", "db", ".", "numParts", "\n", "ht", ":=", "col", ".", "hts", "[", "partNum", "]", "[", "idxName", "]", "\n", "ht", ".", "Lock", ".", "Lock", "(", ")", "\n", "ht", ".", "Put", "(", "hashKey", ",", "id", ")", "\n", "ht", ".", "Lock", ".", "Unlock", "(", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Put", "a", "document", "on", "all", "user", "-", "created", "indexes", "." ]

[ "func", "(", "col", "*", "Col", ")", "InsertRecovery", "(", "id", "int", ",", "doc", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "err", "error", ")", "{", "docJS", ",", "err", ":=", "json", ".", "Marshal", "(", "doc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "partNum", ":=", "id", "%", "col", ".", "db", ".", "numParts", "\n", "part", ":=", "col", ".", "parts", "[", "partNum", "]", "\n", "// Put document data into collection", "if", "_", ",", "err", "=", "part", ".", "Insert", "(", "id", ",", "[", "]", "byte", "(", "docJS", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "// Index the document", "col", ".", "indexDoc", "(", "id", ",", "doc", ")", "\n", "return", "\n", "}" ]

[ "Insert", "a", "document", "with", "the", "specified", "ID", "into", "the", "collection", "(", "incl", ".", "index", ")", ".", "Does", "not", "place", "partition", "/", "schema", "lock", "." ]

[ "func", "(", "col", "*", "Col", ")", "Insert", "(", "doc", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "id", "int", ",", "err", "error", ")", "{", "docJS", ",", "err", ":=", "json", ".", "Marshal", "(", "doc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "id", "=", "rand", ".", "Int", "(", ")", "\n", "partNum", ":=", "id", "%", "col", ".", "db", ".", "numParts", "\n", "col", ".", "db", ".", "schemaLock", ".", "RLock", "(", ")", "\n", "part", ":=", "col", ".", "parts", "[", "partNum", "]", "\n\n", "// Put document data into collection", "part", ".", "DataLock", ".", "Lock", "(", ")", "\n", "_", ",", "err", "=", "part", ".", "Insert", "(", "id", ",", "[", "]", "byte", "(", "docJS", ")", ")", "\n", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "\n", "}", "\n\n", "part", ".", "LockUpdate", "(", "id", ")", "\n", "// Index the document", "col", ".", "indexDoc", "(", "id", ",", "doc", ")", "\n", "part", ".", "UnlockUpdate", "(", "id", ")", "\n\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "\n", "}" ]

[ "Insert", "a", "document", "into", "the", "collection", "." ]

[ "func", "(", "col", "*", "Col", ")", "Read", "(", "id", "int", ")", "(", "doc", "map", "[", "string", "]", "interface", "{", "}", ",", "err", "error", ")", "{", "return", "col", ".", "read", "(", "id", ",", "true", ")", "\n", "}" ]

[ "Find", "and", "retrieve", "a", "document", "by", "ID", "." ]

[ "func", "(", "col", "*", "Col", ")", "Update", "(", "id", "int", ",", "doc", "map", "[", "string", "]", "interface", "{", "}", ")", "error", "{", "if", "doc", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "docJS", ",", "err", ":=", "json", ".", "Marshal", "(", "doc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "col", ".", "db", ".", "schemaLock", ".", "RLock", "(", ")", "\n", "part", ":=", "col", ".", "parts", "[", "id", "%", "col", ".", "db", ".", "numParts", "]", "\n\n", "// Place lock, read back original document and update", "part", ".", "DataLock", ".", "Lock", "(", ")", "\n", "originalB", ",", "err", ":=", "part", ".", "Read", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n", "err", "=", "part", ".", "Update", "(", "id", ",", "[", "]", "byte", "(", "docJS", ")", ")", "\n", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Done with the collection data, next is to maintain indexed values", "var", "original", "map", "[", "string", "]", "interface", "{", "}", "\n", "json", ".", "Unmarshal", "(", "originalB", ",", "&", "original", ")", "\n", "part", ".", "LockUpdate", "(", "id", ")", "\n", "if", "original", "!=", "nil", "{", "col", ".", "unindexDoc", "(", "id", ",", "original", ")", "\n", "}", "else", "{", "tdlog", ".", "Noticef", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "col", ".", "indexDoc", "(", "id", ",", "doc", ")", "\n", "// Done with the index", "part", ".", "UnlockUpdate", "(", "id", ")", "\n\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Update", "a", "document", "." ]

[ "func", "(", "col", "*", "Col", ")", "UpdateBytesFunc", "(", "id", "int", ",", "update", "func", "(", "origDoc", "[", "]", "byte", ")", "(", "newDoc", "[", "]", "byte", ",", "err", "error", ")", ")", "error", "{", "col", ".", "db", ".", "schemaLock", ".", "RLock", "(", ")", "\n", "part", ":=", "col", ".", "parts", "[", "id", "%", "col", ".", "db", ".", "numParts", "]", "\n\n", "// Place lock, read back original document and update", "part", ".", "DataLock", ".", "Lock", "(", ")", "\n", "originalB", ",", "err", ":=", "part", ".", "Read", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n", "var", "original", "map", "[", "string", "]", "interface", "{", "}", "\n", "json", ".", "Unmarshal", "(", "originalB", ",", "&", "original", ")", "// Unmarshal originalB before passing it to update", "\n", "docB", ",", "err", ":=", "update", "(", "originalB", ")", "\n", "if", "err", "!=", "nil", "{", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n", "var", "doc", "map", "[", "string", "]", "interface", "{", "}", "// check if docB are valid JSON before Update", "\n", "if", "err", "=", "json", ".", "Unmarshal", "(", "docB", ",", "&", "doc", ")", ";", "err", "!=", "nil", "{", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n", "err", "=", "part", ".", "Update", "(", "id", ",", "docB", ")", "\n", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Done with the collection data, next is to maintain indexed values", "part", ".", "LockUpdate", "(", "id", ")", "\n", "if", "original", "!=", "nil", "{", "col", ".", "unindexDoc", "(", "id", ",", "original", ")", "\n", "}", "else", "{", "tdlog", ".", "Noticef", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "col", ".", "indexDoc", "(", "id", ",", "doc", ")", "\n", "// Done with the index", "part", ".", "UnlockUpdate", "(", "id", ")", "\n\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "UpdateBytesFunc", "will", "update", "a", "document", "bytes", ".", "update", "func", "will", "get", "current", "document", "bytes", "and", "should", "return", "bytes", "of", "updated", "document", ";", "updated", "document", "should", "be", "valid", "JSON", ";", "provided", "buffer", "could", "be", "modified", "(", "reused", "for", "returned", "value", ")", ";", "non", "-", "nil", "error", "will", "be", "propagated", "back", "and", "returned", "from", "UpdateBytesFunc", "." ]

[ "func", "(", "col", "*", "Col", ")", "Delete", "(", "id", "int", ")", "error", "{", "col", ".", "db", ".", "schemaLock", ".", "RLock", "(", ")", "\n", "part", ":=", "col", ".", "parts", "[", "id", "%", "col", ".", "db", ".", "numParts", "]", "\n\n", "// Place lock, read back original document and delete document", "part", ".", "DataLock", ".", "Lock", "(", ")", "\n", "originalB", ",", "err", ":=", "part", ".", "Read", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n", "err", "=", "part", ".", "Delete", "(", "id", ")", "\n", "part", ".", "DataLock", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Done with the collection data, next is to remove indexed values", "var", "original", "map", "[", "string", "]", "interface", "{", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "originalB", ",", "&", "original", ")", "\n", "if", "err", "==", "nil", "{", "part", ".", "LockUpdate", "(", "id", ")", "\n", "col", ".", "unindexDoc", "(", "id", ",", "original", ")", "\n", "part", ".", "UnlockUpdate", "(", "id", ")", "\n", "}", "else", "{", "tdlog", ".", "Noticef", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n\n", "col", ".", "db", ".", "schemaLock", ".", "RUnlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Delete", "a", "document", "." ]

[ "func", "CritNoRepeat", "(", "template", "string", ",", "params", "...", "interface", "{", "}", ")", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "template", ",", "params", "...", ")", "\n", "critLock", ".", "Lock", "(", ")", "\n", "if", "_", ",", "exists", ":=", "critHistory", "[", "msg", "]", ";", "!", "exists", "{", "log", ".", "Print", "(", "msg", ")", "\n", "critHistory", "[", "msg", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "if", "len", "(", "critHistory", ")", ">", "limitCritHistory", "{", "critHistory", "=", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", "\n", "}", "\n", "critLock", ".", "Unlock", "(", ")", "\n", "}" ]

[ "LVL", "2", "-", "will", "not", "repeat", "a", "message", "twice", "over", "the", "past", "100", "distinct", "crit", "messages" ]

[ "func", "EmbeddedExample", "(", ")", "{", "// ****************** Collection Management ******************", "myDBDir", ":=", "\"", "\"", "\n", "os", ".", "RemoveAll", "(", "myDBDir", ")", "\n", "defer", "os", ".", "RemoveAll", "(", "myDBDir", ")", "\n\n", "// (Create if not exist) open a database", "myDB", ",", "err", ":=", "db", ".", "OpenDB", "(", "myDBDir", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// Create two collections: Feeds and Votes", "if", "err", ":=", "myDB", ".", "Create", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "myDB", ".", "Create", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// What collections do I now have?", "for", "_", ",", "name", ":=", "range", "myDB", ".", "AllCols", "(", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "name", ")", "\n", "}", "\n\n", "// Rename collection \"Votes\" to \"Points\"", "if", "err", ":=", "myDB", ".", "Rename", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// Drop (delete) collection \"Points\"", "if", "err", ":=", "myDB", ".", "Drop", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// Scrub (repair and compact) \"Feeds\"", "if", "err", ":=", "myDB", ".", "Scrub", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// ****************** Document Management ******************", "// Start using a collection (the reference is valid until DB schema changes or Scrub is carried out)", "feeds", ":=", "myDB", ".", "Use", "(", "\"", "\"", ")", "\n\n", "// Insert document (afterwards the docID uniquely identifies the document and will never change)", "docID", ",", "err", ":=", "feeds", ".", "Insert", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", "}", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// Read document", "readBack", ",", "err", ":=", "feeds", ".", "Read", "(", "docID", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "fmt", ".", "Println", "(", "\"", "\"", ",", "docID", ",", "\"", "\"", ",", "readBack", ")", "\n\n", "// Update document", "err", "=", "feeds", ".", "Update", "(", "docID", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", "}", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// Process all documents (note that document order is undetermined)", "feeds", ".", "ForEachDoc", "(", "func", "(", "id", "int", ",", "docContent", "[", "]", "byte", ")", "(", "willMoveOn", "bool", ")", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "id", ",", "\"", "\"", ",", "string", "(", "docContent", ")", ")", "\n", "return", "true", "// move on to the next document OR", "\n", "return", "false", "// do not move on to the next document", "\n", "}", ")", "\n\n", "// Delete document", "if", "err", ":=", "feeds", ".", "Delete", "(", "docID", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// More complicated error handing - identify the error Type.", "// In this example, the error code tells that the document no longer exists.", "if", "err", ":=", "feeds", ".", "Delete", "(", "docID", ")", ";", "dberr", ".", "Type", "(", "err", ")", "==", "dberr", ".", "ErrorNoDoc", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// ****************** Index Management ******************", "// Indexes assist in many types of queries", "// Create index (path leads to document JSON attribute)", "if", "err", ":=", "feeds", ".", "Index", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "feeds", ".", "Index", "(", "[", "]", "string", "{", "\"", "\"", "}", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "feeds", ".", "Index", "(", "[", "]", "string", "{", "\"", "\"", "}", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// What indexes do I have on collection A?", "for", "_", ",", "path", ":=", "range", "feeds", ".", "AllIndexes", "(", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "path", ")", "\n", "}", "\n\n", "// Remove index", "if", "err", ":=", "feeds", ".", "Unindex", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// ****************** Queries ******************", "// Prepare some documents for the query", "feeds", ".", "Insert", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "3", "}", ")", "\n", "feeds", ".", "Insert", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "2", "}", ")", "\n", "feeds", ".", "Insert", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "1", "}", ")", "\n\n", "var", "query", "interface", "{", "}", "\n", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "`[{\"eq\": \"New Go release\", \"in\": [\"Title\"]}, {\"eq\": \"slackware.com\", \"in\": [\"Source\"]}]`", ")", ",", "&", "query", ")", "\n\n", "queryResult", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "// query result (document IDs) goes into map keys", "\n\n", "if", "err", ":=", "db", ".", "EvalQuery", "(", "query", ",", "feeds", ",", "&", "queryResult", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "// Query result are document IDs", "for", "id", ":=", "range", "queryResult", "{", "// To get query result document, simply read it", "readBack", ",", "err", ":=", "feeds", ".", "Read", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "readBack", ")", "\n", "}", "\n\n", "// Gracefully close database", "if", "err", ":=", "myDB", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "/", "*", "In", "embedded", "usage", "you", "are", "encouraged", "to", "use", "all", "public", "functions", "concurrently", ".", "However", "please", "do", "not", "use", "public", "functions", "in", "data", "package", "by", "yourself", "-", "you", "most", "likely", "will", "not", "need", "to", "use", "them", "directly", "." ]

[ "func", "EvalUnion", "(", "exprs", "[", "]", "interface", "{", "}", ",", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "for", "_", ",", "subExpr", ":=", "range", "exprs", "{", "if", "err", "=", "evalQuery", "(", "subExpr", ",", "src", ",", "result", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Calculate", "union", "of", "sub", "-", "query", "results", "." ]

[ "func", "EvalAllIDs", "(", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "src", ".", "forEachDoc", "(", "func", "(", "id", "int", ",", "_", "[", "]", "byte", ")", "bool", "{", "(", "*", "result", ")", "[", "id", "]", "=", "struct", "{", "}", "{", "}", "\n", "return", "true", "\n", "}", ",", "false", ")", "\n", "return", "\n", "}" ]

[ "Put", "all", "document", "IDs", "into", "result", "." ]

[ "func", "Lookup", "(", "lookupValue", "interface", "{", "}", ",", "expr", "map", "[", "string", "]", "interface", "{", "}", ",", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "// Figure out lookup path - JSON array \"in\"", "path", ",", "hasPath", ":=", "expr", "[", "\"", "\"", "]", "\n", "if", "!", "hasPath", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "vecPath", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "if", "vecPathInterface", ",", "ok", ":=", "path", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "for", "_", ",", "v", ":=", "range", "vecPathInterface", "{", "vecPath", "=", "append", "(", "vecPath", ",", "fmt", ".", "Sprint", "(", "v", ")", ")", "\n", "}", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "// Figure out result number limit", "intLimit", ":=", "int", "(", "0", ")", "\n", "if", "limit", ",", "hasLimit", ":=", "expr", "[", "\"", "\"", "]", ";", "hasLimit", "{", "if", "floatLimit", ",", "ok", ":=", "limit", ".", "(", "float64", ")", ";", "ok", "{", "intLimit", "=", "int", "(", "floatLimit", ")", "\n", "}", "else", "if", "_", ",", "ok", ":=", "limit", ".", "(", "int", ")", ";", "ok", "{", "intLimit", "=", "limit", ".", "(", "int", ")", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingInt", ",", "\"", "\"", ",", "limit", ")", "\n", "}", "\n", "}", "\n", "lookupStrValue", ":=", "fmt", ".", "Sprint", "(", "lookupValue", ")", "// the value to look for", "\n", "lookupValueHash", ":=", "StrHash", "(", "lookupStrValue", ")", "\n", "scanPath", ":=", "strings", ".", "Join", "(", "vecPath", ",", "INDEX_PATH_SEP", ")", "\n", "if", "_", ",", "indexed", ":=", "src", ".", "indexPaths", "[", "scanPath", "]", ";", "!", "indexed", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorNeedIndex", ",", "scanPath", ",", "expr", ")", "\n", "}", "\n", "num", ":=", "lookupValueHash", "%", "src", ".", "db", ".", "numParts", "\n", "ht", ":=", "src", ".", "hts", "[", "num", "]", "[", "scanPath", "]", "\n", "ht", ".", "Lock", ".", "RLock", "(", ")", "\n", "vals", ":=", "ht", ".", "Get", "(", "lookupValueHash", ",", "intLimit", ")", "\n", "ht", ".", "Lock", ".", "RUnlock", "(", ")", "\n", "for", "_", ",", "match", ":=", "range", "vals", "{", "// Filter result to avoid hash collision", "if", "doc", ",", "err", ":=", "src", ".", "read", "(", "match", ",", "false", ")", ";", "err", "==", "nil", "{", "for", "_", ",", "v", ":=", "range", "GetIn", "(", "doc", ",", "vecPath", ")", "{", "if", "fmt", ".", "Sprint", "(", "v", ")", "==", "lookupStrValue", "{", "(", "*", "result", ")", "[", "match", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Value", "equity", "check", "(", "attribute", "==", "value", ")", "using", "hash", "lookup", "." ]

[ "func", "PathExistence", "(", "hasPath", "interface", "{", "}", ",", "expr", "map", "[", "string", "]", "interface", "{", "}", ",", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "// Figure out the path", "vecPath", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "if", "vecPathInterface", ",", "ok", ":=", "hasPath", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "for", "_", ",", "v", ":=", "range", "vecPathInterface", "{", "vecPath", "=", "append", "(", "vecPath", ",", "fmt", ".", "Sprint", "(", "v", ")", ")", "\n", "}", "\n", "}", "else", "{", "return", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "hasPath", ")", ")", "\n", "}", "\n", "// Figure out result number limit", "intLimit", ":=", "0", "\n", "if", "limit", ",", "hasLimit", ":=", "expr", "[", "\"", "\"", "]", ";", "hasLimit", "{", "if", "floatLimit", ",", "ok", ":=", "limit", ".", "(", "float64", ")", ";", "ok", "{", "intLimit", "=", "int", "(", "floatLimit", ")", "\n", "}", "else", "if", "_", ",", "ok", ":=", "limit", ".", "(", "int", ")", ";", "ok", "{", "intLimit", "=", "limit", ".", "(", "int", ")", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingInt", ",", "\"", "\"", ",", "limit", ")", "\n", "}", "\n", "}", "\n", "jointPath", ":=", "strings", ".", "Join", "(", "vecPath", ",", "INDEX_PATH_SEP", ")", "\n", "if", "_", ",", "indexed", ":=", "src", ".", "indexPaths", "[", "jointPath", "]", ";", "!", "indexed", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorNeedIndex", ",", "vecPath", ",", "expr", ")", "\n", "}", "\n", "counter", ":=", "0", "\n", "partDiv", ":=", "src", ".", "approxDocCount", "(", "false", ")", "/", "src", ".", "db", ".", "numParts", "/", "4000", "// collect approx. 4k document IDs in each iteration", "\n", "if", "partDiv", "==", "0", "{", "partDiv", "++", "\n", "}", "\n", "for", "iteratePart", ":=", "0", ";", "iteratePart", "<", "src", ".", "db", ".", "numParts", ";", "iteratePart", "++", "{", "ht", ":=", "src", ".", "hts", "[", "iteratePart", "]", "[", "jointPath", "]", "\n", "ht", ".", "Lock", ".", "RLock", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "partDiv", ";", "i", "++", "{", "_", ",", "ids", ":=", "ht", ".", "GetPartition", "(", "i", ",", "partDiv", ")", "\n", "for", "_", ",", "id", ":=", "range", "ids", "{", "(", "*", "result", ")", "[", "id", "]", "=", "struct", "{", "}", "{", "}", "\n", "counter", "++", "\n", "if", "counter", "==", "intLimit", "{", "ht", ".", "Lock", ".", "RUnlock", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "ht", ".", "Lock", ".", "RUnlock", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Value", "existence", "check", "(", "value", "!", "=", "nil", ")", "using", "hash", "lookup", "." ]

[ "func", "Intersect", "(", "subExprs", "interface", "{", "}", ",", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "myResult", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "if", "subExprVecs", ",", "ok", ":=", "subExprs", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "first", ":=", "true", "\n", "for", "_", ",", "subExpr", ":=", "range", "subExprVecs", "{", "subResult", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "intersection", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "if", "err", "=", "evalQuery", "(", "subExpr", ",", "src", ",", "&", "subResult", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "first", "{", "myResult", "=", "subResult", "\n", "first", "=", "false", "\n", "}", "else", "{", "for", "k", ":=", "range", "subResult", "{", "if", "_", ",", "inBoth", ":=", "myResult", "[", "k", "]", ";", "inBoth", "{", "intersection", "[", "k", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "myResult", "=", "intersection", "\n", "}", "\n", "}", "\n", "for", "docID", ":=", "range", "myResult", "{", "(", "*", "result", ")", "[", "docID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingSubQuery", ",", "subExprs", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Calculate", "intersection", "of", "sub", "-", "query", "results", "." ]

[ "func", "Complement", "(", "subExprs", "interface", "{", "}", ",", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "myResult", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "if", "subExprVecs", ",", "ok", ":=", "subExprs", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "for", "_", ",", "subExpr", ":=", "range", "subExprVecs", "{", "subResult", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "complement", ":=", "make", "(", "map", "[", "int", "]", "struct", "{", "}", ")", "\n", "if", "err", "=", "evalQuery", "(", "subExpr", ",", "src", ",", "&", "subResult", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "for", "k", ":=", "range", "subResult", "{", "if", "_", ",", "inBoth", ":=", "myResult", "[", "k", "]", ";", "!", "inBoth", "{", "complement", "[", "k", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "for", "k", ":=", "range", "myResult", "{", "if", "_", ",", "inBoth", ":=", "subResult", "[", "k", "]", ";", "!", "inBoth", "{", "complement", "[", "k", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "myResult", "=", "complement", "\n", "}", "\n", "for", "docID", ":=", "range", "myResult", "{", "(", "*", "result", ")", "[", "docID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingSubQuery", ",", "subExprs", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Calculate", "complement", "of", "sub", "-", "query", "results", "." ]

[ "func", "IntRange", "(", "intFrom", "interface", "{", "}", ",", "expr", "map", "[", "string", "]", "interface", "{", "}", ",", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "path", ",", "hasPath", ":=", "expr", "[", "\"", "\"", "]", "\n", "if", "!", "hasPath", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "// Figure out the path", "vecPath", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "if", "vecPathInterface", ",", "ok", ":=", "path", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "for", "_", ",", "v", ":=", "range", "vecPathInterface", "{", "vecPath", "=", "append", "(", "vecPath", ",", "fmt", ".", "Sprint", "(", "v", ")", ")", "\n", "}", "\n", "}", "else", "{", "return", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "path", ")", ")", "\n", "}", "\n", "// Figure out result number limit", "intLimit", ":=", "int", "(", "0", ")", "\n", "if", "limit", ",", "hasLimit", ":=", "expr", "[", "\"", "\"", "]", ";", "hasLimit", "{", "if", "floatLimit", ",", "ok", ":=", "limit", ".", "(", "float64", ")", ";", "ok", "{", "intLimit", "=", "int", "(", "floatLimit", ")", "\n", "}", "else", "if", "_", ",", "ok", ":=", "limit", ".", "(", "int", ")", ";", "ok", "{", "intLimit", "=", "limit", ".", "(", "int", ")", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingInt", ",", "limit", ")", "\n", "}", "\n", "}", "\n", "// Figure out the range (\"from\" value & \"to\" value)", "from", ",", "to", ":=", "int", "(", "0", ")", ",", "int", "(", "0", ")", "\n", "if", "floatFrom", ",", "ok", ":=", "intFrom", ".", "(", "float64", ")", ";", "ok", "{", "from", "=", "int", "(", "floatFrom", ")", "\n", "}", "else", "if", "_", ",", "ok", ":=", "intFrom", ".", "(", "int", ")", ";", "ok", "{", "from", "=", "intFrom", ".", "(", "int", ")", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingInt", ",", "\"", "\"", ",", "from", ")", "\n", "}", "\n", "if", "intTo", ",", "ok", ":=", "expr", "[", "\"", "\"", "]", ";", "ok", "{", "if", "floatTo", ",", "ok", ":=", "intTo", ".", "(", "float64", ")", ";", "ok", "{", "to", "=", "int", "(", "floatTo", ")", "\n", "}", "else", "if", "_", ",", "ok", ":=", "intTo", ".", "(", "int", ")", ";", "ok", "{", "to", "=", "intTo", ".", "(", "int", ")", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingInt", ",", "\"", "\"", ",", "to", ")", "\n", "}", "\n", "}", "else", "if", "intTo", ",", "ok", ":=", "expr", "[", "\"", "\"", "]", ";", "ok", "{", "if", "floatTo", ",", "ok", ":=", "intTo", ".", "(", "float64", ")", ";", "ok", "{", "to", "=", "int", "(", "floatTo", ")", "\n", "}", "else", "if", "_", ",", "ok", ":=", "intTo", ".", "(", "int", ")", ";", "ok", "{", "to", "=", "intTo", ".", "(", "int", ")", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorExpectingInt", ",", "\"", "\"", ",", "to", ")", "\n", "}", "\n", "}", "else", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorMissing", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "to", ">", "from", "&&", "to", "-", "from", ">", "1000", "||", "from", ">", "to", "&&", "from", "-", "to", ">", "1000", "{", "tdlog", ".", "CritNoRepeat", "(", "\"", "\"", ",", "expr", ")", "\n", "}", "\n", "counter", ":=", "int", "(", "0", ")", "// Number of results already collected", "\n", "htPath", ":=", "strings", ".", "Join", "(", "vecPath", ",", "\"", "\"", ")", "\n", "if", "_", ",", "indexScan", ":=", "src", ".", "indexPaths", "[", "htPath", "]", ";", "!", "indexScan", "{", "return", "dberr", ".", "New", "(", "dberr", ".", "ErrorNeedIndex", ",", "vecPath", ",", "expr", ")", "\n", "}", "\n", "if", "from", "<", "to", "{", "// Forward scan - from low value to high value", "for", "lookupValue", ":=", "from", ";", "lookupValue", "<=", "to", ";", "lookupValue", "++", "{", "lookupStrValue", ":=", "fmt", ".", "Sprint", "(", "float64", "(", "lookupValue", ")", ")", "\n", "hashValue", ":=", "StrHash", "(", "lookupStrValue", ")", "\n", "vals", ":=", "src", ".", "hashScan", "(", "htPath", ",", "hashValue", ",", "int", "(", "intLimit", ")", ")", "\n", "for", "_", ",", "docID", ":=", "range", "vals", "{", "if", "intLimit", ">", "0", "&&", "counter", "==", "intLimit", "{", "break", "\n", "}", "\n", "counter", "++", "\n", "(", "*", "result", ")", "[", "docID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "}", "else", "{", "// Backward scan - from high value to low value", "for", "lookupValue", ":=", "from", ";", "lookupValue", ">=", "to", ";", "lookupValue", "--", "{", "lookupStrValue", ":=", "fmt", ".", "Sprint", "(", "float64", "(", "lookupValue", ")", ")", "\n", "hashValue", ":=", "StrHash", "(", "lookupStrValue", ")", "\n", "vals", ":=", "src", ".", "hashScan", "(", "htPath", ",", "hashValue", ",", "int", "(", "intLimit", ")", ")", "\n", "for", "_", ",", "docID", ":=", "range", "vals", "{", "if", "intLimit", ">", "0", "&&", "counter", "==", "intLimit", "{", "break", "\n", "}", "\n", "counter", "++", "\n", "(", "*", "result", ")", "[", "docID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Look", "for", "indexed", "integer", "values", "within", "the", "specified", "integer", "range", "." ]

[ "func", "EvalQuery", "(", "q", "interface", "{", "}", ",", "src", "*", "Col", ",", "result", "*", "map", "[", "int", "]", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "return", "evalQuery", "(", "q", ",", "src", ",", "result", ",", "true", ")", "\n", "}" ]

[ "Main", "entrance", "to", "query", "processor", "-", "evaluate", "a", "query", "and", "put", "result", "into", "result", "map", "(", "as", "map", "keys", ")", "." ]

[ "func", "LooksEmpty", "(", "buf", "gommap", ".", "MMap", ")", "bool", "{", "upTo", ":=", "1024", "\n", "if", "upTo", ">=", "len", "(", "buf", ")", "{", "upTo", "=", "len", "(", "buf", ")", "-", "1", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "upTo", ";", "i", "++", "{", "if", "buf", "[", "i", "]", "!=", "0", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Return", "true", "if", "the", "buffer", "begins", "with", "64", "consecutive", "zero", "bytes", "." ]

[ "func", "OpenDataFile", "(", "path", "string", ",", "growth", "int", ")", "(", "file", "*", "DataFile", ",", "err", "error", ")", "{", "file", "=", "&", "DataFile", "{", "Path", ":", "path", ",", "Growth", ":", "growth", "}", "\n", "if", "file", ".", "Fh", ",", "err", "=", "os", ".", "OpenFile", "(", "file", ".", "Path", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_RDWR", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "var", "size", "int64", "\n", "if", "size", ",", "err", "=", "file", ".", "Fh", ".", "Seek", "(", "0", ",", "os", ".", "SEEK_END", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "// Ensure the file is not smaller than file growth", "if", "file", ".", "Size", "=", "int", "(", "size", ")", ";", "file", ".", "Size", "<", "file", ".", "Growth", "{", "if", "err", "=", "file", ".", "EnsureSize", "(", "file", ".", "Growth", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "if", "file", ".", "Buf", "==", "nil", "{", "file", ".", "Buf", ",", "err", "=", "gommap", ".", "Map", "(", "file", ".", "Fh", ")", "\n", "}", "\n", "defer", "tdlog", ".", "Infof", "(", "\"", "\"", ",", "file", ".", "Path", ",", "file", ".", "Used", ",", "file", ".", "Size", ")", "\n", "// Bi-sect file buffer to find out how much space is in-use", "for", "low", ",", "mid", ",", "high", ":=", "0", ",", "file", ".", "Size", "/", "2", ",", "file", ".", "Size", ";", ";", "{", "switch", "{", "case", "high", "-", "mid", "==", "1", ":", "if", "LooksEmpty", "(", "file", ".", "Buf", "[", "mid", ":", "]", ")", "{", "if", "mid", ">", "0", "&&", "LooksEmpty", "(", "file", ".", "Buf", "[", "mid", "-", "1", ":", "]", ")", "{", "file", ".", "Used", "=", "mid", "-", "1", "\n", "}", "else", "{", "file", ".", "Used", "=", "mid", "\n", "}", "\n", "return", "\n", "}", "\n", "file", ".", "Used", "=", "high", "\n", "return", "\n", "case", "LooksEmpty", "(", "file", ".", "Buf", "[", "mid", ":", "]", ")", ":", "high", "=", "mid", "\n", "mid", "=", "low", "+", "(", "mid", "-", "low", ")", "/", "2", "\n", "default", ":", "low", "=", "mid", "\n", "mid", "=", "mid", "+", "(", "high", "-", "mid", ")", "/", "2", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Open", "a", "data", "file", "that", "grows", "by", "the", "specified", "size", "." ]

[ "func", "(", "file", "*", "DataFile", ")", "overwriteWithZero", "(", "from", "int", ",", "size", "int", ")", "(", "err", "error", ")", "{", "if", "_", ",", "err", "=", "file", ".", "Fh", ".", "Seek", "(", "int64", "(", "from", ")", ",", "os", ".", "SEEK_SET", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "zeroSize", ":=", "1048576", "*", "8", "// Fill 8 MB at a time", "\n", "zero", ":=", "make", "(", "[", "]", "byte", ",", "zeroSize", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "size", ";", "i", "+=", "zeroSize", "{", "var", "zeroSlice", "[", "]", "byte", "\n", "if", "i", "+", "zeroSize", ">", "size", "{", "zeroSlice", "=", "zero", "[", "0", ":", "size", "-", "i", "]", "\n", "}", "else", "{", "zeroSlice", "=", "zero", "\n", "}", "\n", "if", "_", ",", "err", "=", "file", ".", "Fh", ".", "Write", "(", "zeroSlice", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "return", "file", ".", "Fh", ".", "Sync", "(", ")", "\n", "}" ]

[ "Fill", "up", "portion", "of", "a", "file", "with", "0s", "." ]

[ "func", "(", "file", "*", "DataFile", ")", "EnsureSize", "(", "more", "int", ")", "(", "err", "error", ")", "{", "if", "file", ".", "Used", "+", "more", "<=", "file", ".", "Size", "{", "return", "\n", "}", "else", "if", "file", ".", "Buf", "!=", "nil", "{", "if", "err", "=", "file", ".", "Buf", ".", "Unmap", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "if", "err", "=", "file", ".", "overwriteWithZero", "(", "file", ".", "Size", ",", "file", ".", "Growth", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "if", "file", ".", "Buf", ",", "err", "=", "gommap", ".", "Map", "(", "file", ".", "Fh", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "file", ".", "Size", "+=", "file", ".", "Growth", "\n", "tdlog", ".", "Infof", "(", "\"", "\"", ",", "file", ".", "Path", ",", "file", ".", "Size", "-", "file", ".", "Growth", ",", "file", ".", "Size", ",", "file", ".", "Used", ")", "\n", "return", "file", ".", "EnsureSize", "(", "more", ")", "\n", "}" ]

[ "Ensure", "there", "is", "enough", "room", "for", "that", "many", "bytes", "of", "data", "." ]

[ "func", "(", "file", "*", "DataFile", ")", "Close", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "file", ".", "Buf", ".", "Unmap", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "file", ".", "Fh", ".", "Close", "(", ")", "\n", "}" ]

[ "Un", "-", "map", "the", "file", "buffer", "and", "close", "the", "file", "handle", "." ]

[ "func", "(", "file", "*", "DataFile", ")", "Clear", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "file", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "if", "err", "=", "os", ".", "Truncate", "(", "file", ".", "Path", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "if", "file", ".", "Fh", ",", "err", "=", "os", ".", "OpenFile", "(", "file", ".", "Path", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_RDWR", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "if", "err", "=", "file", ".", "overwriteWithZero", "(", "0", ",", "file", ".", "Growth", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "if", "file", ".", "Buf", ",", "err", "=", "gommap", ".", "Map", "(", "file", ".", "Fh", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "file", ".", "Used", ",", "file", ".", "Size", "=", "0", ",", "file", ".", "Growth", "\n", "tdlog", ".", "Infof", "(", "\"", "\"", ",", "file", ".", "Path", ",", "file", ".", "Used", ",", "file", ".", "Size", ")", "\n", "return", "\n", "}" ]

[ "Clear", "the", "entire", "file", "and", "resize", "it", "to", "initial", "size", "." ]

[ "func", "(", "conf", "*", "Config", ")", "OpenCollection", "(", "path", "string", ")", "(", "col", "*", "Collection", ",", "err", "error", ")", "{", "col", "=", "new", "(", "Collection", ")", "\n", "col", ".", "DataFile", ",", "err", "=", "OpenDataFile", "(", "path", ",", "conf", ".", "ColFileGrowth", ")", "\n", "col", ".", "Config", "=", "conf", "\n", "col", ".", "Config", ".", "CalculateConfigConstants", "(", ")", "\n", "return", "\n", "}" ]

[ "Open", "a", "collection", "file", "." ]

[ "func", "(", "col", "*", "Collection", ")", "Read", "(", "id", "int", ")", "[", "]", "byte", "{", "if", "id", "<", "0", "||", "id", ">", "col", ".", "Used", "-", "DocHeader", "||", "col", ".", "Buf", "[", "id", "]", "!=", "1", "{", "return", "nil", "\n", "}", "else", "if", "room", ",", "_", ":=", "binary", ".", "Varint", "(", "col", ".", "Buf", "[", "id", "+", "1", ":", "id", "+", "11", "]", ")", ";", "room", ">", "int64", "(", "col", ".", "DocMaxRoom", ")", "{", "return", "nil", "\n", "}", "else", "if", "docEnd", ":=", "id", "+", "DocHeader", "+", "int", "(", "room", ")", ";", "docEnd", ">=", "col", ".", "Size", "{", "return", "nil", "\n", "}", "else", "{", "docCopy", ":=", "make", "(", "[", "]", "byte", ",", "room", ")", "\n", "copy", "(", "docCopy", ",", "col", ".", "Buf", "[", "id", "+", "DocHeader", ":", "docEnd", "]", ")", "\n", "return", "docCopy", "\n", "}", "\n", "}" ]

[ "Find", "and", "retrieve", "a", "document", "by", "ID", "(", "physical", "document", "location", ")", ".", "Return", "value", "is", "a", "copy", "of", "the", "document", "." ]