SCM

SCM Repository

[tm] Diff of /pkg/R/corpus.R
ViewVC logotype

Diff of /pkg/R/corpus.R

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 958, Sat Jun 13 06:06:42 2009 UTC revision 1419, Sat May 2 17:23:47 2015 UTC
# Line 1  Line 1 
1  # Author: Ingo Feinerer  # Author: Ingo Feinerer
2    
3  prepareReader <- function(readerControl, defaultReader = NULL, ...) {  PCorpus <-
4      if (is.null(readerControl$reader))  function(x,
5          readerControl$reader <- defaultReader           readerControl = list(reader = reader(x), language = "en"),
6      if (is(readerControl$reader, "FunctionGenerator"))           dbControl = list(dbName = "", dbType = "DB1"))
7          readerControl$reader <- readerControl$reader(...)  {
8      if (is.null(readerControl$language))      stopifnot(inherits(x, "Source"))
         readerControl$language <- "eng"  
     readerControl  
 }  
   
 FCorpus <- function(object, readerControl = list(language = "eng")) {  
     readerControl <- prepareReader(readerControl, object@DefaultReader, ...)  
   
     if (!object@Vectorized)  
         stop("Source is not vectorized")  
   
     tdl <- lapply(mapply(c, pGetElem(object), id = seq_len(object@Length), SIMPLIFY = FALSE),  
                   function(x) readSlim(x[c("content", "uri")],  
                                        readerControl$language,  
                                        as.character(x$id)))  
   
     new("FCorpus", .Data = tdl)  
 }  
9    
10  PCorpus <- function(object,      readerControl <- prepareReader(readerControl, reader(x))
                     readerControl = list(reader = object@DefaultReader, language = "eng"),  
                     dbControl = list(dbName = "", dbType = "DB1"),  
                     ...) {  
     readerControl <- prepareReader(readerControl, object@DefaultReader, ...)  
11    
12      if (!filehash::dbCreate(dbControl$dbName, dbControl$dbType))      if (!filehash::dbCreate(dbControl$dbName, dbControl$dbType))
13          stop("error in creating database")          stop("error in creating database")
14      db <- filehash::dbInit(dbControl$dbName, dbControl$dbType)      db <- filehash::dbInit(dbControl$dbName, dbControl$dbType)
15    
16      # Allocate memory in advance if length is known      x <- open(x)
17      tdl <- if (object@Length > 0)      tdl <- vector("list", length(x))
         vector("list", as.integer(object@Length))  
     else  
         list()  
   
18      counter <- 1      counter <- 1
19      while (!eoi(object)) {      while (!eoi(x)) {
20          object <- stepNext(object)          x <- stepNext(x)
21          elem <- getElem(object)          elem <- getElem(x)
22          doc <- readerControl$reader(elem, readerControl$language, as.character(counter))          doc <- readerControl$reader(elem,
23          filehash::dbInsert(db, ID(doc), doc)                                      readerControl$language,
24          if (object@Length > 0) tdl[[counter]] <- ID(doc)                                      as.character(counter))
25          else tdl <- c(tdl, ID(doc))          filehash::dbInsert(db, meta(doc, "id"), doc)
26            tdl[[counter]] <- meta(doc, "id")
27          counter <- counter + 1          counter <- counter + 1
28      }      }
29        x <- close(x)
30    
31      df <- data.frame(MetaID = rep(0, length(tdl)), stringsAsFactors = FALSE)      p <- list(content = tdl,
32      filehash::dbInsert(db, "DMetaData", df)                meta = CorpusMeta(),
33      dmeta.df <- data.frame(key = "DMetaData", subset = I(list(NA)))                dmeta = data.frame(row.names = seq_along(tdl)),
34                  dbcontrol = dbControl)
35      cmeta.node <- new("MetaDataNode",      class(p) <- c("PCorpus", "Corpus")
36                        NodeID = 0,      p
37                        MetaData = list(create_date = as.POSIXlt(Sys.time(), tz = "GMT"), creator = Sys.getenv("LOGNAME")),  }
38                        children = list())  
39    Corpus <-
40      new("PCorpus", .Data = tdl, DMetaData = dmeta.df, CMetaData = cmeta.node, DBControl = dbControl)  VCorpus <-
41  }  function(x, readerControl = list(reader = reader(x), language = "en"))
42    {
43  # The "..." are additional arguments for the FunctionGenerator reader      stopifnot(inherits(x, "Source"))
44  SCorpus <- Corpus <- function(object,  
45                      readerControl = list(reader = object@DefaultReader, language = "eng"),      readerControl <- prepareReader(readerControl, reader(x))
46                      ...) {  
47      readerControl <- prepareReader(readerControl, object@DefaultReader, ...)      x <- open(x)
48        tdl <- vector("list", length(x))
49      # Allocate memory in advance if length is known      # Check for parallel element access
50      tdl <- if (object@Length > 0)      if (is.function(getS3method("pGetElem", class(x), TRUE)))
51          vector("list", as.integer(object@Length))          tdl <- mapply(function(elem, id)
52      else                            readerControl$reader(elem, readerControl$language, id),
53          list()                        pGetElem(x),
54                          id = as.character(seq_along(x)),
55      if (object@Vectorized)                        SIMPLIFY = FALSE)
         tdl <- lapply(mapply(c, pGetElem(object), id = seq_len(object@Length), SIMPLIFY = FALSE),  
                       function(x) readerControl$reader(x[c("content", "uri")],  
                                                        readerControl$language,  
                                                        as.character(x$id)))  
56      else {      else {
57          counter <- 1          counter <- 1
58          while (!eoi(object)) {          while (!eoi(x)) {
59              object <- stepNext(object)              x <- stepNext(x)
60              elem <- getElem(object)              elem <- getElem(x)
61              doc <- readerControl$reader(elem, readerControl$language, as.character(counter))              doc <- readerControl$reader(elem,
62              if (object@Length > 0)                                          readerControl$language,
63                                            as.character(counter))
64                  tdl[[counter]] <- doc                  tdl[[counter]] <- doc
             else  
                 tdl <- c(tdl, list(doc))  
65              counter <- counter + 1              counter <- counter + 1
66          }          }
67      }      }
68        x <- close(x)
69    
70      df <- data.frame(MetaID = rep(0, length(tdl)), stringsAsFactors = FALSE)      as.VCorpus(tdl)
     cmeta.node <- new("MetaDataNode",  
                       NodeID = 0,  
                       MetaData = list(create_date = as.POSIXlt(Sys.time(), tz = "GMT"), creator = Sys.getenv("LOGNAME")),  
                       children = list())  
   
     new("SCorpus", .Data = tdl, DMetaData = df, CMetaData = cmeta.node)  
 }  
   
 setGeneric("tmMap", function(object, FUN, ..., lazy = FALSE) standardGeneric("tmMap"))  
 setMethod("tmMap",  
           signature(object = "FCorpus", FUN = "function"),  
           function(object, FUN, ..., lazy = FALSE) {  
               if (lazy)  
                   warning("lazy mapping is deactivated")  
   
               new("FCorpus", .Data = lapply(object, FUN, ..., DMetaData = data.frame()))  
           })  
 setMethod("tmMap",  
           signature(object = "SCorpus", FUN = "function"),  
           function(object, FUN, ..., lazy = FALSE) {  
               result <- object  
               # Lazy mapping  
               if (lazy) {  
                   lazyTmMap <- meta(object, tag = "lazyTmMap", type = "corpus")  
                   if (is.null(lazyTmMap)) {  
                       meta(result, tag = "lazyTmMap", type = "corpus") <-  
                           list(index = rep(TRUE, length(result)),  
                                maps = list(function(x, DMetaData) FUN(x, ..., DMetaData = DMetaData)))  
71                    }                    }
72                    else {  
73                        lazyTmMap$maps <- c(lazyTmMap$maps, list(function(x, DMetaData) FUN(x, ..., DMetaData = DMetaData)))  `[.PCorpus` <-
74                        meta(result, tag = "lazyTmMap", type = "corpus") <- lazyTmMap  function(x, i)
75    {
76        if (!missing(i)) {
77            x$content <- x$content[i]
78            x$dmeta <- x$dmeta[i, , drop = FALSE]
79                    }                    }
80        x
81                }                }
82                else {  
83                    result@.Data <- if (clusterAvailable())  `[.VCorpus` <-
84                        snow::parLapply(snow::getMPIcluster(), object, FUN, ..., DMetaData = DMetaData(object))  function(x, i)
85                    else  {
86                        lapply(object, FUN, ..., DMetaData = DMetaData(object))      if (!missing(i)) {
87            x$content <- x$content[i]
88            x$dmeta <- x$dmeta[i, , drop = FALSE]
89            if (!is.null(x$lazy))
90                x$lazy$index <- x$lazy$index[i]
91                }                }
92                result      x
           })  
 setMethod("tmMap",  
           signature(object = "PCorpus", FUN = "function"),  
           function(object, FUN, ..., lazy = FALSE) {  
               # TODO: When should lazy mapping be conceptually available?  
               if (lazy)  
                   warning("lazy mapping is deactived when using database backend")  
               db <- filehash::dbInit(DBControl(object)[["dbName"]], DBControl(object)[["dbType"]])  
               i <- 1  
               for (id in unlist(object)) {  
                   db[[id]] <- FUN(object[[i]], ..., DMetaData = DMetaData(object))  
                   i <- i + 1  
               }  
               # Suggested by Christian Buchta  
               filehash::dbReorganize(db)  
   
               object  
           })  
   
 # Materialize lazy mappings  
 # Improvements by Christian Buchta  
 materialize <- function(corpus, range = seq_along(corpus)) {  
     lazyTmMap <- meta(corpus, tag = "lazyTmMap", type = "corpus")  
     if (!is.null(lazyTmMap)) {  
        # Make valid and lazy index  
        idx <- (seq_along(corpus) %in% range) & lazyTmMap$index  
        if (any(idx)) {  
            res <- corpus@.Data[idx]  
            for (m in lazyTmMap$maps)  
                res <- lapply(res, m, DMetaData = DMetaData(corpus))  
            corpus@.Data[idx] <- res  
            lazyTmMap$index[idx] <- FALSE  
        }  
     }  
     # Clean up if everything is materialized  
     if (!any(lazyTmMap$index))  
         lazyTmMap <- NULL  
     meta(corpus, tag = "lazyTmMap", type = "corpus") <- lazyTmMap  
     corpus  
 }  
   
 setGeneric("asPlain", function(object, FUN, ...) standardGeneric("asPlain"))  
 setMethod("asPlain", signature(object = "PlainTextDocument"),  
           function(object, FUN, ...) object)  
 setMethod("asPlain",  
           signature(object = "XMLTextDocument"),  
           function(object, FUN, ...) {  
               require("XML")  
   
               corpus <- Content(object)  
   
               # As XMLDocument is no native S4 class, restore valid information  
               class(corpus) <- "XMLDocument"  
               names(corpus) <- c("doc","dtd")  
   
               return(FUN(xmlRoot(corpus), ...))  
           })  
 setMethod("asPlain",  
           signature(object = "Reuters21578Document"),  
           function(object, FUN, ...) {  
               require("XML")  
   
               FUN <- convertReut21578XMLPlain  
               corpus <- Content(object)  
   
               # As XMLDocument is no native S4 class, restore valid information  
               class(corpus) <- "XMLDocument"  
               names(corpus) <- c("doc","dtd")  
   
               return(FUN(xmlRoot(corpus), ...))  
           })  
 setMethod("asPlain", signature(object = "RCV1Document"),  
           function(object, FUN, ...) convertRCV1Plain(object, ...))  
 setMethod("asPlain",  
           signature(object = "NewsgroupDocument"),  
           function(object, FUN, ...) {  
               new("PlainTextDocument", .Data = Content(object), Author = Author(object),  
                   DateTimeStamp = DateTimeStamp(object), Description = Description(object), ID = ID(object),  
                   Origin = Origin(object), Heading = Heading(object), Language = Language(object),  
                   LocalMetaData = LocalMetaData(object))  
           })  
 setMethod("asPlain",  
           signature(object = "StructuredTextDocument"),  
           function(object, FUN, ...) {  
               new("PlainTextDocument", .Data = unlist(Content(object)),  
                   Author = Author(object), DateTimeStamp = DateTimeStamp(object),  
                   Description = Description(object), ID = ID(object), Origin = Origin(object),  
                   Heading = Heading(object), Language = Language(object),  
                   LocalMetaData = LocalMetaData(object))  
           })  
   
 setGeneric("tmFilter", function(object, ..., FUN = searchFullText, doclevel = TRUE) standardGeneric("tmFilter"))  
 setMethod("tmFilter", signature(object = "Corpus"),  
           function(object, ..., FUN = searchFullText, doclevel = TRUE)  
               object[tmIndex(object, ..., FUN = FUN, doclevel = doclevel)])  
   
 setGeneric("tmIndex", function(object, ..., FUN = searchFullText, doclevel = TRUE) standardGeneric("tmIndex"))  
 setMethod("tmIndex",  
           signature(object = "Corpus"),  
           function(object, ..., FUN = searchFullText, doclevel = TRUE) {  
               if (!is.null(attr(FUN, "doclevel")))  
                   doclevel <- attr(FUN, "doclevel")  
               if (doclevel) {  
                   if (clusterAvailable())  
                       return(snow::parSapply(snow::getMPIcluster(), object, FUN, ..., DMetaData = DMetaData(object)))  
                   else  
                       return(sapply(object, FUN, ..., DMetaData = DMetaData(object)))  
93                }                }
               else  
                   return(FUN(object, ...))  
           })  
94    
95  # TODO: Replace with c(Corpus, TextDocument)?  .map_name_index <-
96  setGeneric("appendElem", function(object, data, meta = NULL) standardGeneric("appendElem"))  function(x, i)
97  setMethod("appendElem",  {
98            signature(object = "Corpus", data = "TextDocument"),      if (is.character(i))
99            function(object, data, meta = NULL) {          match(i, meta(x, "id", "local"))
               if (DBControl(object)[["useDb"]] && require("filehash")) {  
                   db <- dbInit(DBControl(object)[["dbName"]], DBControl(object)[["dbType"]])  
                   if (dbExists(db, ID(data)))  
                       warning("document with identical ID already exists")  
                   dbInsert(db, ID(data), data)  
                   object@.Data[[length(object)+1]] <- ID(data)  
               }  
100                else                else
101                    object@.Data[[length(object)+1]] <- data          i
               DMetaData(object) <- rbind(DMetaData(object), c(MetaID = CMetaData(object)@NodeID, meta))  
               return(object)  
           })  
   
 prescindMeta <- function(object, meta) {  
     df <- DMetaData(object)  
   
     for (m in meta)  
         df <- cbind(df, structure(data.frame(I(meta(object, tag = m, type = "local"))), names = m))  
   
     df  
102  }  }
103    
104  setMethod("[",  `[[.PCorpus` <-
105            signature(x = "FCorpus", i = "ANY", j = "ANY", drop = "ANY"),  function(x, i)
106            function(x, i, j, ... , drop) {  {
107                if (missing(i)) return(x)      i <- .map_name_index(x, i)
108        db <- filehash::dbInit(x$dbcontrol[["dbName"]], x$dbcontrol[["dbType"]])
109                x@.Data <- x@.Data[i, ..., drop = FALSE]      filehash::dbFetch(db, x$content[[i]])
110                x  }
111            })  `[[.VCorpus` <-
112  setMethod("[",  function(x, i)
113            signature(x = "PCorpus", i = "ANY", j = "ANY", drop = "ANY"),  {
114            function(x, i, j, ... , drop) {      i <- .map_name_index(x, i)
115                if (missing(i)) return(x)      if (!is.null(x$lazy))
116            .Call(copyCorpus, x, materialize(x, i))
117                x@.Data <- x@.Data[i, ..., drop = FALSE]      x$content[[i]]
               index <- x@DMetaData[[1 , "subset"]]  
               if (any(is.na(index))) x@DMetaData[[1 , "subset"]] <- i  
               else x@DMetaData[[1 , "subset"]] <- index[i]  
               x  
           })  
 setMethod("[",  
           signature(x = "SCorpus", i = "ANY", j = "ANY", drop = "ANY"),  
           function(x, i, j, ... , drop) {  
               if (missing(i)) return(x)  
   
               x@.Data <- x@.Data[i, ..., drop = FALSE]  
               DMetaData(x) <- DMetaData(x)[i, , drop = FALSE]  
               x  
           })  
   
 setMethod("[<-",  
           signature(x = "PCorpus", i = "ANY", j = "ANY", value = "ANY"),  
           function(x, i, j, ... , value) {  
               db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])  
               counter <- 1  
               for (id in x@.Data[i, ...]) {  
                   if (identical(length(value), 1)) db[[id]] <- value  
                   else db[[id]] <- value[[counter]]  
                   counter <- counter + 1  
118                }                }
               x  
           })  
 setMethod("[<-",  
           signature(x = "SCorpus", i = "ANY", j = "ANY", value = "ANY"),  
           function(x, i, j, ... , value) {  
               x@.Data[i, ...] <- value  
               x  
           })  
119    
120  setMethod("[[",  `[[<-.PCorpus` <-
121            signature(x = "PCorpus", i = "ANY", j = "ANY"),  function(x, i, value)
122            function(x, i, j, ...) {  {
123                db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])      i <- .map_name_index(x, i)
124                filehash::dbFetch(db, x@.Data[[i]])      db <- filehash::dbInit(x$dbcontrol[["dbName"]], x$dbcontrol[["dbType"]])
125            })      db[[x$content[[i]]]] <- value
 setMethod("[[",  
           signature(x = "SCorpus", i = "ANY", j = "ANY"),  
           function(x, i, j, ...) {  
               # TODO: For which corpora should lazy mapping be available?  
               lazyTmMap <- meta(x, tag = "lazyTmMap", type = "corpus")  
               if (!is.null(lazyTmMap))  
                   .Call("copyCorpus", x, materialize(x, i))  
               x@.Data[[i]]  
           })  
   
 setMethod("[[<-",  
           signature(x = "PCorpus", i = "ANY", j = "ANY", value = "ANY"),  
           function(x, i, j, ..., value) {  
               db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])  
               index <- x@.Data[[i]]  
               db[[index]] <- value  
126                x                x
           })  
 setMethod("[[<-",  
           signature(x = "SCorpus", i = "ANY", j = "ANY", value = "ANY"),  
           function(x, i, j, ..., value) {  
               # Mark new objects as not active for lazy mapping  
               lazyTmMap <- meta(x, tag = "lazyTmMap", type = "corpus")  
               if (!is.null(lazyTmMap)) {  
                   lazyTmMap$index[i] <- FALSE  
                   meta(x, tag = "lazyTmMap", type = "corpus") <- lazyTmMap  
127                }                }
128                # Set the value  `[[<-.VCorpus` <-
129                x@.Data[[i, ...]] <- value  function(x, i, value)
130    {
131        i <- .map_name_index(x, i)
132        # Mark new objects as inactive for lazy mapping
133        if (!is.null(x$lazy))
134            x$lazy$index[i] <- FALSE
135        x$content[[i]] <- value
136                x                x
           })  
   
 # Update \code{NodeID}s of a CMetaData tree  
 update_id <- function(object, id = 0, mapping = NULL, left.mapping = NULL, level = 0) {  
     # Traversal of (binary) CMetaData tree with setup of \code{NodeID}s  
     set_id <- function(object) {  
         object@NodeID <- id  
         id <<- id + 1  
         level <<- level + 1  
   
         if (length(object@children) > 0) {  
             mapping <<- cbind(mapping, c(object@children[[1]]@NodeID, id))  
             left <- set_id(object@children[[1]])  
             if (level == 1) {  
                 left.mapping <<- mapping  
                 mapping <<- NULL  
137              }              }
             mapping <<- cbind(mapping, c(object@children[[2]]@NodeID, id))  
             right <- set_id(object@children[[2]])  
138    
139              object@children <- list(left, right)  as.list.PCorpus <- as.list.VCorpus <-
140          }  function(x, ...)
141          level <<- level - 1      setNames(content(x), as.character(lapply(content(x), meta, "id")))
142    
143          return(object)  as.VCorpus <-
144    function(x)
145        UseMethod("as.VCorpus")
146    as.VCorpus.VCorpus <- identity
147    as.VCorpus.list <-
148    function(x)
149    {
150        v <- list(content = x,
151                  meta = CorpusMeta(),
152                  dmeta = data.frame(row.names = seq_along(x)))
153        class(v) <- c("VCorpus", "Corpus")
154        v
155      }      }
156    
157      list(root = set_id(object), left.mapping = left.mapping, right.mapping = mapping)  outer_union <-
158    function(x, y, ...)
159    {
160        if (nrow(x) > 0L)
161            x[, setdiff(names(y), names(x))] <- NA
162        if (nrow(y) > 0L)
163            y[, setdiff(names(x), names(y))] <- NA
164        res <- rbind(x, y)
165        if (ncol(res) == 0L)
166            res <- data.frame(row.names = seq_len(nrow(x) + nrow(y)))
167        res
168  }  }
169    
170  setMethod("c",  c.VCorpus <-
171            signature(x = "Corpus"),  function(..., recursive = FALSE)
172            function(x, ..., meta = list(merge_date = as.POSIXlt(Sys.time(), tz = "GMT"), merger = Sys.getenv("LOGNAME")), recursive = FALSE) {  {
173                args <- list(...)                args <- list(...)
174                if (identical(length(args), 0)) return(x)      x <- args[[1L]]
175    
176                if (!all(sapply(args, inherits, class(x))))      if (length(args) == 1L)
177            return(x)
178    
179        if (!all(unlist(lapply(args, inherits, class(x)))))
180                    stop("not all arguments are of the same corpus type")                    stop("not all arguments are of the same corpus type")
181    
182                if (inherits(x, "PCorpus"))      v <- list(content = do.call("c", lapply(args, content)),
183                    stop("concatenation of corpora with underlying databases is not supported")                meta = CorpusMeta(meta = do.call("c",
184                    lapply(args, function(a) meta(a, type = "corpus")))),
185                  dmeta = Reduce(outer_union, lapply(args, meta)))
186        class(v) <- c("VCorpus", "Corpus")
187        v
188    }
189    
190    content.VCorpus <-
191    function(x)
192    {
193        if (!is.null(x$lazy))
194            .Call(copyCorpus, x, materialize(x))
195        x$content
196    }
197    
198    content.PCorpus <-
199    function(x)
200    {
201        db <- filehash::dbInit(x$dbcontrol[["dbName"]], x$dbcontrol[["dbType"]])
202        filehash::dbMultiFetch(db, unlist(x$content))
203    }
204    
205    inspect <-
206    function(x)
207        UseMethod("inspect", x)
208    inspect.PCorpus <- inspect.VCorpus <-
209    function(x)
210    {
211        print(x)
212        cat("\n")
213        print(noquote(content(x)))
214        invisible(x)
215    }
216    
217                Reduce(c2, base::c(list(x), args))  length.PCorpus <- length.VCorpus <-
218            })  function(x)
219        length(x$content)
220    
221  setGeneric("c2", function(x, y, ..., meta = list(merge_date = as.POSIXlt(Sys.time(), tz = "GMT"), merger = Sys.getenv("LOGNAME"))) standardGeneric("c2"))  names.PCorpus <- names.VCorpus <-
222  setMethod("c2", signature(x = "FCorpus", y = "FCorpus"),  function(x)
223            function(x, y, ..., meta = list(merge_date = as.POSIXlt(Sys.time(), tz = "GMT"), merger = Sys.getenv("LOGNAME"))) {      as.character(meta(x, "id", "local"))
               new("FCorpus", .Data = c(as(x, "list"), as(y, "list")))  
           })  
 setMethod("c2", signature(x = "SCorpus", y = "SCorpus"),  
           function(x, y, ..., meta = list(merge_date = as.POSIXlt(Sys.time(), tz = "GMT"), merger = Sys.getenv("LOGNAME"))) {  
               object <- x  
               # Concatenate data slots  
               object@.Data <- c(as(x, "list"), as(y, "list"))  
   
               # Update the CMetaData tree  
               cmeta <- new("MetaDataNode", NodeID = 0, MetaData = meta, children = list(CMetaData(x), CMetaData(y)))  
               update.struct <- update_id(cmeta)  
               object@CMetaData <- update.struct$root  
   
               # Find indices to be updated for the left tree  
               indices.mapping <- NULL  
               for (m in levels(as.factor(DMetaData(x)$MetaID))) {  
                   indices <- (DMetaData(x)$MetaID == m)  
                   indices.mapping <- c(indices.mapping, list(m = indices))  
                   names(indices.mapping)[length(indices.mapping)] <- m  
               }  
   
               # Update the DMetaData data frames for the left tree  
               for (i in 1:ncol(update.struct$left.mapping)) {  
                   map <- update.struct$left.mapping[,i]  
                   x@DMetaData$MetaID <- replace(DMetaData(x)$MetaID, indices.mapping[[as.character(map[1])]], map[2])  
               }  
   
               # Find indices to be updated for the right tree  
               indices.mapping <- NULL  
               for (m in levels(as.factor(DMetaData(y)$MetaID))) {  
                   indices <- (DMetaData(y)$MetaID == m)  
                   indices.mapping <- c(indices.mapping, list(m = indices))  
                   names(indices.mapping)[length(indices.mapping)] <- m  
               }  
   
               # Update the DMetaData data frames for the right tree  
               for (i in 1:ncol(update.struct$right.mapping)) {  
                   map <- update.struct$right.mapping[,i]  
                   y@DMetaData$MetaID <- replace(DMetaData(y)$MetaID, indices.mapping[[as.character(map[1])]], map[2])  
               }  
   
               # Merge the DMetaData data frames  
               labels <- setdiff(names(DMetaData(y)), names(DMetaData(x)))  
               na.matrix <- matrix(NA, nrow = nrow(DMetaData(x)), ncol = length(labels), dimnames = list(row.names(DMetaData(x)), labels))  
               x.dmeta.aug <- cbind(DMetaData(x), na.matrix)  
               labels <- setdiff(names(DMetaData(x)), names(DMetaData(y)))  
               na.matrix <- matrix(NA, nrow = nrow(DMetaData(y)), ncol = length(labels), dimnames = list(row.names(DMetaData(y)), labels))  
               y.dmeta.aug <- cbind(DMetaData(y), na.matrix)  
               object@DMetaData <- rbind(x.dmeta.aug, y.dmeta.aug)  
   
               object  
           })  
   
 setMethod("c",  
           signature(x = "TextDocument"),  
           function(x, ..., recursive = FALSE){  
               args <- list(...)  
               if (identical(length(args), 0)) return(x)  
224    
225                dmeta.df <- data.frame(MetaID = rep(0, length(list(x, ...))), stringsAsFactors = FALSE)  `names<-.PCorpus` <- `names<-.VCorpus` <-
226                cmeta.node <- new("MetaDataNode",  function(x, value)
227                              NodeID = 0,  {
228                              MetaData = list(create_date = as.POSIXlt(Sys.time(), tz = "GMT"), creator = Sys.getenv("LOGNAME")),      meta(x, "id", "local") <- as.character(value)
229                              children = list())      x
   
               new("SCorpus", .Data = list(x, ...), DMetaData = dmeta.df, CMetaData = cmeta.node)  
           })  
   
 setMethod("show",  
           signature(object = "Corpus"),  
           function(object){  
               cat(sprintf(ngettext(length(object),  
                                    "A corpus with %d text document\n",  
                                    "A corpus with %d text documents\n"),  
                           length(object)))  
     })  
   
 setMethod("summary",  
           signature(object = "Corpus"),  
           function(object){  
               show(object)  
               if (length(DMetaData(object)) > 0) {  
                   cat(sprintf(ngettext(length(CMetaData(object)@MetaData),  
                                               "\nThe metadata consists of %d tag-value pair and a data frame\n",  
                                               "\nThe metadata consists of %d tag-value pairs and a data frame\n"),  
                                        length(CMetaData(object)@MetaData)))  
                   cat("Available tags are:\n")  
                   cat(strwrap(paste(names(CMetaData(object)@MetaData), collapse = " "), indent = 2, exdent = 2), "\n")  
                   cat("Available variables in the data frame are:\n")  
                   cat(strwrap(paste(names(DMetaData(object)), collapse = " "), indent = 2, exdent = 2), "\n")  
               }  
     })  
   
 inspect <- function(x) UseMethod("inspect", x)  
 inspect.PCorpus <- function(x) {  
     summary(x)  
     cat("\n")  
     db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])  
     show(filehash::dbMultiFetch(db, unlist(x)))  
 }  
 inspect.FCorpus <- inspect.SCorpus <- function(x) {  
     summary(x)  
     cat("\n")  
     print(noquote(lapply(x, identity)))  
230  }  }
231    
232  # No metadata is checked  format.PCorpus <- format.VCorpus <-
233  setGeneric("%IN%", function(x, y) standardGeneric("%IN%"))  function(x, ...)
234  setMethod("%IN%", signature(x = "TextDocument", y = "PCorpus"),  {
235            function(x, y) {      c(sprintf("<<%s>>", class(x)[1L]),
236                db <- filehash::dbInit(DBControl(y)[["dbName"]], DBControl(y)[["dbType"]])        sprintf("Metadata:  corpus specific: %d, document level (indexed): %d",
237                any(sapply(y, function(x, z) {x %in% Content(z)}, x))                length(meta(x, type = "corpus")),
238            })                ncol(meta(x, type = "indexed"))),
239  setMethod("%IN%", signature(x = "TextDocument", y = "SCorpus"),        sprintf("Content:  documents: %d", length(x)))
           function(x, y) x %in% y)  
   
 setMethod("lapply",  
           signature(X = "SCorpus"),  
           function(X, FUN, ...) {  
               lazyTmMap <- meta(X, tag = "lazyTmMap", type = "corpus")  
               if (!is.null(lazyTmMap))  
                   .Call("copyCorpus", X, materialize(X))  
               base::lapply(X, FUN, ...)  
           })  
 setMethod("lapply",  
           signature(X = "PCorpus"),  
           function(X, FUN, ...) {  
               db <- filehash::dbInit(DBControl(X)[["dbName"]], DBControl(X)[["dbType"]])  
               lapply(filehash::dbMultiFetch(db, unlist(X)), FUN, ...)  
           })  
   
 setMethod("sapply",  
           signature(X = "SCorpus"),  
           function(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE) {  
               lazyTmMap <- meta(X, tag = "lazyTmMap", type = "corpus")  
               if (!is.null(lazyTmMap))  
                   .Call("copyCorpus", X, materialize(X))  
               base::sapply(X, FUN, ...)  
           })  
 setMethod("sapply",  
           signature(X = "PCorpus"),  
           function(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE) {  
               db <- filehash::dbInit(DBControl(X)[["dbName"]], DBControl(X)[["dbType"]])  
               sapply(filehash::dbMultiFetch(db, unlist(X)), FUN, ...)  
           })  
   
 setAs("list", "SCorpus", function(from) {  
     cmeta.node <- new("MetaDataNode",  
                       NodeID = 0,  
                       MetaData = list(create_date = as.POSIXlt(Sys.time(), tz = "GMT"), creator = Sys.getenv("LOGNAME")),  
                       children = list())  
     data <- vector("list", length(from))  
     counter <- 1  
     for (f in from) {  
         data[[counter]] <- new("PlainTextDocument",  
                                .Data = f,  
                                DateTimeStamp = as.POSIXlt(Sys.time(), tz = "GMT"),  
                                ID = as.character(counter),  
                                Language = "eng")  
         counter <- counter + 1  
240      }      }
241      new("SCorpus", .Data = data,  
242          DMetaData = data.frame(MetaID = rep(0, length(from)), stringsAsFactors = FALSE),  writeCorpus <-
243          CMetaData = cmeta.node)  function(x, path = ".", filenames = NULL)
244  })  {
   
 setGeneric("writeCorpus", function(object, path = ".", filenames = NULL) standardGeneric("writeCorpus"))  
 setMethod("writeCorpus",  
           signature(object = "Corpus"),  
           function(object, path = ".", filenames = NULL) {  
245                filenames <- file.path(path,                filenames <- file.path(path,
246                                       if (is.null(filenames)) sapply(object, function(x) sprintf("%s.txt", ID(x)))        if (is.null(filenames))
247              sprintf("%s.txt", as.character(meta(x, "id", "local")))
248                                       else filenames)                                       else filenames)
249                i <- 1  
250                for (o in object) {      stopifnot(length(x) == length(filenames))
251                    writeLines(asPlain(o), filenames[i])  
252                    i <- i + 1      mapply(function(doc, f) writeLines(as.character(doc), f), x, filenames)
253    
254        invisible(x)
255                }                }
           })  

Legend:
Removed from v.958  
changed lines
  Added in v.1419

root@r-forge.r-project.org
ViewVC Help
Powered by ViewVC 1.0.0  
Thanks to:
Vienna University of Economics and Business Powered By FusionForge