{
  "_id": "6a16a50bacfb0bcc41d821c7",
  "Package": "S4Vectors",
  "Title": "Foundation of vector-like and list-like containers in\nBioconductor",
  "Description": "The S4Vectors package defines the Vector and List virtual\nclasses and a set of generic functions that extend the semantic\nof ordinary vectors and lists in R. Package developers can\neasily implement vector-like or list-like objects as concrete\nsubclasses of Vector or List. In addition, a few low-level\nconcrete subclasses of general interest (e.g. DataFrame, Rle,\nFactor, and Hits) are implemented in the S4Vectors package\nitself (many more are implemented in the IRanges package and in\nother Bioconductor infrastructure packages).",
  "biocViews": "Infrastructure, DataRepresentation",
  "URL": "https://bioconductor.org/packages/S4Vectors",
  "BugReports": "https://github.com/Bioconductor/S4Vectors/issues",
  "Version": "0.51.3",
  "License": "Artistic-2.0",
  "Encoding": "UTF-8",
  "Authors@R": "c(\nperson(\"Hervé\", \"Pagès\", role=c(\"aut\", \"cre\"),\nemail=\"hpages.on.github@gmail.com\"),\nperson(\"Michael\", \"Lawrence\", role=\"aut\"),\nperson(\"Patrick\", \"Aboyoun\", role=\"aut\"),\nperson(\"Aaron\", \"Lun\", role=\"ctb\"),\nperson(\"Beryl\", \"Kanali\", role=\"ctb\",\ncomment=\"Converted vignettes from Sweave to RMarkdown\"))",
  "VignetteBuilder": "knitr",
  "Collate": "S4-utils.R show-utils.R utils.R normarg-utils.R bindROWS.R\nLLint-class.R isSorted.R subsetting-utils.R vector-utils.R\ninteger-utils.R character-utils.R raw-utils.R eval-utils.R\nmap_ranges_to_runs.R RectangularData-class.R Annotated-class.R\nDataFrame_OR_NULL-class.R Vector-class.R Vector-comparison.R\nVector-setops.R Vector-merge.R Hits-class.R Hits-comparison.R\nHits-setops.R Rle-class.R Rle-utils.R Factor-class.R\nList-class.R List-comparison.R splitAsList.R List-utils.R\nSimpleList-class.R HitsList-class.R DataFrame-class.R\nDataFrame-combine.R DataFrame-comparison.R DataFrame-utils.R\nDataFrameFactor-class.R TransposedDataFrame-class.R\nPairs-class.R FilterRules-class.R stack-methods.R\nexpand-methods.R aggregate-methods.R shiftApply-methods.R zzz.R",
  "Repository": "https://bioc.r-universe.dev",
  "Date/Publication": "2026-05-27 02:24:47 UTC",
  "RemoteUrl": "https://github.com/bioc/S4Vectors",
  "RemoteRef": "HEAD",
  "RemoteSha": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
  "NeedsCompilation": "yes",
  "Packaged": {
    "Date": "2026-05-27 07:06:58 UTC",
    "User": "root"
  },
  "Author": "Hervé Pagès [aut, cre],\nMichael Lawrence [aut],\nPatrick Aboyoun [aut],\nAaron Lun [ctb],\nBeryl Kanali [ctb] (Converted vignettes from Sweave to RMarkdown)",
  "Maintainer": "Hervé Pagès <hpages.on.github@gmail.com>",
  "MD5sum": "a7ca4165ae5f321bdd76f5ebb97a3275",
  "_user": "bioc",
  "_type": "src",
  "_file": "S4Vectors_0.51.3.tar.gz",
  "_fileid": "80873e8f1de259f642a995f3201cbbaec13fe0fdf4aa96ceafe7286cbac65fbf",
  "_filesize": 809513,
  "_sha256": "80873e8f1de259f642a995f3201cbbaec13fe0fdf4aa96ceafe7286cbac65fbf",
  "_created": "2026-05-27T07:06:58.000Z",
  "_published": "2026-05-27T08:02:19.810Z",
  "_jobs": [
    {
      "job": 78032606015,
      "time": 188,
      "config": "bioc-checks",
      "r": "4.6.0",
      "check": "WARNING",
      "artifact": "7234083326"
    },
    {
      "job": 78032606404,
      "time": 223,
      "config": "linux-devel-arm64",
      "r": "4.7.0",
      "check": "NOTE",
      "artifact": "7234092821"
    },
    {
      "job": 78032606364,
      "time": 234,
      "config": "linux-devel-x86_64",
      "r": "4.7.0",
      "check": "NOTE",
      "artifact": "7234095628"
    },
    {
      "job": 78032606504,
      "time": 213,
      "config": "linux-release-arm64",
      "r": "4.6.0",
      "check": "NOTE",
      "artifact": "7234090151"
    },
    {
      "job": 78032606411,
      "time": 268,
      "config": "linux-release-x86_64",
      "r": "4.6.0",
      "check": "NOTE",
      "artifact": "7234105050"
    },
    {
      "job": 78032605895,
      "time": 185,
      "config": "macos-oldrel-arm64",
      "r": "4.5.3",
      "check": "ERROR",
      "artifact": "7234990839"
    },
    {
      "job": 78032605908,
      "time": 280,
      "config": "macos-oldrel-x86_64",
      "r": "4.5.3",
      "check": "ERROR",
      "artifact": "7235022636"
    },
    {
      "job": 78032606116,
      "time": 146,
      "config": "macos-release-arm64",
      "r": "4.6.0",
      "check": "NOTE",
      "artifact": "7234182088"
    },
    {
      "job": 78032606145,
      "time": 259,
      "config": "macos-release-x86_64",
      "r": "4.6.0",
      "check": "NOTE",
      "artifact": "7234107794"
    },
    {
      "job": 78032605935,
      "time": 264,
      "config": "source",
      "r": "4.6.0",
      "check": "OK",
      "artifact": "7234029768"
    },
    {
      "job": 78032605993,
      "time": 148,
      "config": "wasm-release",
      "r": "4.6.0",
      "check": "OK",
      "artifact": "7234071679"
    },
    {
      "job": 78032606301,
      "time": 217,
      "config": "windows-devel",
      "r": "4.7.0",
      "check": "WARNING",
      "artifact": "7234091383"
    },
    {
      "job": 78032605879,
      "time": 166,
      "config": "windows-oldrel",
      "r": "4.5.3",
      "check": "ERROR",
      "artifact": "7234985252"
    },
    {
      "job": 78032606417,
      "time": 185,
      "config": "windows-release",
      "r": "4.6.0",
      "check": "WARNING",
      "artifact": "7234082045"
    }
  ],
  "_bioccheck": {
    "error": 0,
    "warning": 3,
    "note": 18
  },
  "_buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394",
  "_status": "success",
  "_host": "GitHub-Actions",
  "_upstream": "https://github.com/bioc/S4Vectors",
  "_commit": {
    "id": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
    "author": "Hervé Pagès <hpages.on.github@gmail.com>",
    "committer": "Hervé Pagès <hpages.on.github@gmail.com>",
    "message": "S4Vectors 0.51.3: Use new transform() signature in method definitions\n",
    "time": 1779848687
  },
  "_maintainer": {
    "name": "Hervé Pagès",
    "email": "hpages.on.github@gmail.com",
    "login": "hpages",
    "linkedin": "in/hervé-pagès-5038527",
    "description": "",
    "uuid": 8810451
  },
  "_distro": "noble",
  "_registered": true,
  "_dependencies": [
    {
      "package": "R",
      "version": ">= 4.1.0",
      "role": "Depends"
    },
    {
      "package": "methods",
      "role": "Depends"
    },
    {
      "package": "utils",
      "role": "Depends"
    },
    {
      "package": "stats",
      "role": "Depends"
    },
    {
      "package": "stats4",
      "role": "Depends"
    },
    {
      "package": "BiocGenerics",
      "version": ">= 0.59.5",
      "role": "Depends"
    },
    {
      "package": "IRanges",
      "role": "Suggests"
    },
    {
      "package": "GenomicRanges",
      "role": "Suggests"
    },
    {
      "package": "SummarizedExperiment",
      "role": "Suggests"
    },
    {
      "package": "Matrix",
      "role": "Suggests"
    },
    {
      "package": "DelayedArray",
      "role": "Suggests"
    },
    {
      "package": "ShortRead",
      "role": "Suggests"
    },
    {
      "package": "graph",
      "role": "Suggests"
    },
    {
      "package": "data.table",
      "role": "Suggests"
    },
    {
      "package": "RUnit",
      "role": "Suggests"
    },
    {
      "package": "BiocStyle",
      "role": "Suggests"
    },
    {
      "package": "knitr",
      "role": "Suggests"
    }
  ],
  "_owner": "bioc",
  "_selfowned": true,
  "_usedby": 1988,
  "_updates": [
    {
      "week": "2025-37",
      "n": 3
    },
    {
      "week": "2025-38",
      "n": 1
    },
    {
      "week": "2025-39",
      "n": 2
    },
    {
      "week": "2025-43",
      "n": 2
    },
    {
      "week": "2025-44",
      "n": 3
    },
    {
      "week": "2026-14",
      "n": 2
    },
    {
      "week": "2026-15",
      "n": 1
    },
    {
      "week": "2026-16",
      "n": 2
    },
    {
      "week": "2026-17",
      "n": 3
    },
    {
      "week": "2026-18",
      "n": 5
    },
    {
      "week": "2026-20",
      "n": 1
    },
    {
      "week": "2026-22",
      "n": 1
    }
  ],
  "_tags": [],
  "_bioc": [
    {
      "branch": "devel",
      "version": "0.51.2",
      "bioc": "3.24"
    },
    {
      "branch": "release",
      "version": "0.50.1",
      "bioc": "3.23"
    }
  ],
  "_topics": [
    "infrastructure",
    "datarepresentation",
    "bioconductor-package",
    "core-package"
  ],
  "_stars": 18,
  "_contributors": [
    {
      "user": "hpages",
      "count": 358,
      "uuid": 8810451
    },
    {
      "user": "lawremi",
      "count": 108,
      "uuid": 158190
    },
    {
      "user": "ltla",
      "count": 36,
      "uuid": 8166669
    },
    {
      "user": "jwokaty",
      "count": 16,
      "uuid": 1744257
    },
    {
      "user": "nturaga",
      "count": 14,
      "uuid": 2746443
    },
    {
      "user": "dtenenba",
      "count": 10,
      "uuid": 2286826
    },
    {
      "user": "link-ny",
      "count": 7,
      "uuid": 4392950
    },
    {
      "user": "vobencha",
      "count": 2,
      "uuid": 2466173
    },
    {
      "user": "berylkanali",
      "count": 1,
      "uuid": 50364045
    },
    {
      "user": "darios",
      "count": 1,
      "uuid": 631218
    },
    {
      "user": "plenaerts",
      "count": 1,
      "uuid": 14309550
    }
  ],
  "_userbio": {
    "uuid": 2286807,
    "type": "organization",
    "name": "Bioconductor",
    "description": "Software for the analysis and comprehension of high-throughput genomic data"
  },
  "_downloads": {
    "count": 117688,
    "source": "https://www.bioconductor.org/packages/stats/bioc/S4Vectors"
  },
  "_mentions": 7,
  "_devurl": "https://github.com/bioconductor/s4vectors",
  "_searchresults": 1768,
  "_rbuild": "4.6.0",
  "_assets": [
    "extra/citation.cff",
    "extra/citation.html",
    "extra/citation.json",
    "extra/citation.txt",
    "extra/contents.json",
    "extra/NEWS.html",
    "extra/NEWS.txt",
    "extra/readme.html",
    "extra/readme.md",
    "extra/S4Vectors.html",
    "manual.pdf"
  ],
  "_homeurl": "https://github.com/bioconductor/s4vectors",
  "_realowner": "bioc",
  "_cranurl": false,
  "_exports": [
    ".Call2",
    "%in%",
    "active",
    "active<-",
    "aggregate",
    "aggregate.Vector",
    "anyDuplicated",
    "anyDuplicated.NSBS",
    "anyDuplicated.Rle",
    "anyDuplicated.Vector",
    "append",
    "as.character.LLint",
    "as.data.frame",
    "as.data.frame.DataFrame",
    "as.data.frame.Hits",
    "as.data.frame.Vector",
    "as.env",
    "as.factor",
    "as.integer.LLint",
    "as.list",
    "as.list.Rle",
    "as.list.SimpleList",
    "as.list.TransposedDataFrame",
    "as.list.Vector",
    "as.LLint",
    "as.logical.LLint",
    "as.matrix",
    "as.matrix.Vector",
    "as.numeric.LLint",
    "as.table",
    "as.vector.Rle",
    "bindCOLS",
    "bindROWS",
    "breakTies",
    "by",
    "cbind",
    "cbind_mcols_for_display",
    "cbind.DataFrame",
    "cbind.List",
    "cbind.RectangularData",
    "classNameForDisplay",
    "coerce",
    "colnames",
    "colnames<-",
    "combineCols",
    "combineRows",
    "combineUniqueCols",
    "complete.cases",
    "coolcat",
    "cor",
    "countLnodeHits",
    "countMatches",
    "countQueryHits",
    "countRnodeHits",
    "countSubjectHits",
    "cov",
    "DataFrame",
    "DataFrameFactor",
    "decode",
    "diff.Rle",
    "do.call",
    "droplevels",
    "droplevels.Factor",
    "droplevels.List",
    "droplevels.Rle",
    "duplicated",
    "duplicated.DataFrame",
    "duplicated.Vector",
    "duplicatedIntegerPairs",
    "duplicatedIntegerQuads",
    "elementMetadata",
    "elementMetadata<-",
    "elementNROWS",
    "elementType",
    "end",
    "endoapply",
    "eval",
    "evalSeparately",
    "expand",
    "expand.grid",
    "extractCOLS",
    "extractROWS",
    "Factor",
    "FactorToClass",
    "Filter",
    "FilterMatrix",
    "filterRules",
    "FilterRules",
    "findMatches",
    "findRun",
    "first",
    "first<-",
    "fold",
    "from",
    "get_showHeadLines",
    "get_showTailLines",
    "getListElement",
    "grep",
    "grepl",
    "head",
    "head.LLint",
    "head.RectangularData",
    "head.Vector",
    "Hits",
    "HitsList",
    "horizontal_slot_names",
    "I",
    "intersect",
    "intersect.Vector",
    "is.LLint",
    "is.unsorted",
    "isConstant",
    "isEmpty",
    "isRedundantHit",
    "isSelfHit",
    "isSequence",
    "isSingleInteger",
    "isSingleNumber",
    "isSingleNumberOrNA",
    "isSingleString",
    "isSingleStringOrNA",
    "isSorted",
    "isStrictlySorted",
    "isTRUEorFALSE",
    "lapply",
    "levels",
    "levels.Rle",
    "List",
    "LLint",
    "make_zero_col_DFrame",
    "makeClassinfoRowForCompactPrinting",
    "makeNakedCharacterMatrixForDisplay",
    "makePrettyMatrixForCompactPrinting",
    "match",
    "matchIntegerPairs",
    "matchIntegerQuads",
    "mcols",
    "mcols<-",
    "mean.Rle",
    "median.Rle",
    "mendoapply",
    "merge",
    "mergeROWS",
    "metadata",
    "metadata<-",
    "mstack",
    "NA_LLint_",
    "na.exclude",
    "na.omit",
    "nchar",
    "ncol",
    "new2",
    "nLnode",
    "nnode",
    "normalizeDoubleBracketSubscript",
    "normalizeSingleBracketReplacementValue",
    "normalizeSingleBracketSubscript",
    "nRnode",
    "nrow",
    "nrun",
    "NSBS",
    "Ops",
    "order",
    "orderIntegerPairs",
    "orderIntegerQuads",
    "Pairs",
    "parallel_slot_names",
    "parallelVectorNames",
    "params",
    "pc",
    "pcompare",
    "pcompareRecursively",
    "printAtomicVectorInAGrid",
    "quantile.Rle",
    "queryHits",
    "queryLength",
    "rank",
    "rbind",
    "rbind.RectangularData",
    "recycleArg",
    "recycleCharacterArg",
    "recycleIntegerArg",
    "recycleLogicalArg",
    "recycleNumericArg",
    "Reduce",
    "relistToClass",
    "remapHits",
    "rename",
    "rep.int",
    "replaceCOLS",
    "replaceROWS",
    "rev",
    "rev.Rle",
    "rev.Vector",
    "revElements",
    "Rle",
    "rownames",
    "ROWNAMES",
    "rownames<-",
    "ROWNAMES<-",
    "runLength",
    "runLength<-",
    "runmean",
    "runq",
    "runsum",
    "runValue",
    "runValue<-",
    "runwtsum",
    "safeExplode",
    "sameAsPreviousROW",
    "sapply",
    "sd",
    "second",
    "second<-",
    "selectHits",
    "SelfHits",
    "selfmatch",
    "selfmatchIntegerPairs",
    "selfmatchIntegerQuads",
    "set_showHeadLines",
    "set_showTailLines",
    "setdiff",
    "setdiff.Vector",
    "setequal",
    "setequal.Vector",
    "setListElement",
    "setMethods",
    "setValidity2",
    "shiftApply",
    "show",
    "showAsCell",
    "SimpleList",
    "sort",
    "sort.DataFrame",
    "sort.List",
    "sort.Rle",
    "sort.Vector",
    "space",
    "split",
    "splitAsList",
    "stack",
    "start",
    "subjectHits",
    "subjectLength",
    "subset",
    "subset.Vector",
    "subsetByFilter",
    "substr",
    "substring",
    "summary",
    "Summary",
    "summary.Hits",
    "summary.Rle",
    "summary.Vector",
    "svn.time",
    "t",
    "t.DataFrame",
    "t.Hits",
    "t.HitsList",
    "t.TransposedDataFrame",
    "tail",
    "tail.LLint",
    "tail.RectangularData",
    "tail.Vector",
    "to",
    "toListOfIntegerVectors",
    "transform",
    "transform.DataFrame",
    "transform.Vector",
    "unfactor",
    "union",
    "union.Vector",
    "unique",
    "unique.DataFrame",
    "unique.Vector",
    "unname",
    "unstrsplit",
    "updateObject",
    "values",
    "values<-",
    "var",
    "vertical_slot_names",
    "width",
    "window",
    "window.LLint",
    "window.Vector",
    "with",
    "within",
    "wmsg",
    "xtabs",
    "zipdown",
    "zipup"
  ],
  "_help": [
    {
      "page": "aggregate-methods",
      "title": "Compute summary statistics of subsets of vector-like objects",
      "topics": [
        "aggregate",
        "aggregate,data.frame-method",
        "aggregate,List-method",
        "aggregate,matrix-method",
        "aggregate,Rle-method",
        "aggregate,ts-method",
        "aggregate,Vector-method",
        "aggregate-methods",
        "aggregate.Vector"
      ]
    },
    {
      "page": "Annotated-class",
      "title": "Annotated class",
      "topics": [
        "Annotated",
        "Annotated-class",
        "metadata",
        "metadata,Annotated-method",
        "metadata<-",
        "metadata<-,Annotated-method"
      ]
    },
    {
      "page": "bindROWS",
      "title": "Combine objects along their ROWS or COLS",
      "topics": [
        "bindCOLS",
        "bindROWS",
        "bindROWS,ANY-method",
        "bindROWS,NULL-method"
      ]
    },
    {
      "page": "character-utils",
      "title": "Some utility functions to operate on strings",
      "topics": [
        "safeExplode",
        "svn.time",
        "unstrsplit",
        "unstrsplit,character-method",
        "unstrsplit,list-method"
      ]
    },
    {
      "page": "DataFrame-class",
      "title": "DataFrame objects",
      "topics": [
        "as.data.frame,DataFrame-method",
        "as.data.frame.DataFrame",
        "as.matrix,DataFrame-method",
        "class:DataFrame",
        "class:DFrame",
        "classNameForDisplay,DFrame-method",
        "coerce,ANY,DataFrame-method",
        "coerce,ANY,DataFrame_OR_NULL-method",
        "coerce,ANY,DFrame-method",
        "coerce,AsIs,DFrame-method",
        "coerce,data.frame,DFrame-method",
        "coerce,data.table,DFrame-method",
        "coerce,list,DFrame-method",
        "coerce,NULL,DFrame-method",
        "coerce,SimpleList,DataFrame-method",
        "coerce,SimpleList,DFrame-method",
        "coerce,table,DFrame-method",
        "coerce,Vector,DFrame-method",
        "coerce,xtabs,DFrame-method",
        "colnames,DataFrame-method",
        "colnames<-,DataFrame-method",
        "DataFrame",
        "DataFrame-class",
        "DFrame",
        "DFrame-class",
        "dimnames<-,DataFrame-method",
        "droplevels,DFrame-method",
        "extractCOLS,DataFrame-method",
        "extractROWS,DataFrame,ANY-method",
        "getListElement,DataFrame-method",
        "horizontal_slot_names,DFrame-method",
        "length,DataFrame-method",
        "makeNakedCharacterMatrixForDisplay,DataFrame-method",
        "make_zero_col_DFrame",
        "mergeROWS,DFrame-method",
        "names,DataFrame-method",
        "ncol,DataFrame-method",
        "normalizeSingleBracketReplacementValue,DataFrame-method",
        "nrow,DataFrame-method",
        "rep,DataFrame-method",
        "replaceCOLS,DFrame-method",
        "replaceROWS,DFrame-method",
        "rownames,DataFrame-method",
        "rownames<-,DFrame-method",
        "show,DataFrame-method",
        "showAsCell,DataFrame-method",
        "updateObject,DataFrame-method",
        "vertical_slot_names,DFrame-method",
        "[,DataFrame-method",
        "[<-,DataFrame-method",
        "[[,DataFrame-method",
        "[[,DFrame-method",
        "[[<-,DFrame-method"
      ]
    },
    {
      "page": "DataFrame-combine",
      "title": "Combine DataFrame objects along their rows or columns, or merge them",
      "topics": [
        "bindROWS,DataFrame-method",
        "c,DataFrame-method",
        "cbind,DataFrame-method",
        "cbind.DataFrame",
        "combineCols,DataFrame-method",
        "combineRows,DataFrame-method",
        "DataFrame-combine",
        "merge,data.frame,DataFrame-method",
        "merge,DataFrame,data.frame-method",
        "merge,DataFrame,DataFrame-method"
      ]
    },
    {
      "page": "DataFrame-comparison",
      "title": "DataFrame comparison methods",
      "topics": [
        "<=,DataFrame,DataFrame-method",
        "==,DataFrame,DataFrame-method",
        "duplicated,DataFrame-method",
        "duplicated.DataFrame",
        "match,DataFrame,DataFrame-method",
        "order,DataFrame-method",
        "pcompare,DataFrame,DataFrame-method",
        "sameAsPreviousROW,DataFrame-method",
        "sort,DataFrame-method",
        "sort.DataFrame",
        "unique,DataFrame-method",
        "unique.DataFrame"
      ]
    },
    {
      "page": "DataFrame-utils",
      "title": "Common operations on DataFrame objects",
      "topics": [
        "complete.cases,DataFrame-method",
        "DataFrame-utils",
        "is.na,DataFrame-method",
        "na.exclude,DataFrame-method",
        "na.omit,DataFrame-method",
        "relistToClass,data.frame-method",
        "relistToClass,DataFrame-method",
        "transform,DataFrame-method",
        "transform.DataFrame",
        "xtabs,DataFrame-method"
      ]
    },
    {
      "page": "DataFrameFactor-class",
      "title": "DataFrameFactor objects",
      "topics": [
        "$,DataFrameFactor-method",
        "class:DataFrameFactor",
        "DataFrameFactor",
        "DataFrameFactor-class",
        "dim,DataFrameFactor-method",
        "dimnames,DataFrameFactor-method",
        "show,DataFrameFactor-method",
        "[,DataFrameFactor,ANY,ANY,ANY-method",
        "[,DataFrameFactor-method",
        "[[,DataFrameFactor,ANY,ANY-method",
        "[[,DataFrameFactor-method"
      ]
    },
    {
      "page": "expand-methods",
      "title": "Unlist the list-like columns of a DataFrame object",
      "topics": [
        "expand",
        "expand,DataFrame-method",
        "expand,Vector-method"
      ]
    },
    {
      "page": "Factor-class",
      "title": "Factor objects",
      "topics": [
        "as.character,Factor-method",
        "as.factor,Factor-method",
        "as.integer,Factor-method",
        "as.raw,Factor-method",
        "bindROWS,Factor-method",
        "class:Factor",
        "class:integer_OR_raw",
        "coerce,factor,Factor-method",
        "coerce,vector_OR_Vector,Factor-method",
        "droplevels,Factor-method",
        "droplevels.Factor",
        "Factor",
        "Factor-class",
        "FactorToClass",
        "FactorToClass,vector_OR_Vector-method",
        "integer_OR_raw",
        "integer_OR_raw-class",
        "levels",
        "levels<-",
        "levels<-,Factor-method",
        "match,Factor,Factor-method",
        "names,Factor-method",
        "names<-,Factor-method",
        "nlevels",
        "nlevels,Factor-method",
        "parallel_slot_names,Factor-method",
        "pcompare,Factor,Factor-method",
        "selfmatch,Factor-method",
        "show,Factor-method",
        "showAsCell,Factor-method",
        "unfactor",
        "unfactor,Factor-method",
        "unfactor,factor-method",
        "xtfrm,Factor-method"
      ]
    },
    {
      "page": "FilterMatrix-class",
      "title": "Matrix for Filter Results",
      "topics": [
        "cbind,FilterMatrix-method",
        "class:FilterMatrix",
        "FilterMatrix",
        "FilterMatrix-class",
        "filterRules",
        "filterRules,FilterMatrix-method",
        "rbind,FilterMatrix-method",
        "show,FilterMatrix-method",
        "summary,FilterMatrix-method",
        "[,FilterMatrix-method"
      ]
    },
    {
      "page": "FilterRules-class",
      "title": "Collection of Filter Rules",
      "topics": [
        "&,FilterRules,FilterRules-method",
        "active",
        "active,FilterRules-method",
        "active<-",
        "active<-,FilterRules-method",
        "class:expression_OR_function",
        "class:FilterRules",
        "coerce,ANY,FilterRules-method",
        "coerce,function,FilterClosure-method",
        "coerce,SimpleList,FilterRules-method",
        "coerce,standardGeneric,FilterClosure-method",
        "eval,FilterRules,ANY-method",
        "evalSeparately",
        "evalSeparately,FilterRules-method",
        "expression_OR_function",
        "expression_OR_function-class",
        "FilterRules",
        "filterRules,FilterResults-method",
        "FilterRules-class",
        "parallel_slot_names,FilterRules-method",
        "params",
        "params,FilterClosure-method",
        "show,FilterClosure-method",
        "subsetByFilter",
        "subsetByFilter,ANY,FilterRules-method",
        "summary,FilterResults-method",
        "summary,FilterRules-method",
        "[,FilterRules-method",
        "[[<-,FilterRules-method"
      ]
    },
    {
      "page": "Hits-class",
      "title": "Hits objects",
      "topics": [
        "as.data.frame,Hits-method",
        "as.data.frame.Hits",
        "as.matrix,Hits-method",
        "as.table,Hits-method",
        "bindROWS,Hits-method",
        "breakTies",
        "class:Hits",
        "class:SelfHits",
        "class:SortedByQueryHits",
        "class:SortedByQuerySelfHits",
        "classNameForDisplay,SortedByQueryHits-method",
        "coerce,Hits,DFrame-method",
        "coerce,Hits,SelfHits-method",
        "coerce,Hits,SortedByQueryHits-method",
        "coerce,Hits,SortedByQuerySelfHits-method",
        "coerce,SelfHits,SortedByQuerySelfHits-method",
        "coerce,SortedByQueryHits,SortedByQuerySelfHits-method",
        "countLnodeHits",
        "countLnodeHits,Hits-method",
        "countQueryHits",
        "countRnodeHits",
        "countRnodeHits,Hits-method",
        "countSubjectHits",
        "extractROWS,SortedByQueryHits,ANY-method",
        "from",
        "from,Hits-method",
        "Hits",
        "Hits-class",
        "isRedundantHit",
        "isSelfHit",
        "makeNakedCharacterMatrixForDisplay,Hits-method",
        "nLnode",
        "nLnode,Hits-method",
        "nnode",
        "nnode,SelfHits-method",
        "nRnode",
        "nRnode,Hits-method",
        "parallel_slot_names,Hits-method",
        "queryHits",
        "queryLength",
        "remapHits",
        "selectHits",
        "SelfHits",
        "SelfHits-class",
        "show,Hits-method",
        "sort,SortedByQueryHits-method",
        "SortedByQueryHits",
        "SortedByQueryHits-class",
        "SortedByQuerySelfHits",
        "SortedByQuerySelfHits-class",
        "subjectHits",
        "subjectLength",
        "summary,Hits-method",
        "summary.Hits",
        "t,Hits-method",
        "t.Hits",
        "to",
        "to,Hits-method",
        "updateObject,Hits-method"
      ]
    },
    {
      "page": "Hits-comparison",
      "title": "Comparing and ordering hits",
      "topics": [
        "Hits-comparison",
        "match,Hits,Hits-method",
        "order,Hits-method",
        "pcompare,Hits,Hits-method"
      ]
    },
    {
      "page": "Hits-setops",
      "title": "Set operations on Hits objects",
      "topics": [
        "Hits-setops",
        "union,SortedByQueryHits,Hits-method"
      ]
    },
    {
      "page": "HitsList-class",
      "title": "List of Hits objects",
      "topics": [
        "as.matrix,HitsList-method",
        "as.table,HitsList-method",
        "class:HitsList",
        "class:SelfHitsList",
        "class:SortedByQueryHitsList",
        "class:SortedByQuerySelfHitsList",
        "coerce,HitsList,SortedByQueryHitsList-method",
        "coerce,SortedByQueryHitsList,HitsList-method",
        "from,HitsList-method",
        "HitsList",
        "HitsList-class",
        "queryHits,HitsList-method",
        "relistToClass,Hits-method",
        "relistToClass,SortedByQueryHits-method",
        "SelfHitsList",
        "SelfHitsList-class",
        "SortedByQueryHitsList",
        "SortedByQueryHitsList-class",
        "SortedByQuerySelfHitsList",
        "SortedByQuerySelfHitsList-class",
        "space",
        "space,HitsList-method",
        "splitAsList,SortedByQueryHits,ANY-method",
        "subjectHits,HitsList-method",
        "t,HitsList-method",
        "t.HitsList",
        "to,HitsList-method"
      ]
    },
    {
      "page": "integer-utils",
      "title": "Some utility functions to operate on integer vectors",
      "topics": [
        "duplicatedIntegerPairs",
        "duplicatedIntegerQuads",
        "isSequence",
        "matchIntegerPairs",
        "matchIntegerQuads",
        "orderIntegerPairs",
        "orderIntegerQuads",
        "selfmatchIntegerPairs",
        "selfmatchIntegerQuads",
        "toListOfIntegerVectors"
      ]
    },
    {
      "page": "isSorted",
      "title": "Test if a vector-like object is sorted",
      "topics": [
        "isConstant",
        "isConstant,array-method",
        "isConstant,integer-method",
        "isConstant,numeric-method",
        "isSorted",
        "isSorted,ANY-method",
        "isStrictlySorted",
        "isStrictlySorted,ANY-method"
      ]
    },
    {
      "page": "List-class",
      "title": "List objects",
      "topics": [
        "$,List-method",
        "$<-,List-method",
        "anyNA,List-method",
        "as.data.frame,List-method",
        "as.list,List-method",
        "class:List",
        "class:list_OR_List",
        "coerce,ANY,List-method",
        "coerce,integer,List-method",
        "coerce,List,list-method",
        "elementNROWS",
        "elementNROWS,ANY-method",
        "elementNROWS,List-method",
        "elementType",
        "elementType,List-method",
        "elementType,vector-method",
        "getListElement,List-method",
        "is.na,List-method",
        "isEmpty",
        "isEmpty,ANY-method",
        "isEmpty,List-method",
        "List",
        "List-class",
        "list_OR_List",
        "list_OR_List-class",
        "normalizeSingleBracketReplacementValue,List-method",
        "parallelVectorNames,List-method",
        "setListElement,List-method",
        "show,List-method",
        "showAsCell,List-method",
        "unlist,List-method",
        "[,List-method",
        "[<-,List-method",
        "[[,List-method",
        "[[<-,List-method"
      ]
    },
    {
      "page": "List-comparison",
      "title": "Compare and order list-like objects",
      "topics": [
        "<=,List,List-method",
        "<=,List,list-method",
        "<=,list,List-method",
        "==,List,List-method",
        "==,List,list-method",
        "==,list,List-method",
        "duplicated,List-method",
        "is.unsorted,List-method",
        "List-comparison",
        "match,List,List-method",
        "match,List,list-method",
        "match,list,List-method",
        "match,List,Vector-method",
        "match,List,vector-method",
        "order,List-method",
        "pcompare,List,List-method",
        "pcompare,List,list-method",
        "pcompare,list,List-method",
        "pcompareRecursively",
        "pcompareRecursively,List-method",
        "pcompareRecursively,list-method",
        "rank,List-method",
        "sort,List-method",
        "sort.List",
        "unique,List-method",
        "unique,SimpleList-method"
      ]
    },
    {
      "page": "List-utils",
      "title": "Common operations on List objects",
      "topics": [
        "!,List-method",
        "cbind,List-method",
        "cbind.List",
        "do.call,ANY,List-method",
        "droplevels,List-method",
        "droplevels.List",
        "endoapply",
        "Filter,List-method",
        "Find,List-method",
        "lapply,List-method",
        "List-utils",
        "Map,List-method",
        "mendoapply",
        "pc",
        "Position,List-method",
        "rbind,List-method",
        "Reduce,List-method",
        "revElements",
        "revElements,List-method",
        "revElements,list-method",
        "sapply,List-method",
        "within,List-method"
      ]
    },
    {
      "page": "LLint-class",
      "title": "LLint vectors",
      "topics": [
        "as.character,LLint-method",
        "as.character.LLint",
        "as.integer,LLint-method",
        "as.integer.LLint",
        "as.LLint",
        "as.logical,LLint-method",
        "as.logical.LLint",
        "as.numeric,LLint-method",
        "as.numeric.LLint",
        "bindROWS,LLint-method",
        "c,LLint-method",
        "class:integer_OR_LLint",
        "class:LLint",
        "coerce,character,LLint-method",
        "coerce,integer,LLint-method",
        "coerce,logical,LLint-method",
        "coerce,numeric,LLint-method",
        "extractROWS,LLint,ANY-method",
        "extractROWS,LLint,NSBS-method",
        "extractROWS,LLint,RangeNSBS-method",
        "head,LLint-method",
        "head.LLint",
        "integer_OR_LLint",
        "integer_OR_LLint-class",
        "is.LLint",
        "is.na,LLint-method",
        "length,LLint-method",
        "LLint",
        "LLint-class",
        "NA_LLint_",
        "Ops,LLint,LLint-method",
        "Ops,LLint,numeric-method",
        "Ops,numeric,LLint-method",
        "rep.int,LLint-method",
        "show,LLint-method",
        "showAsCell,LLint-method",
        "Summary,LLint-method",
        "tail,LLint-method",
        "tail.LLint",
        "window,LLint-method",
        "window.LLint",
        "[,LLint-method"
      ]
    },
    {
      "page": "Pairs-class",
      "title": "Pairs objects",
      "topics": [
        "as.data.frame,Pairs-method",
        "class:Pairs",
        "coerce,list_OR_List,Pairs-method",
        "coerce,Pairs,DFrame-method",
        "first",
        "first,Pairs-method",
        "first<-",
        "first<-,Pairs-method",
        "makeNakedCharacterMatrixForDisplay,Pairs-method",
        "match,Pairs,Pairs-method",
        "names,Pairs-method",
        "names<-,Pairs-method",
        "order,Pairs-method",
        "Pairs",
        "Pairs-class",
        "parallel_slot_names,Pairs-method",
        "pcompare,Pairs,Pairs-method",
        "sameAsPreviousROW,Pairs-method",
        "second",
        "second,Pairs-method",
        "second<-",
        "second<-,Pairs-method",
        "show,Pairs-method",
        "t,Pairs-method",
        "zipup,Pairs,missing-method"
      ]
    },
    {
      "page": "RectangularData-class",
      "title": "RectangularData objects",
      "topics": [
        "cbind,RectangularData-method",
        "cbind.RectangularData",
        "class:RectangularData",
        "combineCols",
        "combineRows",
        "combineUniqueCols",
        "dim,RectangularData-method",
        "dimnames,RectangularData-method",
        "dimnames<-,RectangularData-method",
        "head,RectangularData-method",
        "head.RectangularData",
        "horizontal_slot_names",
        "rbind,RectangularData-method",
        "rbind.RectangularData",
        "RectangularData",
        "RectangularData-class",
        "ROWNAMES",
        "ROWNAMES,ANY-method",
        "ROWNAMES,RectangularData-method",
        "ROWNAMES<-",
        "ROWNAMES<-,ANY-method",
        "ROWNAMES<-,RectangularData-method",
        "subset,RectangularData-method",
        "tail,RectangularData-method",
        "tail.RectangularData",
        "vertical_slot_names"
      ]
    },
    {
      "page": "Rle-class",
      "title": "Rle objects",
      "topics": [
        "%in%,Rle,ANY-method",
        "anyDuplicated,Rle-method",
        "anyDuplicated,RleNSBS-method",
        "anyDuplicated.Rle",
        "anyNA,Rle-method",
        "append,Rle,vector-method",
        "append,vector,Rle-method",
        "as.data.frame,Rle-method",
        "as.factor,Rle-method",
        "as.integer,RleNSBS-method",
        "as.list,Rle-method",
        "as.list.Rle",
        "as.vector,Rle-method",
        "as.vector.Rle",
        "bindROWS,Rle-method",
        "class:Rle",
        "coerce,ANY,Rle-method",
        "coerce,Rle,character-method",
        "coerce,Rle,complex-method",
        "coerce,Rle,factor-method",
        "coerce,Rle,integer-method",
        "coerce,Rle,list-method",
        "coerce,Rle,logical-method",
        "coerce,Rle,numeric-method",
        "coerce,Rle,raw-method",
        "coerce,Rle,vector-method",
        "decode",
        "decode,ANY-method",
        "decode,Rle-method",
        "duplicated,Rle-method",
        "end,Rle-method",
        "extractROWS,Rle,ANY-method",
        "extractROWS,Rle,NSBS-method",
        "extractROWS,Rle,RangeNSBS-method",
        "extractROWS,Rle,RleNSBS-method",
        "findRun",
        "findRun,Rle-method",
        "intersect,ANY,Rle-method",
        "intersect,Rle,ANY-method",
        "intersect,Rle,Rle-method",
        "is.finite,Rle-method",
        "is.na,Rle-method",
        "is.unsorted,Rle-method",
        "isStrictlySorted,Rle-method",
        "isStrictlySorted,RleNSBS-method",
        "length,Rle-method",
        "length,RleNSBS-method",
        "match,ANY,Rle-method",
        "match,Rle,ANY-method",
        "match,Rle,Rle-method",
        "nrun",
        "nrun,Rle-method",
        "NSBS,Rle-method",
        "order,Rle-method",
        "rank,Rle-method",
        "rep,Rle-method",
        "rep.int,Rle-method",
        "replaceROWS,Rle,ANY-method",
        "replaceROWS,Rle-method",
        "rev,Rle-method",
        "rev.Rle",
        "Rle",
        "Rle,ANY-method",
        "Rle,Rle-method",
        "Rle-class",
        "runLength",
        "runLength,Rle-method",
        "runLength<-",
        "runLength<-,Rle-method",
        "runValue",
        "runValue,Rle-method",
        "runValue<-",
        "runValue<-,Rle-method",
        "setdiff,ANY,Rle-method",
        "setdiff,Rle,ANY-method",
        "setdiff,Rle,Rle-method",
        "show,Rle-method",
        "sort,Rle-method",
        "sort.Rle",
        "start,Rle-method",
        "table,Rle-method",
        "tabulate,Rle-method",
        "union,ANY,Rle-method",
        "union,Rle,ANY-method",
        "union,Rle,Rle-method",
        "unique,Rle-method",
        "width,Rle-method",
        "xtfrm,Rle-method",
        "[,Rle-method",
        "[<-,Rle,ANY-method",
        "[<-,Rle-method"
      ]
    },
    {
      "page": "Rle-runstat",
      "title": "Fixed-width running window summaries",
      "topics": [
        "Rle-runstat",
        "runmean",
        "runmean,Rle-method",
        "runmed,Rle-method",
        "runq",
        "runq,Rle-method",
        "runsum",
        "runsum,Rle-method",
        "runwtsum",
        "runwtsum,Rle-method",
        "smoothEnds,Rle-method"
      ]
    },
    {
      "page": "Rle-utils",
      "title": "Common operations on Rle objects",
      "topics": [
        "!,Rle-method",
        "chartr,ANY,ANY,Rle-method",
        "Complex,Rle-method",
        "cor,Rle,Rle-method",
        "cov,Rle,Rle-method",
        "diff,Rle-method",
        "diff.Rle",
        "droplevels,Rle-method",
        "droplevels.Rle",
        "grep,ANY,Rle-method",
        "grepl,ANY,Rle-method",
        "gsub,ANY,ANY,Rle-method",
        "IQR,Rle-method",
        "levels,Rle-method",
        "levels.Rle",
        "levels<-,Rle-method",
        "mad,Rle-method",
        "mad.Rle",
        "Math,Rle-method",
        "Math2,Rle-method",
        "mean,Rle-method",
        "mean.Rle",
        "median,Rle-method",
        "median.Rle",
        "nchar,Rle-method",
        "Ops,Rle,Rle-method",
        "Ops,Rle,vector-method",
        "Ops,vector,Rle-method",
        "paste,Rle-method",
        "pmax,Rle-method",
        "pmax.int,Rle-method",
        "pmin,Rle-method",
        "pmin.int,Rle-method",
        "quantile,Rle-method",
        "quantile.Rle",
        "Rle-utils",
        "sd,Rle-method",
        "sub,ANY,ANY,Rle-method",
        "substr,Rle-method",
        "substring,Rle-method",
        "Summary,Rle-method",
        "summary,Rle-method",
        "summary.Rle",
        "tolower,Rle-method",
        "toupper,Rle-method",
        "var,Rle,missing-method",
        "var,Rle,Rle-method",
        "which,Rle-method",
        "which.max,Rle-method"
      ]
    },
    {
      "page": "shiftApply-methods",
      "title": "Apply a function over subsequences of 2 vector-like objects",
      "topics": [
        "shiftApply",
        "shiftApply,Vector,Vector-method",
        "shiftApply,vector,vector-method",
        "shiftApply-methods"
      ]
    },
    {
      "page": "show-utils",
      "title": "Display utilities",
      "topics": [
        "cbind_mcols_for_display",
        "classNameForDisplay",
        "classNameForDisplay,ANY-method",
        "coolcat",
        "get_showHeadLines",
        "get_showTailLines",
        "makeClassinfoRowForCompactPrinting",
        "makeNakedCharacterMatrixForDisplay",
        "makeNakedCharacterMatrixForDisplay,ANY-method",
        "makePrettyMatrixForCompactPrinting",
        "printAtomicVectorInAGrid",
        "set_showHeadLines",
        "set_showTailLines",
        "show-utils",
        "showAsCell",
        "showAsCell,ANY-method",
        "showAsCell,AsIs-method",
        "showAsCell,character-method",
        "showAsCell,data.frame-method",
        "showAsCell,list-method",
        "showAsCell,numeric-method",
        "showHeadLines",
        "showTailLines"
      ]
    },
    {
      "page": "SimpleList-class",
      "title": "SimpleList objects",
      "topics": [
        "as.env,SimpleList-method",
        "as.list,SimpleList-method",
        "as.list.SimpleList",
        "class:SimpleList",
        "classNameForDisplay,SimpleList-method",
        "coerce,ANY,SimpleList-method",
        "coerce,list,List-method",
        "getListElement,SimpleList-method",
        "lapply,SimpleList-method",
        "names,SimpleList-method",
        "names<-,SimpleList-method",
        "parallel_slot_names,SimpleList-method",
        "SimpleList",
        "SimpleList-class",
        "updateObject,SimpleList-method"
      ]
    },
    {
      "page": "splitAsList",
      "title": "Divide a vector-like object into groups",
      "topics": [
        "relistToClass",
        "relistToClass,ANY-method",
        "split",
        "split,ANY,Vector-method",
        "split,list,Vector-method",
        "split,Vector,ANY-method",
        "split,Vector,Vector-method",
        "splitAsList",
        "splitAsList,ANY,ANY-method",
        "splitAsList,ANY-method",
        "splitAsList,SortedByQueryHits-method"
      ]
    },
    {
      "page": "stack-methods",
      "title": "Stack objects",
      "topics": [
        "mstack",
        "mstack,DataFrame-method",
        "mstack,Vector-method",
        "mstack,vector-method",
        "stack,List-method",
        "stack,matrix-method",
        "stack-methods"
      ]
    },
    {
      "page": "subsetting-utils",
      "title": "Subsetting utilities",
      "topics": [
        "anyDuplicated,NSBS-method",
        "anyDuplicated,RangeNSBS-method",
        "anyDuplicated.NSBS",
        "as.integer,NativeNSBS-method",
        "as.integer,RangeNSBS-method",
        "class:NSBS",
        "extractCOLS",
        "extractROWS",
        "extractROWS,ANY,ANY-method",
        "extractROWS,array,RangeNSBS-method",
        "extractROWS,data.frame,RangeNSBS-method",
        "extractROWS,vector_OR_factor,RangeNSBS-method",
        "getListElement",
        "getListElement,list-method",
        "isStrictlySorted,NSBS-method",
        "isStrictlySorted,RangeNSBS-method",
        "length,NSBS-method",
        "length,RangeNSBS-method",
        "max,NSBS-method",
        "max,RangeNSBS-method",
        "mergeROWS",
        "mergeROWS,ANY,ANY-method",
        "normalizeDoubleBracketSubscript",
        "normalizeSingleBracketReplacementValue",
        "normalizeSingleBracketReplacementValue,ANY-method",
        "normalizeSingleBracketSubscript",
        "NSBS",
        "NSBS,ANY-method",
        "NSBS,character-method",
        "NSBS,factor-method",
        "NSBS,logical-method",
        "NSBS,missing-method",
        "NSBS,NSBS-method",
        "NSBS,NULL-method",
        "NSBS,numeric-method",
        "NSBS-class",
        "replaceCOLS",
        "replaceROWS",
        "replaceROWS,ANY,ANY-method",
        "setListElement",
        "setListElement,list-method",
        "show,RangeNSBS-method",
        "subsetting-utils"
      ]
    },
    {
      "page": "TransposedDataFrame-class",
      "title": "TransposedDataFrame objects",
      "topics": [
        "as.list,TransposedDataFrame-method",
        "as.list.TransposedDataFrame",
        "as.matrix,TransposedDataFrame-method",
        "bindCOLS,TransposedDataFrame-method",
        "bindROWS,TransposedDataFrame-method",
        "class:TransposedDataFrame",
        "coerce,ANY,TransposedDataFrame-method",
        "coerce,DataFrame,TransposedDataFrame-method",
        "coerce,TransposedDataFrame,DataFrame-method",
        "colnames,TransposedDataFrame-method",
        "dimnames<-,TransposedDataFrame-method",
        "extractCOLS,TransposedDataFrame-method",
        "extractROWS,TransposedDataFrame,ANY-method",
        "getListElement,TransposedDataFrame-method",
        "length,TransposedDataFrame-method",
        "makeNakedCharacterMatrixForDisplay,TransposedDataFrame-method",
        "names,TransposedDataFrame-method",
        "names<-,TransposedDataFrame-method",
        "ncol,TransposedDataFrame-method",
        "normalizeSingleBracketReplacementValue,TransposedDataFrame-method",
        "nrow,TransposedDataFrame-method",
        "rownames,TransposedDataFrame-method",
        "show,TransposedDataFrame-method",
        "t,DataFrame-method",
        "t,TransposedDataFrame-method",
        "t.DataFrame",
        "t.TransposedDataFrame",
        "TransposedDataFrame",
        "TransposedDataFrame-class",
        "[,TransposedDataFrame-method",
        "[<-,TransposedDataFrame-method"
      ]
    },
    {
      "page": "Vector-class",
      "title": "Vector objects",
      "topics": [
        "anyNA,Vector-method",
        "append",
        "append,Vector,Vector-method",
        "as.character,Vector-method",
        "as.complex,Vector-method",
        "as.data.frame,Vector-method",
        "as.data.frame.Vector",
        "as.double,Vector-method",
        "as.env",
        "as.env,NULL-method",
        "as.env,Vector-method",
        "as.integer,Vector-method",
        "as.list,Vector-method",
        "as.list.Vector",
        "as.logical,Vector-method",
        "as.matrix,Vector-method",
        "as.matrix.Vector",
        "as.numeric,Vector-method",
        "as.raw,Vector-method",
        "bindROWS,Vector-method",
        "by,Vector-method",
        "c",
        "c,Vector-method",
        "class:Vector",
        "class:vector_OR_Vector",
        "coerce,Vector,character-method",
        "coerce,Vector,complex-method",
        "coerce,Vector,data.frame-method",
        "coerce,Vector,double-method",
        "coerce,Vector,factor-method",
        "coerce,Vector,integer-method",
        "coerce,Vector,logical-method",
        "coerce,Vector,numeric-method",
        "coerce,Vector,raw-method",
        "coerce,Vector,vector-method",
        "elementMetadata",
        "elementMetadata,Vector-method",
        "elementMetadata<-",
        "elementMetadata<-,Vector-method",
        "eval,expression,Vector-method",
        "eval,language,Vector-method",
        "expand.grid",
        "expand.grid,Vector-method",
        "extractROWS,Vector,ANY-method",
        "head",
        "head,Vector-method",
        "head.Vector",
        "is.na,Vector-method",
        "length,Vector-method",
        "lengths,Vector-method",
        "mcols",
        "mcols,Vector-method",
        "mcols<-",
        "mcols<-,Vector-method",
        "mergeROWS,ANY-method",
        "mergeROWS,Vector,ANY-method",
        "mergeROWS,Vector-method",
        "parallelVectorNames",
        "parallelVectorNames,ANY-method",
        "parallel_slot_names",
        "parallel_slot_names,Vector-method",
        "rename",
        "rename,Vector-method",
        "rename,vector-method",
        "rep",
        "rep,Vector-method",
        "rep.int",
        "rep.int,Vector-method",
        "replaceROWS,ANY-method",
        "replaceROWS,Vector,ANY-method",
        "replaceROWS,Vector-method",
        "rev",
        "rev,Vector-method",
        "rev.Vector",
        "subset",
        "subset,Vector-method",
        "subset.Vector",
        "summary,Vector-method",
        "summary.Vector",
        "tail",
        "tail,Vector-method",
        "tail.Vector",
        "transform,Vector-method",
        "transform.Vector",
        "unname",
        "unname,Vector-method",
        "updateObject,Vector-method",
        "values",
        "values,Vector-method",
        "values<-",
        "values<-,Vector-method",
        "Vector",
        "Vector-class",
        "vector_OR_Vector",
        "vector_OR_Vector-class",
        "window",
        "window,Vector-method",
        "window.Vector",
        "with,Vector-method",
        "xtabs,Vector-method",
        "[",
        "[,Vector-method",
        "[<-,Vector-method"
      ]
    },
    {
      "page": "Vector-comparison",
      "title": "Compare, order, tabulate vector-like objects",
      "topics": [
        "!=,ANY,Vector-method",
        "!=,Vector,ANY-method",
        "!=,Vector,Vector-method",
        "%in%,ANY,Vector-method",
        "%in%,Vector,ANY-method",
        "%in%,Vector,Vector-method",
        "<,ANY,Vector-method",
        "<,Vector,ANY-method",
        "<,Vector,Vector-method",
        "<=,ANY,Vector-method",
        "<=,Vector,ANY-method",
        "<=,Vector,Vector-method",
        "==,ANY,Vector-method",
        "==,Vector,ANY-method",
        "==,Vector,Vector-method",
        ">,ANY,Vector-method",
        ">,Vector,ANY-method",
        ">,Vector,Vector-method",
        ">=,ANY,Vector-method",
        ">=,Vector,ANY-method",
        ">=,Vector,Vector-method",
        "anyDuplicated,Vector-method",
        "anyDuplicated.Vector",
        "countMatches",
        "countMatches,ANY,ANY-method",
        "countMatches,ANY-method",
        "duplicated,Vector-method",
        "duplicated.Vector",
        "findMatches",
        "findMatches,ANY,ANY-method",
        "findMatches,ANY,missing-method",
        "match",
        "match,Vector,Vector-method",
        "pcompare",
        "pcompare,ANY,ANY-method",
        "pcompare,numeric,numeric-method",
        "rank,Vector-method",
        "sameAsPreviousROW",
        "sameAsPreviousROW,ANY-method",
        "sameAsPreviousROW,atomic-method",
        "sameAsPreviousROW,complex-method",
        "sameAsPreviousROW,integer-method",
        "sameAsPreviousROW,numeric-method",
        "sameAsPreviousROW,Rle-method",
        "selfmatch",
        "selfmatch,ANY-method",
        "selfmatch,factor-method",
        "selfmatch,Vector-method",
        "sort,Vector-method",
        "sort.Vector",
        "table,Vector-method",
        "unique,Vector-method",
        "unique.Vector",
        "Vector-comparison",
        "xtfrm,Vector-method"
      ]
    },
    {
      "page": "Vector-merge",
      "title": "Merge vector-like objects",
      "topics": [
        "merge",
        "merge,Vector,Vector-method",
        "Vector-merge"
      ]
    },
    {
      "page": "Vector-setops",
      "title": "Set operations on vector-like objects",
      "topics": [
        "intersect,Vector,Vector-method",
        "intersect.Vector",
        "setdiff,Vector,Vector-method",
        "setdiff.Vector",
        "setequal,Vector,Vector-method",
        "setequal.Vector",
        "union,Vector,Vector-method",
        "union.Vector",
        "Vector-setops"
      ]
    },
    {
      "page": "zip-methods",
      "title": "Convert between parallel vectors and lists",
      "topics": [
        "zipdown",
        "zipdown,ANY-method",
        "zipdown,List-method",
        "zipup",
        "zipup,ANY,ANY-method"
      ]
    }
  ],
  "_readme": "https://github.com/bioc/S4Vectors/raw/HEAD/README.md",
  "_rundeps": [
    "BiocGenerics",
    "generics"
  ],
  "_vignettes": [
    {
      "source": "S4QuickOverview.Rmd",
      "filename": "S4QuickOverview.html",
      "title": "A quick overview of the S4 class system",
      "author": "Hervé Pagès",
      "engine": "knitr::rmarkdown",
      "headings": [
        "What is S4?",
        "The S4 class system",
        "A different world",
        "",
        "S4 in Bioconductor",
        "S4 from an end-user point of view",
        "Where do S4 objects come from?",
        "How to manipulate S4 objects?",
        "How to find the right man page?",
        "Inspecting objects and discovering methods",
        "Implementing an S4 class (in 4 slides)",
        "Class definition and constructor",
        "Getters",
        "Extending an existing class",
        "Slot inheritance",
        "Method inheritance",
        "Incremental validity method",
        "What else?"
      ],
      "created": "2025-09-13 05:33:39",
      "modified": "2025-09-13 05:33:39",
      "commits": 1
    },
    {
      "source": "S4VectorsOverview.Rmd",
      "filename": "S4VectorsOverview.html",
      "title": "An Overview of the S4Vectors package",
      "author": "Patrick Aboyoun, Michael Lawrence, Hervé Pagès",
      "engine": "knitr::rmarkdown",
      "headings": [
        "Introduction",
        "Vector-like and list-like objects",
        "Vector-like objects",
        "Subsetting a vector-like object",
        "Concatenating vector-like objects",
        "Looping over subsequences of vector-like objects",
        "List-like objects",
        "Vector Annotations",
        "Session Information"
      ],
      "created": "2024-04-05 00:47:52",
      "modified": "2024-04-05 00:47:52",
      "commits": 1
    },
    {
      "source": "RleTricks.Rmd",
      "filename": "RleTricks.html",
      "title": "Rle Tips and Tricks",
      "author": "Patrick Aboyoun, Beryl Kanali",
      "engine": "knitr::rmarkdown",
      "headings": [],
      "created": "2022-12-07 02:50:41",
      "modified": "2022-12-07 02:50:41",
      "commits": 1
    }
  ],
  "_score": 16.44939512815299,
  "_indexed": true,
  "_nocasepkg": "s4vectors",
  "_universes": [
    "bioc",
    "hpages",
    "bioconductor"
  ],
  "_binaries": [
    {
      "r": "4.7.0",
      "os": "linux",
      "version": "0.51.3",
      "date": "2026-05-27T07:10:18.000Z",
      "distro": "noble",
      "arch": "aarch64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "6e32619f74220c8fcf256958df181bd394a2b29e92e79148dfba10b8ba4e9f0f",
      "status": "success",
      "check": "NOTE",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.7.0",
      "os": "linux",
      "version": "0.51.3",
      "date": "2026-05-27T07:10:20.000Z",
      "distro": "noble",
      "arch": "x86_64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "590f0eabcee6af3b2099e4b0d02b1efa2dca25a63226d2b2de8642b7bb8b82ea",
      "status": "success",
      "check": "NOTE",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.6.0",
      "os": "linux",
      "version": "0.51.3",
      "date": "2026-05-27T07:10:10.000Z",
      "distro": "noble",
      "arch": "aarch64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "7532fae9ca47fcd4b34832ae5682f680bcbf7558a28d7cab9d5e4dc458e0c1fe",
      "status": "success",
      "check": "NOTE",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.6.0",
      "os": "linux",
      "version": "0.51.3",
      "date": "2026-05-27T07:10:53.000Z",
      "distro": "noble",
      "arch": "x86_64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "effc7da310516c80548c5a18a2c412aabbd85274da3b0c5323158078f41cbe39",
      "status": "success",
      "check": "NOTE",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.5.3",
      "os": "mac",
      "version": "0.51.3",
      "date": "2026-05-27T07:57:46.000Z",
      "arch": "aarch64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "33915ff1788acbd823188878d13c1ce41ee04b224e7422a933bfaf36171bdd8b",
      "status": "failure",
      "check": "ERROR",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.5.3",
      "os": "mac",
      "version": "0.51.3",
      "date": "2026-05-27T07:58:28.000Z",
      "arch": "x86_64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "2848aa3dcfcffec4d608c159c816cb8fba30a7902b3ca428ee59aad774e4bef0",
      "status": "failure",
      "check": "ERROR",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.6.0",
      "os": "mac",
      "version": "0.51.3",
      "date": "2026-05-27T07:15:50.000Z",
      "arch": "aarch64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "c2038b952e817885ab234cb0e4ac94fde64b65a5bf8c2ee42a02ec22171f2904",
      "status": "success",
      "check": "NOTE",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.6.0",
      "os": "mac",
      "version": "0.51.3",
      "date": "2026-05-27T07:10:41.000Z",
      "arch": "x86_64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "b0daae54cd7e2161e33b61828208492b54df5830e21560ed23e740076d7086fb",
      "status": "success",
      "check": "NOTE",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.6.0",
      "os": "wasm",
      "version": "0.51.3",
      "date": "2026-05-27T07:09:58.000Z",
      "arch": "emscripten",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "527c5009bbde98aac744aa182acd3c786b479eca505b3e5f3e53041ebf5436d6",
      "status": "success",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.7.0",
      "os": "win",
      "version": "0.51.3",
      "date": "2026-05-27T07:09:25.000Z",
      "arch": "x86_64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "2552ae2c2beb044531368b4a974dd37425f88885f683c90e0eaa95827d039c12",
      "status": "success",
      "check": "WARNING",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.5.3",
      "os": "win",
      "version": "0.51.3",
      "date": "2026-05-27T07:57:05.000Z",
      "arch": "x86_64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "cf588e55091a2515619dea8843e7a69c7b29d60c8b681a335dd043729d02c286",
      "status": "failure",
      "check": "ERROR",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    },
    {
      "r": "4.6.0",
      "os": "win",
      "version": "0.51.3",
      "date": "2026-05-27T07:09:06.000Z",
      "arch": "x86_64",
      "commit": "6b6e8b0396cf84d00b05199a0580ea25284ed4b8",
      "fileid": "ddd6c4c844e8372780b2f78b036369dfb2f83ad0f7ef04a4e29c822054b3d8a2",
      "status": "success",
      "check": "WARNING",
      "buildurl": "https://github.com/r-universe/bioc/actions/runs/26496184394"
    }
  ]
}