Merge pull request #66 from r-lib/usage-spacing

Add spacing in \usage like roxygen does

R/cache.R

@@ -24,11 +24,17 @@
 #! }
 #! \usage{
 #! newcache(x)
+#!
 #! jamcache(x)
+#!
 #! cache(x)
+#!
 #! setcache(x, which, value)
+#!
 #! getcache(x, which)
+#!
 #! remcache(x)
+#!
 #! \method{print}{cache}(x, all.names = FALSE, pattern, ...)
 #! }
 #! \arguments{
@@ -182,8 +188,11 @@ print.cache<- function(x, all.names=FALSE, pattern, ...){
 #! }
 #! \usage{
 #! hashcache(x, nunique=NULL, ...)
+#!
 #! sortcache(x, has.na = NULL)
+#!
 #! sortordercache(x, has.na = NULL, stable = NULL)
+#!
 #! ordercache(x, has.na = NULL, stable = NULL, optimize = "time")
 #! }
 #! \arguments{
@@ -328,9 +337,13 @@ ordercache <- function(x, has.na = NULL, stable = NULL, optimize = "time"){
 #! }
 #! \usage{
 #!     \method{is.sorted}{integer64}(x, ...)
+#!
 #!     \method{na.count}{integer64}(x, ...)
+#!
 #!     \method{nvalid}{integer64}(x, ...)
+#!
 #!     \method{nunique}{integer64}(x, ...)
+#!
 #!     \method{nties}{integer64}(x, ...)
 #! }
 #! \arguments{

R/hash64.R

@@ -47,30 +47,55 @@
 #! }
 #! \usage{
 #! hashfun(x, ...)
+#!
 #! \method{hashfun}{integer64}(x, minfac=1.41, hashbits=NULL, ...)
+#!
 #! hashmap(x, ...)
+#!
 #! \method{hashmap}{integer64}(x, nunique=NULL, minfac=1.41, hashbits=NULL, cache=NULL, ...)
+#!
 #! hashpos(cache, ...)
+#!
 #! \method{hashpos}{cache_integer64}(cache, x, nomatch = NA_integer_, ...)
+#!
 #! hashrev(cache, ...)
+#!
 #! \method{hashrev}{cache_integer64}(cache, x, nomatch = NA_integer_, ...)
+#!
 #! hashfin(cache, ...)
+#!
 #! \method{hashfin}{cache_integer64}(cache, x, ...)
+#!
 #! hashrin(cache, ...)
+#!
 #! \method{hashrin}{cache_integer64}(cache, x, ...)
+#!
 #! hashdup(cache, ...)
+#!
 #! \method{hashdup}{cache_integer64}(cache, ...)
+#!
 #! hashuni(cache, ...)
+#!
 #! \method{hashuni}{cache_integer64}(cache, keep.order=FALSE, ...)
+#!
 #! hashmapuni(x, ...)
+#!
 #! \method{hashmapuni}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
+#!
 #! hashupo(cache, ...)
+#!
 #! \method{hashupo}{cache_integer64}(cache, keep.order=FALSE, ...)
+#!
 #! hashmapupo(x, ...)
+#!
 #! \method{hashmapupo}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
+#!
 #! hashtab(cache, ...)
+#!
 #! \method{hashtab}{cache_integer64}(cache, ...)
+#!
 #! hashmaptab(x, ...)
+#!
 #! \method{hashmaptab}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
 #! }
 #! \arguments{

R/highlevel64.R

@@ -22,6 +22,7 @@
 #! \usage{
 #! benchmark64(nsmall = 2^16, nbig = 2^25, timefun = repeat.time
 #! )
+#!
 #! optimizer64(nsmall = 2^16, nbig = 2^25, timefun = repeat.time
 #! , what = c("match", "\%in\%", "duplicated", "unique", "unipos", "table", "rank", "quantile")
 #! , uniorder = c("original", "values", "any")
@@ -1399,6 +1400,7 @@ optimizer64 <- function(nsmall=2L^16L, nbig=2L^25L, timefun=repeat.time
 #! }
 #! \usage{
 #! \method{match}{integer64}(x, table, nomatch = NA_integer_, nunique = NULL, method = NULL, ...)
+#!
 #! \method{\%in\%}{integer64}(x, table, ...)
 #! }
 #! \arguments{
@@ -1980,6 +1982,7 @@ unique.integer64 <- function(x
 #! }
 #! \usage{
 #! unipos(x, incomparables = FALSE, order = c("original","values","any"), ...)
+#!
 #! \method{unipos}{integer64}(x, incomparables = FALSE, order = c("original","values","any")
 #! , nunique = NULL, method = NULL, ...)
 #! }
@@ -2482,6 +2485,7 @@ as.integer64.factor <- function(x, ...)as.integer64(unclass(x))
 #! }
 #! \usage{
 #! keypos(x, ...)
+#!
 #! \method{keypos}{integer64}(x, method = NULL, ...)
 #! }
 #! \arguments{
@@ -2570,6 +2574,7 @@ keypos.integer64 <- function(x
 #! }
 #! \usage{
 #! tiepos(x, ...)
+#!
 #! \method{tiepos}{integer64}(x, nties = NULL, method = NULL, ...)
 #! }
 #! \arguments{
@@ -2751,6 +2756,7 @@ rank.integer64 <- function(x
 #! }
 #! \usage{
 #!     prank(x, ...)
+#!
 #!     \method{prank}{integer64}(x, method = NULL, ...)
 #! }
 #! \arguments{
@@ -2808,9 +2814,13 @@ prank.integer64 <- function(x
 #! \usage{
 #!     qtile(x, probs=seq(0, 1, 0.25), ...)
 #!     \method{qtile}{integer64}(x, probs = seq(0, 1, 0.25), names = TRUE, method = NULL, ...)
+#!
 #!     \method{quantile}{integer64}(x, probs = seq(0, 1, 0.25), na.rm = FALSE, names = TRUE, type=0L, ...)
+#!
 #!     \method{median}{integer64}(x, na.rm = FALSE, ...)
+#!
 #!  \method{mean}{integer64}(x, na.rm = FALSE, ...)
+#!
 #!     \method{summary}{integer64}(object, ...)
 #!  ## mean(x, na.rm = FALSE, ...)
 #!  ## or

R/integer64.R

@@ -62,9 +62,13 @@
 #! }
 #! \usage{
 #!  integer64(length)
+#!
 #!  \method{is}{integer64}(x)
+#!
 #!  \method{length}{integer64}(x) <- value
+#!
 #!  \method{print}{integer64}(x, quote=FALSE, ...)
+#!
 #!  \method{str}{integer64}(object, vec.len  = strO$vec.len, give.head = TRUE, give.length = give.head, ...)
 #! }
 #! \arguments{
@@ -964,14 +968,23 @@
 #! }
 #! \usage{
 #!  as.bitstring(x, ...)
+#!
 #!  \method{as.bitstring}{integer64}(x, ...)
+#!
 #!  \method{print}{bitstring}(x, ...)
+#!
 #!  \method{as.character}{integer64}(x, ...)
+#!
 #!  \method{as.double}{integer64}(x, keep.names = FALSE, ...)
+#!
 #!  \method{as.integer}{integer64}(x, ...)
+#!
 #!  \method{as.logical}{integer64}(x, ...)
+#!
 #!  \method{as.factor}{integer64}(x)
+#!
 #!  \method{as.ordered}{integer64}(x)
+#!
 #!  \method{as.list}{integer64}(x, ...)
 #! }
 #! \arguments{
@@ -1016,14 +1029,23 @@
 #! }
 #! \usage{
 #!  NA_integer64_
+#!
 #!  as.integer64(x, ...)
+#!
 #!  \method{as.integer64}{integer64}(x, ...)
+#!
 #!  \method{as.integer64}{NULL}(x, ...)
+#!
 #!  \method{as.integer64}{character}(x, ...)
+#!
 #!  \method{as.integer64}{bitstring}(x, ...)
+#!
 #!  \method{as.integer64}{double}(x, keep.names = FALSE, ...)
+#!
 #!  \method{as.integer64}{integer}(x, ...)
+#!
 #!  \method{as.integer64}{logical}(x, ...)
+#!
 #!  \method{as.integer64}{factor}(x, ...)
 #! }
 #! \arguments{
@@ -1085,8 +1107,11 @@
 #! }
 #! \usage{
 #!  \method{[}{integer64}(x, i, ...)
+#!
 #!  \method{[}{integer64}(x, ...) <- value
+#!
 #!  \method{[[}{integer64}(x, ...)
+#!
 #!  \method{[[}{integer64}(x, ...) <- value
 #! }
 #! \arguments{
@@ -1148,22 +1173,39 @@
 #! }
 #! \usage{
 #! \method{format}{integer64}(x, justify="right", ...)
+#!
 #! \method{is.na}{integer64}(x)
+#!
 #! \method{is.nan}{integer64}(x)
+#!
 #! \method{is.finite}{integer64}(x)
+#!
 #! \method{is.infinite}{integer64}(x)
+#!
 #! \method{!}{integer64}(x)
+#!
 #! \method{sign}{integer64}(x)
+#!
 #! \method{abs}{integer64}(x)
+#!
 #! \method{sqrt}{integer64}(x)
+#!
 #! \method{log}{integer64}(x, base)
+#!
 #! \method{log2}{integer64}(x)
+#!
 #! \method{log10}{integer64}(x)
+#!
 #! \method{floor}{integer64}(x)
+#!
 #! \method{ceiling}{integer64}(x)
+#!
 #! \method{trunc}{integer64}(x, ...)
+#!
 #! \method{round}{integer64}(x, digits=0)
+#!
 #! \method{signif}{integer64}(x, digits=6)
+#!
 #! \method{scale}{integer64}(x, center = TRUE, scale = TRUE)
 #! }
 #! \arguments{
@@ -1228,21 +1270,37 @@
 #! }
 #! \usage{
 #! \method{&}{integer64}(e1,e2)
+#!
 #! \method{|}{integer64}(e1,e2)
+#!
 #! \method{xor}{integer64}(x,y)
+#!
 #! \method{!=}{integer64}(e1,e2)
+#!
 #! \method{==}{integer64}(e1,e2)
+#!
 #! \method{<}{integer64}(e1,e2)
+#!
 #! \method{<=}{integer64}(e1,e2)
+#!
 #! \method{>}{integer64}(e1,e2)
+#!
 #! \method{>=}{integer64}(e1,e2)
+#!
 #! \method{+}{integer64}(e1,e2)
+#!
 #! \method{-}{integer64}(e1,e2)
+#!
 #! \method{*}{integer64}(e1,e2)
+#!
 #! \method{^}{integer64}(e1,e2)
+#!
 #! \method{/}{integer64}(e1,e2)
+#!
 #! \method{\%/\%}{integer64}(e1,e2)
+#!
 #! \method{\%\%}{integer64}(e1,e2)
+#!
 #! binattr(e1,e2) # for internal use only
 #! }
 #! \arguments{
@@ -1297,12 +1355,19 @@
 #! }
 #! \usage{
 #! \method{all}{integer64}(..., na.rm = FALSE)
+#!
 #! \method{any}{integer64}(..., na.rm = FALSE)
+#!
 #! \method{min}{integer64}(..., na.rm = FALSE)
+#!
 #! \method{max}{integer64}(..., na.rm = FALSE)
+#!
 #! \method{range}{integer64}(..., na.rm = FALSE, finite = FALSE)
+#!
 #! lim.integer64()
+#!
 #! \method{sum}{integer64}(..., na.rm = FALSE)
+#!
 #! \method{prod}{integer64}(..., na.rm = FALSE)
 #! }
 #! \arguments{
@@ -1349,9 +1414,13 @@
 #! }
 #! \usage{
 #! \method{cummin}{integer64}(x)
+#!
 #! \method{cummax}{integer64}(x)
+#!
 #! \method{cumsum}{integer64}(x)
+#!
 #! \method{cumprod}{integer64}(x)
+#!
 #! \method{diff}{integer64}(x, lag = 1L, differences = 1L, ...)
 #! }
 #! \arguments{
@@ -1391,7 +1460,9 @@
 #! }
 #! \usage{
 #! \method{c}{integer64}(..., recursive = FALSE)
+#!
 #! \method{cbind}{integer64}(...)
+#!
 #! \method{rbind}{integer64}(...)
 #! }
 #! \arguments{
@@ -1549,6 +1620,7 @@
 #! }
 #! \usage{
 #!   plusclass(class, whichclass)
+#!
 #!   minusclass(class, whichclass)
 #! }
 #! \arguments{