R.oo/0000755000176200001440000000000014711213442011066 5ustar liggesusersR.oo/tests/0000755000176200001440000000000014554121067012236 5ustar liggesusersR.oo/tests/Object.finalize,noattach.R0000644000176200001440000000200314554071366017166 0ustar liggesusersoopts <- options(warn=1L) message("TESTING: finalize() on Object without attach ...") pkgs <- c("R.methodsS3", "R.oo") isAttached <- function(pkgs) { structure(sprintf("package:%s", pkgs) %in% search(), names=pkgs) } # Record which packages were attached from the beginning # (happens if not a fresh session) wasAttached <- isAttached(pkgs) assertPackages <- function(loaded=c("R.methodsS3", "R.oo")) { s <- utils::sessionInfo() s$R.version <- NULL s$platform <- "" s$locale <- "" cat("----------------------------------") print(s) cat("----------------------------------\n\n") loaded <- loaded[!wasAttached[loaded]] stopifnot(!any(isAttached(loaded))) } R.oo::setConstructorS3("MyClass", function(a=1:10) { R.oo::extend(R.oo::Object(), "MyClass", a=a) }) # Create an object with a finalizer x <- MyClass() assertPackages() # Remove 'x' so that it will be finalized below rm(x) gc() assertPackages(loaded="R.oo") message("TESTING: finalize() on Object without attach ... DONE") options(oopts) R.oo/tests/Object.R0000644000176200001440000000375014554071366013602 0ustar liggesusersmessage("TESTING: Object...") library("R.oo") obj <- Object() print(obj) obj <- Object(42L) print(obj) stopifnot(obj == 42L) obj$a <- 1:99 print(obj) fields <- getFields(obj) print(fields) hasA <- hasField(obj, "a") print(hasA) stopifnot(hasA) value <- obj$a str(value) stopifnot(identical(value, 1:99)) obj$a <- 1:100 print(obj) value <- obj[["a"]] str(value) stopifnot(identical(value, 1:100)) obj[["a"]] <- 1:101 print(obj) value <- obj[["a"]] str(value) stopifnot(identical(value, 1:101)) size <- objectSize(obj) print(size) ref <- isReferable(obj) print(ref) stopifnot(isTRUE(ref)) time <- getInstantiationTime(obj) print(time) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Attach and detach # - - - - - - - - - - - - - - - - - - - - - - - - - - - - res <- attach(obj) print(res) stopifnot(exists("a", mode="integer")) str(a) ## Object already attached res <- tryCatch(attach(obj), warning=function(w) w) stopifnot(inherits(res, "warning")) res <- detach(obj) print(res) ## Object already detached res <- tryCatch(detach(obj), warning=function(w) w) stopifnot(inherits(res, "warning")) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Save and load # - - - - - - - - - - - - - - - - - - - - - - - - - - - - obj <- Object() obj$a <- 1 obj$b <- 2 pathnameT <- tempfile() save(obj, file=pathnameT) obj2 <- Object$load(pathnameT) stopifnot(all.equal(getFields(obj2), getFields(obj))) for (key in getFields(obj)) { stopifnot(identical(obj2[[key]], obj[[key]])) } file.remove(pathnameT) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Class # - - - - - - - - - - - - - - - - - - - - - - - - - - - - obj2 <- newInstance(obj, 43L) print(obj2) stopifnot(obj2 == 43L) hash <- hashCode(obj) print(hash) stopifnot(length(hash) == 1L) neq <- equals(obj, 1) print(neq) stopifnot(!neq) eq <- equals(obj, obj) print(eq) stopifnot(eq) obj3 <- clone(obj) print(obj3) stopifnot(!identical(obj3, obj)) stopifnot(all.equal(obj3, obj)) message("TESTING: Object...DONE") R.oo/tests/getConstructorS3.R0000644000176200001440000000023714554071366015624 0ustar liggesusersmessage("TESTING: getConstructorS3()...") library("R.oo") fcn <- getConstructorS3("Object") print(args(fcn)) message("TESTING: getConstructorS3()...DONE") R.oo/tests/Package.unload.R0000644000176200001440000000030414554071366015200 0ustar liggesusersmessage("TESTING: Package unloading...") library("R.oo") pkg <- Package("datasets") load(pkg) print(isLoaded(pkg)) unload(pkg) print(isLoaded(pkg)) message("TESTING: Package unloading...DONE") R.oo/tests/Object.finalize.R0000644000176200001440000000162514554071366015401 0ustar liggesuserslibrary("R.oo") oopts <- options(warn=1L) message("TESTING: finalize() on Object ...") setConstructorS3("MyClass", function() { extend(Object(), "MyClass") }) setMethodS3("finalize", "MyClass", function(this, ...) { cat(as.character(this), "is about to be removed from the memory!\n") }) o <- MyClass() o <- MyClass() o <- MyClass() o <- MyClass() gc() ## MyClass: 0x01BE602C is about to be removed from the memory! ## MyClass: 0x01BFF634 is about to be removed from the memory! ## MyClass: 0x01C13584 is about to be removed from the memory! ## used (Mb) gc trigger (Mb) ## Ncells 229903 6.2 467875 12.5 ## Vcells 53725 0.5 786432 6.0 rm(o) ## MyClass: 0x01C578B0 is about to be removed from the memory! ## used (Mb) gc trigger (Mb) ## Ncells 229903 6.1 467875 12.3 ## Vcells 53725 0.5 786432 6.0 message("TESTING: finalize() on Object ... DONE") options(oopts) R.oo/tests/zzz.Object.finalize,reentrant.R0000644000176200001440000000262114554071366020231 0ustar liggesusersmessage("TESTING: finalize() reentrant...") ## FIXME: 'covr' does not play well with tests ## detaching/unloading packages if ("covr" %in% loadedNamespaces()) { detach <- function(...) NULL } library("R.methodsS3") library("R.oo") lotsOfParsing <- function(code="y <- 1:3") { parse(text=rep(code, times=10000)) } setConstructorS3("MyClass", function(a=1:10) { extend(Object(), "MyClass", a=a) }) setMethodS3("finalize", "MyClass", function(this, ...) { cat("finalize...\n") utils::str(sys.calls()) cat("finalize...done\n") }) # Parse and eval expression (works) expr <- lotsOfParsing() eval(expr) print(y) ## [1] 1 2 3 stopifnot(identical(y, 1:3)) # Create an object with a finalizer x <- MyClass() # Detach R.oo so that the finalizer will try to reload it detach("package:R.oo") # Remove 'x' so that it will be finalized below rm(x) # This may trigger garbage collection via parse() # If so, it is important that parse() is not called # (indirectly via library()) by the finalizer. # Because otherwise R may crash. expr2 <- lotsOfParsing(code="y <- 1:4") ## finalize... ## Dotted pair list of 9 ## $ : ... ## ... ## $ : language function (env) { ... ## $ : language finalize(this) ## $ : language finalize.MyClass(this) ## Parse called: TRUE ## finalize...done eval(expr2) print(y) ## [1] 1 2 3 4 stopifnot(identical(y, 1:4)) print(warnings()) message("TESTING: finalize() reentrant...DONE") R.oo/tests/InternalErrorException.reportBug.R0000644000176200001440000000127414554071366021010 0ustar liggesusersmessage("TESTING: InternalErrorException...") library("R.oo") ex <- InternalErrorException("Hmm... I didn't expect this!") print(ex) ex2 <- InternalErrorException("Hmm... I didn't expect this!", package=R.oo) print(ex2) ex3 <- InternalErrorException("Hmm... I didn't expect this!", package="R.oo") print(ex3) myLog <- function(x, ...) { if (!is.numeric(x)) { throw(InternalErrorException("Argument 'x' to myLog() is not numeric: ", mode(x), package=R.oo)) } log(x, ...) } myLog(2) ex <- NULL tryCatch({ myLog("a") }, error= function(ex) { ex <- Exception$getLastException() }) message("TESTING: InternalErrorException...DONE") R.oo/tests/hashCode.R0000644000176200001440000000367114554121067014106 0ustar liggesuserslibrary(R.oo) message("hashCode() ...") message("- NULL") y <- hashCode(NULL) print(y) stopifnot(is.null(y)) message("- empty vectors") y <- hashCode(character(0L)) print(y) stopifnot(is.null(y)) y <- hashCode(integer(0L)) print(y) stopifnot(is.null(y)) y <- hashCode(double(0L)) print(y) stopifnot(is.null(y)) y <- hashCode(list()) print(y) stopifnot(is.null(y)) message("- strings") x <- "" y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), y == 0L ) x <- base::letters y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), all(y == charToInt(base::letters)) ) x <- "abcdefghij" y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), y == -634317659L ) x <- "abcdefghijklmno" y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), y == 486644840L ) ## Assert no integer overflow => NA for (n in seq_along(base::letters)) { x <- paste(base::letters[seq_len(n)], collapse = "") y <- hashCode(x) cat(sprintf("%s => %d\n", x, y)) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y) ) } message("- integers") x <- 1:10 y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), all(y == x) ) message("- doubles") x <- as.numeric(1:10) y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), all(y == as.integer(x)) ) message("- complex") x <- 1:10 + 0.1 y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), all(y == 1:10) ) message("- miscellaneous types") x <- list(0L) y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), y == 0L ) x <- as.list(1:10) y <- hashCode(x) print(y) stopifnot( is.integer(y), length(y) == length(x), !anyNA(y), all(y == 1:10) ) message("hashCode() ... DONE") R.oo/tests/typeOfClass.R0000644000176200001440000000107014554071366014621 0ustar liggesusersmessage("TESTING: typeOfClass()...") library("R.oo") type <- typeOfClass(NULL) print(type) stopifnot(is.na(type)) type <- typeOfClass(Object) print(type) stopifnot(type == "S3-Object") type <- typeOfClass("Object") print(type) stopifnot(type == "S3-Object") library("methods") type <- typeOfClass("data.frame") print(type) stopifnot(type == "S4") clazz <- getClass("data.frame") type <- typeOfClass(clazz) print(type) stopifnot(type == "S4") type <- typeOfClass("Non-Existing-Class") print(type) stopifnot(is.na(type)) message("TESTING: typeOfClass()...DONE") R.oo/tests/attachLocally.Object.R0000644000176200001440000000073514554071366016365 0ustar liggesusersmessage("TESTING: attachLocally()...") library("R.oo") foo <- function(object, arg1="some value", ...) { cat("Local objects in foo():\n") print(ls()) attachLocally(object) cat("\nLocal objects in foo():\n") print(ls()) for (name in ls()) { cat("\nObject '", name, "':\n", sep="") print(get(name, inherits=FALSE)) } } a <- "A string" obj <- Object() obj$a <- "Another string" obj$b <- NA foo(obj) print(a) message("TESTING: attachLocally()...DONE") R.oo/tests/BasicObject.R0000644000176200001440000000532014554071366014537 0ustar liggesusersmessage("TESTING: BasicObject...") library("R.oo") obj <- BasicObject() print(obj) obj <- BasicObject(42L) print(obj) stopifnot(obj == 42L) obj$a <- 1:99 print(obj) fields <- getFields(obj) print(fields) hasA <- hasField(obj, "a") print(hasA) stopifnot(hasA) value <- obj$a str(value) stopifnot(identical(value, 1:99)) obj$a <- 1:100 print(obj) value <- obj[["a"]] str(value) stopifnot(identical(value, 1:100)) obj[["a"]] <- 1:101 print(obj) value <- obj[["a"]] str(value) stopifnot(identical(value, 1:101)) size <- objectSize(obj) print(size) ref <- isReferable(obj) print(ref) stopifnot(isTRUE(ref)) time <- getInstantiationTime(obj) print(time) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Attach and detach # - - - - - - - - - - - - - - - - - - - - - - - - - - - - obj <- BasicObject(42L) obj$a <- 1:99 res <- attach(obj) print(res) stopifnot(exists("a", mode="integer")) str(a) ## Object already attached res <- tryCatch(attach(obj), warning=function(w) w) stopifnot(inherits(res, "warning")) res <- detach(obj) print(res) ## Object already detached res <- tryCatch(detach(obj), warning=function(w) w) stopifnot(inherits(res, "warning")) obj <- BasicObject(list(a=1L, b=2, c=3)) res <- attach(obj) print(res) stopifnot(exists("a", mode="integer")) str(a) res <- detach(obj) print(res) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Class # - - - - - - - - - - - - - - - - - - - - - - - - - - - - obj2 <- newInstance(obj, 43L) print(obj2) stopifnot(obj2 == 43L) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Inheritance # - - - - - - - - - - - - - - - - - - - - - - - - - - - - setConstructorS3("MyObject", function(...) { extend(BasicObject(), "MyObject", ...) }) obj <- MyObject(a=1, b=2) print(obj) str(obj) stopifnot(all(c("a", "b") %in% names(attributes(obj)))) setMethodS3("foo", "MyObject", function(static, x=1L, ...) { list(x=x, ...) }, static=TRUE) res <- MyObject$foo(y=2L) stopifnot(identical(res$x, 1L)) stopifnot(identical(res$y, 2L)) obj$a <- 3 print(obj) value <- obj[["a"]] str(value) stopifnot(identical(value, 3)) obj[["a"]] <- 4 print(obj) value <- obj$a str(value) stopifnot(identical(value, 4)) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # FIXME: hashCode() return integer(0) whenever # getInstantiationTime() returns NULL, which is # now the default behavior of BasicObject # - - - - - - - - - - - - - - - - - - - - - - - - - - - - hash <- hashCode(obj) print(hash) ## FIXME: Currently returns integer(0) ## stopifnot(length(hash) == 1L) neq <- equals(obj, 1) print(neq) ## FIXME: Currently returns NA ## stopifnot(!neq) eq <- equals(obj, obj) print(eq) ## FIXME: Currently returns NA ## stopifnot(eq) message("TESTING: BasicObject...DONE") R.oo/tests/abort.R0000644000176200001440000000160114554071366013474 0ustar liggesusersmessage("TESTING: abort()...") library("R.oo") foo <- function() { cat("foo()...\n") on.exit(cat("foo()...done\n")) tryCatch({ stop("Woops!") }, error = function(ex) { cat("An error was caught: ", ex$message, "\n", sep="") }) cat("Continuing...\n") } bar <- function() { cat("bar()...\n") on.exit(cat("bar()...done\n")) tryCatch({ abort("Woops!") }, error = function(ex) { cat("An error was caught: ", ex$message, "\n", sep="") }) cat("This message will never be displayed...\n") } # An error generated by stop() can be caught foo() ## abort() will abort covr::package_coverage() and ## and any other evaluations beyond this point. if (!"covr" %in% loadedNamespaces() && FALSE) { # ...which is not possible when using abort() bar() # This expression is never reached cat("This line will never be outputted.\n") } # message("TESTING: abort()...DONE") R.oo/tests/extend.default.R0000644000176200001440000000203314554071366015277 0ustar liggesusersmessage("TESTING: extend()...") library("R.oo") setConstructorS3("MyDouble", function(value=0, ...) { extend(as.double(value), "MyDouble", ...) }) setMethodS3("as.character", "MyDouble", function(object, ...) { fmtstr <- attr(object, "fmtstr") if (is.null(fmtstr)) fmtstr <- "%.6f" sprintf(fmtstr, object) }) setMethodS3("print", "MyDouble", function(object, ...) { print(as.character(object), ...) }) x <- MyDouble(3.1415926) print(x) x <- MyDouble(3.1415926, fmtstr="%3.2f") print(x) attr(x, "fmtstr") <- "%e" print(x) setConstructorS3("MyList", function(value=0, ...) { extend(list(value=value, ...), "MyList") }) setMethodS3("as.character", "MyList", function(object, ...) { fmtstr <- object$fmtstr if (is.null(fmtstr)) fmtstr <- "%.6f" sprintf(fmtstr, object$value) }) setMethodS3("print", "MyList", function(object, ...) { print(as.character(object), ...) }) x <- MyList(3.1415926) print(x) x <- MyList(3.1415926, fmtstr="%3.2f") print(x) x$fmtstr <- "%e" print(x) message("TESTING: extend()...DONE") R.oo/tests/local.R0000644000176200001440000000106314554071366013461 0ustar liggesusersmessage("TESTING: local()...") library("R.oo") setConstructorS3("Foo", function() { extend(Object(), "Foo") }) setMethodS3("finalize", "Foo", function(this, ...) { cat("Finalized Foo\n") }) x <- Foo() print(x) # Trigger finalizer via garbage collection rm(list="x") gc() local({ setConstructorS3("Bar", function() { extend(Object(), "Bar") }) setMethodS3("finalize", "Bar", function(this, ...) { cat("Finalized Bar\n") }) x <- Bar() print(x) # Trigger finalizer via garbage collection rm(list="x") gc() }) message("TESTING: local()...DONE") R.oo/tests/Class.R0000644000176200001440000000253114554071366013435 0ustar liggesusersmessage("TESTING: Class...") library("R.oo") clazz <- Object print(clazz) print(as.character(clazz)) message(" - instantiation ...") obj <- Object() print(obj) obj <- newInstance(clazz) print(obj) stopifnot(inherits(obj, "Object")) obj <- clazz[["newInstance"]]() print(obj) stopifnot(inherits(obj, "Object")) message(" - instantiation ... DONE") message(" - reflection ...") clazz <- Class$forName("Object") print(clazz) print(getKnownSubclasses(clazz)) static <- getStaticInstance(clazz) print(static) pkg <- getPackage(clazz) print(pkg) stopifnot(pkg == "R.oo") ## Odds and ends print(isBeingCreated(clazz)) ## FIXME: Case should never occur but code allows for it print(isBeingCreated.Class(obj)) message(" - reflection ... DONE") message(" - modifiers ...") print(isAbstract(clazz)) print(isPrivate(clazz)) print(isProtected(clazz)) print(isPublic(clazz)) print(isDeprecated(clazz)) print(isStatic(clazz)) ## TRUE because of Object$load() message(" - modifiers ... DONE") message(" - inheritance ...") setConstructorS3("MyClass", function(...) { extend(Object(), "MyClass", ...) }) obj <- MyClass(a=1, b=2, c=3) print(obj) stopifnot(all(c("a", "b", "c") %in% names(obj))) obj <- newInstance(MyClass, a=1, b=2, c=3) print(obj) stopifnot(all(c("a", "b", "c") %in% names(obj))) message(" - inheritance ... DONE") message("TESTING: Class...DONE") R.oo/tests/throw.R0000644000176200001440000000105514554071366013533 0ustar liggesusersmessage("TESTING: throw()...") library("R.oo") ## Generate an error ex <- tryCatch({ stop("An error") }, error = function(ex) { ex }) print(ex) ## Re-throw the error ex2 <- tryCatch({ throw(ex) }, error = function(ex) { ex }) print(ex2) stopifnot(identical(ex2, ex)) ## Generate an Exception ex <- tryCatch({ throw("An error") }, error = function(ex) { ex }) print(ex) ## Re-throw the Exception ex2 <- tryCatch({ throw(ex) }, error = function(ex) { ex }) print(ex2) stopifnot(identical(ex2, ex)) message("TESTING: throw()...DONE") R.oo/tests/ASCII.R0000644000176200001440000000053014554071366013215 0ustar liggesusersmessage("TESTING: ASCII...") library("R.oo") ## Display ASCII table print(R.oo::ASCII) idxs <- 1:255 str(idxs) chars <- intToChar(idxs) print(chars) stopifnot(length(chars) == length(idxs)) idxs2 <- charToInt(chars) str(idxs2) stopifnot(length(idxs2) == length(chars)) stopifnot(identical(idxs2, idxs)) message("TESTING: ASCII...DONE") R.oo/tests/equals.R0000644000176200001440000000034614554071366013664 0ustar liggesusersmessage("TESTING: equals()...") library("R.oo") print(equals(1,1)) print(equals(1,2)) a <- 1:100 b <- 1:100 print(equals(a,b)) obj <- Object() print(equals(obj, 1)) print(equals(obj, obj)) message("TESTING: equals()...DONE") R.oo/tests/Interface.R0000644000176200001440000000120014554071366014260 0ustar liggesuserslibrary("R.oo") message("TESTING: Interface...") int <- Interface() print(int) setConstructorS3("MyInterface", function(...) { extend(Interface(), "MyInterface") }) int <- MyInterface() print(int) setConstructorS3("MyClass", function(...) { extend(Object(), c("MyClass", uses(MyInterface(), Interface()))) }) obj <- MyClass() print(obj) ## For some reason uses() doesn't play well with covr if (!"covr" %in% loadedNamespaces()) { setConstructorS3("MyClass", function(...) { extend(Object(), c("MyClass", uses("MyInterface", "Interface"))) }) obj <- MyClass() print(obj) } message("TESTING: Interface...DONE") R.oo/tests/StaticMethodsAndNamespaces.R0000644000176200001440000000030114554071366017557 0ustar liggesusersmessage("TESTING: Static methods and classes...") clazz <- R.oo::Class print(clazz) clazz <- R.oo::Class$forName("Object") print(clazz) message("TESTING: Static methods and classes...DONE") R.oo/tests/Object.finalize,onoff.R0000644000176200001440000000323014554071366016477 0ustar liggesuserslibrary("R.methodsS3") library("R.oo") oopts <- options(warn=1L) message("TESTING: finalize() on Object on and off ...") finalized <- NULL if ("covr" %in% loadedNamespaces()) { assertFinalization <- function(name) TRUE } else { assertFinalization <- function(name) { cat(sprintf("Is '%s' in '%s'?\n", name, paste(finalized, collapse=", "))) stopifnot(is.element(name, finalized)) } } name <- NULL nextName <- function() { if (is.null(name)) return(letters[1L]) letters[which(letters == name) + 1L] } setMethodS3("finalize", "Foo", function(this, ...) { cat(sprintf("Finalizing %s()...\n", class(this)[1L])) name <- unclass(this) cat(sprintf(" Value: %s\n", name)) finalized <<- c(finalized, name) cat(sprintf("Finalizing %s()...done\n", class(this)[1L])) }) setConstructorS3("Foo", function(..., ...finalize=NA) { extend(Object(...), "Foo", ...finalize=...finalize) }) # Default x <- Foo(name <- nextName()) rm(list="x"); gc() assertFinalization(name) # Default (explicit) x <- Foo(name <- nextName(), finalize=TRUE, ...finalize=NA) rm(list="x"); gc() str(finalized) assertFinalization(name) # Disable x <- Foo(name <- nextName(), finalize=FALSE, ...finalize=FALSE) rm(list="x"); gc() str(finalized) # Disable (forced) x <- Foo(name <- nextName(), finalize=TRUE, ...finalize=FALSE) rm(list="x"); gc() str(finalized) # Enable (forced) x <- Foo(name <- nextName(), finalize=FALSE, ...finalize=TRUE) rm(list="x"); gc() str(finalized) assertFinalization(name) print(finalized) # Finalize upon exit options("R.oo::Object/finalizeOnExit"=TRUE) y <- Foo(name <- "OnExit") message("TESTING: finalize() on Object on and off ... DONE") options(oopts) R.oo/tests/isBeingCreated.Class.R0000644000176200001440000000130214554071366016277 0ustar liggesusersmessage("TESTING: isBeingCreated()...") library("R.oo") setConstructorS3("Car", function(brand=NULL, nbrOfWheels=0) { if(!isBeingCreated(Car)) { if (is.null(brand)) throw("A car must have a brand") if (nbrOfWheels <= 0) throw("A car must have one or more wheels: ", nbrOfWheels) } extend(Object(), "Car", .brand = brand, .nbrOfWheels = nbrOfWheels ) }) setMethodS3("as.character", "Car", function(this, ...) { cat(class(this)[1], ":", this$.brand, " with ", this$.nbrOfWheels, " wheels.", sep="") }) print(Car("Volvo", 4)) print(Car("BMW", 4)) print(Car("Tyrrell P34", 6)) print(Car("T-Rex", 3)) message("TESTING: isBeingCreated()...DONE") R.oo/tests/Package.R0000644000176200001440000000511114554071366013720 0ustar liggesusersmessage("TESTING: Package...") library("R.oo") # By defining .onAttach() as follows in zzz.R for a package, an # instance of class Package with the same name as the package will # be made available on the search path. More over, the code below # will also inform the user that the package has been loaded: # # > library(R.oo) # R.oo v0.52 (2003/04/13) was successfully loaded. # .onAttach <- function(libname, pkgname) { pkg <- Package(pkgname) assign(pkgname, pkg, pos=getPosition(pkg)) cat(getName(pkg), " v", getVersion(pkg), " (", getDate(pkg), ")", " was successfully loaded.\n", sep="") } # The Package class works for any packages, loaded or not. # Some information about the base package pkg <- Package("base") print(pkg) # [1] "Package: base v3.6.2 is loaded (pos=14). Title: The R Base Package. # The official webpage is NA and the maintainer is R Core Team . The package is installed in /usr/lib/R/library/base/. # License: Part of R 3.6.2. Description: Base R functions. Type # showNews(base) for package history, and ?base for help." print(list.files(Package("base")$dataPath)) # Some information about the R.oo package print(R.oo::R.oo) # [1] "Package: R.oo v1.23.0-9000 . Title: R Object-Oriented Programming # with or without References. The official webpage is https://github.com/ # HenrikBengtsson/R.oo and the maintainer is Henrik Bengtsson. The package # is installed in /home/alice/R/x86_64-pc-linux-gnu-library/3.6/R.oo/. # License: LGPL (>= 2.1). Description: Methods and classes for object- # oriented programming in R with or without references. Large effort has # been made on making definition of methods as simple as possible with a # minimum of maintenance for package developers. The package has been # developed since 2001 and is now considered very stable. This is a # cross-platform package implemented in pure R that defines standard S3 # classes without any tricks. Type showNews(R.oo) for package history, # and ?R.oo for help." pkg <- Package("R.oo") classes <- getClasses(pkg) print(classes) stopifnot(all(c("Object", "Class", "Interface", "Exception", "Package") %in% classes)) pkg <- Package("R.oo") res <- showDescriptionFile(pkg, pager=function(...) TRUE) stopifnot(isTRUE(res)) res <- showNews(pkg, pager=function(...) TRUE) stopifnot(isTRUE(res)) res <- showChangeLog(pkg, pager=function(...) TRUE) stopifnot(isTRUE(res)) res <- showHistory(pkg, pager=function(...) TRUE) stopifnot(isTRUE(res)) res <- try(Package("Non-Existing-Package"), silent=TRUE) stopifnot(inherits(res, "try-error")) message("TESTING: Package...DONE") R.oo/tests/objectSize.R0000644000176200001440000000113314554071366014466 0ustar liggesusersmessage("TESTING: objectSize()...") library("R.oo") ## Simple object x <- 1:100 y0 <- object.size(x) y <- objectSize(x) print(y) stopifnot(y == y0) ## A list x <- as.list(1:100) y0 <- object.size(x) y <- objectSize(x) print(y) stopifnot(y == y0) ## An environment env <- new.env() env$a <- 1:100 env$b <- as.list(1:100) env$c <- new.env() y0 <- object.size(env) print(y0) y <- objectSize(env) print(y) ## An environment with circular dependencies env <- new.env() env$a <- 1:100 env$env <- env y0 <- object.size(env) print(y0) y <- objectSize(env) print(y) message("TESTING: objectSize()...DONE") R.oo/tests/Exception.R0000644000176200001440000000421214554071366014324 0ustar liggesusersmessage("TESTING: Exception...") library("R.oo") oopts <- options(warn=1) ###################################################################### # 1. To catch a regular "error" exception thrown by e.g. stop(). ###################################################################### x <- NA y <- NA tryCatch({ x <- log(123) y <- log("a") }, error = function(ex) { print(ex) }) print(x) print(y) ###################################################################### # 2. Always run a "final" expression regardless or error or not. ###################################################################### filename <- tempfile("R.methodsS3.example") con <- file(filename) tryCatch({ open(con, "r") }, error = function(ex) { cat("Could not open ", filename, " for reading.\n", sep="") }, finally = { close(con) cat("The id of the connection is ", ifelse(is.null(con), "NULL", con), ".\n", sep="") }) ###################################################################### # 3. Creating your own Exception class ###################################################################### setConstructorS3("NegativeLogValueException", function( msg="Trying to calculate the logarithm of a negative value", value=NULL) { extend(Exception(msg=msg), "NegativeLogValueException", .value = value ) }) setMethodS3("as.character", "NegativeLogValueException", function(this, ...) { paste(as.character.Exception(this), ": ", getValue(this), sep="") }) setMethodS3("getValue", "NegativeLogValueException", function(this, ...) { this$.value }) mylog <- function(x, base=exp(1)) { if (x < 0) throw(NegativeLogValueException(value=x)) else log(x, base=base) } # Note that the order of the catch list is important: l <- NA x <- 123 tryCatch({ l <- mylog(x) }, NegativeLogValueException = function(ex) { cat(as.character(ex), "\n") }, "try-error" = function(ex) { cat("try-error: Could not calculate the logarithm of ", x, ".\n", sep="") }, error = function(ex) { cat("error: Could not calculate the logarithm of ", x, ".\n", sep="") }) cat("The logarithm of ", x, " is ", l, ".\n\n", sep="") options(oopts) message("TESTING: Exception...DONE") R.oo/tests/trim.R0000644000176200001440000000063214554071366013343 0ustar liggesusersmessage("TESTING: trim()...") library("R.oo") x <- character(0L) y <- trim(x) print(y) stopifnot(identical(y, x)) x <- "Hello world!" y <- trim(x) print(y) stopifnot(identical(y, x)) x <- " \tHello world!\n " y <- trim(x) print(y) stopifnot(identical(y, "Hello world!")) x <- c(" \tHello", "world!") y <- trim(x) print(y) stopifnot(identical(y, c("Hello", "world!"))) message("TESTING: trim()...DONE") R.oo/tests/ll.R0000644000176200001440000000157214554071366013003 0ustar liggesusersmessage("TESTING: ll()...") library("R.oo") ## Create some objects in the current environment a <- 1:100 env <- new.env() env$b <- letters[1:10] ## List the content of evironments x <- ll(envir=env) print(x) ## Empty environment x <- ll(envir=new.env()) print(x) ## search() path environment x <- ll(envir=1L) str(x) ## search() path environment x <- ll(envir="R.oo") str(x) ## Filter by name pattern x <- ll(envir="R.oo", pattern="^throw.*") print(x) x <- ll(envir="R.oo", pattern="^NonExistingName$") print(x) ## List all functions and sort them by size x <- ll(envir="R.oo", mode="function", sortBy="objectSize") str(x) ## List all functions of a package and sort them by size x <- ll(R.oo, mode="function", sortBy="objectSize") str(x) ## List all functions of an Object obj <- Object() obj$a <- 1:100 obj$b <- new.env() x <- ll(obj) print(x) message("TESTING: ll()...DONE") R.oo/MD50000644000176200001440000003462114711213442011404 0ustar liggesusers1d7bf4f727e5b6f85dcd6f3845c1ddae *DESCRIPTION eacfc984aed10edeaf9145aaf9a1d7da *NAMESPACE 1560e562b32cb31a076c05e1daef3144 *NEWS.md 5b3e0291bcc049d9ada9005162c5259a *R/000.R ba90a83a672c8430fa7ebd1e35a5a7fa *R/006.fixVarArgs.R 17449bea012e661714466e173d404d9b *R/020.makeObjectFinalizer,private.R f67e4ccc5624a99c29243e395b978b71 *R/030.ObjectClassFunctions.R d31786df8ab1796ca0d4fdc8c0af8ca0 *R/040.setConstructorS3.R 076d6871e2820ad1a8f3493f17c4ce21 *R/050.Object.R 2093d041e210a1d8a41e0992c3c69644 *R/060.Class.R 5dc92b7fe9cdc5c9e04e6626609fc6bc *R/999.NonDocumentedObjects.R 83b0ae93bbd2e0b6e1c015d810ccb612 *R/999.package.R 758e4ee2f2e836f293c75ad8be85ccae *R/ASCII.R eca699b6bdf0873c3f49069e5ce852c1 *R/BasicObject.R edefe2421629cb833bbf9f260886a094 *R/Class.misc.R bf973c6be3fe30b28e195b3b141323f3 *R/Exception.R 2007e8e74516d315b2f790873094a9bc *R/Interface.R e1215b5a3ae63046d6d169d6efadb70e *R/InternalErrorException.R c350a0ae6615456d6001f13a254da3a0 *R/Package.R 6898dcf52f05bb5aca3ad7fe23e6d2a3 *R/RccViolationException.R 40eaad1a1234845ecc598e18d7f2522e *R/Rdoc.R e007f1047cd6d22af1682b696d8111ff *R/RdocException.R e8e3b204efce65c05aa50dca1f59b970 *R/abort.R ac3a33cf1dd34179325151dd009ff6da *R/classRepresentation.misc.R 20cf67355f94923536530c23573cc6fd *R/compileRdoc.R 4a6695254272930273a3ca8a54129ab0 *R/dimension.default.R f3e2c2120d6e90a1187188ba8a355631 *R/equals.default.R 9187f4a7cc8dccaa7393da0766ea00e3 *R/error.throw.R d8c14096ad4f0cec2b18b743bde4abf3 *R/extend.default.R 2bdd10dbd7a659969077218b05d633a6 *R/getConstructorS3.R c2044ea5396bdffb7edc01380cf29658 *R/getName.environment.R bb16183f42121aacd8e94c12c44c80af *R/getNnnByName.R b53a3edefd5d1de3486cbcfa4aefb28b *R/hashCode.R 4a9aae846687a89e6e8b9d81ace66a9b *R/ll.default.R b8b6c695cee9eb18304ec6f0daa3dd04 *R/objectSize.default.R 1dc11d8f4746dd0832eca76a1182f4a0 *R/objectSize.environment.R 1c7049ad9a94e1f059ffc22adf66556f *R/throw.default.R d573ca299c7e656d9325f3fa35415ab5 *R/trim.R f81d192b9e80bb5e2485eadc164fb41c *R/typeOfClass.R 180c9367491b40998fd02ab386c8b440 *R/zzz.R 2ef0403219f4bb9ffa1c744bdc787c86 *R/zzz.avoid_Object_clashes.R 8fb6b9dcccb2ca42072cde9d53d9fa3c *inst/CITATION 7e7e13402a3c82cd31ff3b2c85341590 *inst/WORDLIST 6958ed0722d07b6ca46fafca8aabd608 *inst/doc/Bengtsson.pdf 0f69446bf87d203d9aa7ae96b6711b97 *inst/misc/ASCII.R be5e10acdaefd2ff6cc016f2a0ffb689 *inst/misc/Exception.R 785a50da848bbd6ad592edffcc3c6774 *man/000.makeObjectFinalizer.Rd 25181dbf69eb710562992cd31acea011 *man/ASCII.Rd 3eb8f563416c7e36821ac2147eedaae6 *man/BasicObject.Rd 65b287cd0ee6f3a2c20a39e8e474c055 *man/Class.Rd 8ea0ab6e53cae4e8d1531dae05847d8f *man/DOLLAR.BasicObject.Rd dbd357f98dc7350abd13794694312007 *man/DOLLAR.Class.Rd 407c5e01931e259411212c477a3bd724 *man/DOLLAR.Object.Rd db21e59e2d09a497d94b180632798638 *man/DOLLARLT_-.BasicObject.Rd 5c2d96f9e34504284bf1f548b1e1c26e *man/DOLLARLT_-.Class.Rd 382a22cfa217fb97d7d15e39a6ffd422 *man/DOLLARLT_-.Object.Rd 9255607a267448ff9e665ef01fef9300 *man/Exception.Rd b1a24e7675a94714a08c22590cd010c4 *man/Interface.Rd ce077dc2a937b8ad29504501084e3d2a *man/InternalErrorException.Rd 16cdcb7c6c60f84829d097362b8b22bc *man/Non-documented_objects.Rd 9402d21c663fd36e71c99ae23c5a674c *man/Object.Rd f2345a3c94453786c8795ddb27929ba8 *man/Package.Rd e5617d6d8d15c42a8307abe737d15543 *man/R.oo-package.Rd 96b8ebaca18f24fa8909a41fc24a46a6 *man/RccViolationException.Rd 2870d6bf83a0fc1e62838cc078f07c0e *man/Rdoc.Rd dac8e8181cc28d73f816b9a77894ba1e *man/RdocException.Rd f2decc7171f4f3f3235896658981729d *man/abort.Rd 0e332f1997b5165c17da8aaa043f55e5 *man/argsToString.Class.Rd 9e7b5e9469b332af8da82d633dc22b68 *man/argsToString.Rdoc.Rd 2081d6fe742815ce312ba99135dfcd44 *man/as.character.BasicObject.Rd 7a872a1ce978fd53dd39dae97ce6f04b *man/as.character.Class.Rd 9c5b7596466964b241d878a4a492c3f1 *man/as.character.Exception.Rd 5a9ea3b1e21e7ba99b5a520be238c1dd *man/as.character.Interface.Rd b7bcf3ceb4419d6058e08f37899242f3 *man/as.character.Object.Rd 2e907a5d0ba7c0fe22717158c892f355 *man/as.character.Package.Rd fce03677219580b92f0f026c5d8dac08 *man/as.character.RccViolationException.Rd 3541b5a81b14fd75ef7a7b40f7286c93 *man/as.character.RdocException.Rd 827e0e2e64a89e3359e1b48755cbd556 *man/attach.BasicObject.Rd 0efcacaf2f405347ea3ebbc370bfa238 *man/attach.Object.Rd 75e3f59ac1c86203031a83eea741471b *man/attachLocally.Object.Rd 14d3e71b6831f7403b79c6fe9acb05ef *man/charToInt.Rd 300a03b7658fc53ba0b623cc891b9be9 *man/check.Rdoc.Rd 9602e572090304e1c792a650fbbc403a *man/clearCache.Object.Rd dd0ac1bafc2814963d2c8db46933bac9 *man/clearLookupCache.Object.Rd b247a45c7705380a39c61cb42cb56dae *man/clone.Object.Rd 7eb599b4baeabaab3a4a3573a577044d *man/compile.Rdoc.Rd 4cd903de2e389537348ccb00e24b98b6 *man/compileRdoc.Rd c2b14a5e74b1b68816e41bb7a89bd773 *man/createManPath.Rdoc.Rd c3709819b08e47c26f7c0d3093582412 *man/createName.Rdoc.Rd 66bcb297a123729a188a244467e7a492 *man/declaration.Rdoc.Rd 5a19600a3dc2b82a9a87ca6b148b6410 *man/detach.BasicObject.Rd 1d877d92837f384d97195a23c1777b0c *man/detach.Object.Rd 6faaf3774a757e73b37768a2c07379ef *man/dimension.Rd 43aec1048190143e37aaf9b0b82be424 *man/equals.BasicObject.Rd d3bf66a71639218e4253ac2a10c01588 *man/equals.Object.Rd 483e45de46dd0d315e45385894dc818e *man/equals.Rd e75f20556be6d55adc1d9ff87aa6bdd8 *man/escapeRdFilename.Rdoc.Rd b7710f264c50fb98e2ba1ec5f31bca46 *man/extend.BasicObject.Rd 14ce09fe538ab686e42e1713c6c07326 *man/extend.Interface.Rd 57fef8e17eaa13b5117be9a9ac37c1e8 *man/extend.Object.Rd 8f185cd3e8e39ace3c26ea2ed43247b1 *man/extend.Rd 290c15c4a61a1047a80b15fca0b88c5f *man/finalize.Object.Rd 889ae86e79300ef0fcb6c63394371380 *man/forName.Class.Rd 1749c45a51469ea05edad884e591dfcd *man/getAuthor.Package.Rd 16d9d447902f118f03921a6fcb49848c *man/getBundle.Package.Rd 66c8f9aebd9f21d92c7309dcbb624c2b *man/getBundlePackages.Package.Rd 7810a61a4a2ed382b157705b2bdd259c *man/getCalls.Exception.Rd 390896c0e3ff341e0c0f6f6c6507d9c0 *man/getChangeLog.Package.Rd 708e6815a2d1840edea4a584093bfe18 *man/getClassS4Usage.Rdoc.Rd 367974a09a07b8e96d19c4a9b2ec32b4 *man/getClasses.Package.Rd 09d653e5fb13cd25af5933ccad5b9f76 *man/getConstructorS3.Rd 5233b79fe290a3e52c93dfc69b25a4bd *man/getContents.Package.Rd 3c6a9636df6727c1a9bb431c8ebe99df *man/getContribUrl.Package.Rd d78f6cbdeacca57093d257901a136a25 *man/getDataPath.Package.Rd 1165407e4d6e8d565f71b08b3fd687bb *man/getDate.Package.Rd 8cf0231b753a46d021f1494ded95b004 *man/getDescription.Package.Rd 276e36dcb27f1a2f310b3e945805e77e *man/getDescriptionFile.Package.Rd d3f7d390d942ec20fe90688bc9a7d503 *man/getDetails.Class.Rd aec5edbb1a03b1bd80e5edc91bd1d858 *man/getDevelUrl.Package.Rd 0a05580a58ddd84e09e4a841ff236199 *man/getDocPath.Package.Rd 4980a8c1e9c81a6a0662ae7c1cfb04df *man/getEnvironment.Object.Rd 0c6085ef5a8f862e2db608780f3d027a *man/getEnvironment.Package.Rd 1158aeeb43ab187e02a4781bb0fb54df *man/getExamplePath.Package.Rd fa5f3aae43b975a90ea82a19f42d56ed *man/getFieldModifiers.Object.Rd 4447a1b9e70c06c3854c32fc732d2e9b *man/getFields.BasicObject.Rd e897f187d08fbb893af0b04dcd7b26f4 *man/getFields.Class.Rd b5c4f9a3f0795395264591b1e8df7dd5 *man/getFields.Interface.Rd 67c0509bc67062c08bf01c9a1733b8ca *man/getFields.Object.Rd 0c554581de0046b1e6abeacb025e0694 *man/getHowToCite.Package.Rd a3d3a839ddc51d92dc910c002bf15d43 *man/getInstantiationTime.BasicObject.Rd 30acd8bcf106136d04297f41de02ec08 *man/getInstantiationTime.Object.Rd a3cd00d41122ec37d9b1350adc723b01 *man/getInternalAddress.Object.Rd d7b56ccd4010eafa54154827b6a8bd5e *man/getKeywords.Rdoc.Rd 6b84a7ae5135711ad22c403ac2b5eff3 *man/getKnownSubclasses.Class.Rd e40816a4793ac2e46674882437227159 *man/getKnownSubclasses.classRepresentation.Rd c976acc73c1a4ed32e366b36af4b50d3 *man/getLastException.Exception.Rd 35879aa6c09ec008c26536331096b4a4 *man/getLicense.Package.Rd 1142ad65dd9e0cd674501faee4e76b67 *man/getMaintainer.Package.Rd 7fc05ad512ac8efebe03df33209864e2 *man/getManPath.Rdoc.Rd df2eb30241aea986e2e890919888b781 *man/getMessage.Exception.Rd b1d13c7b06c5c56ef6c36128c23709da *man/getMessage.InternalErrorException.Rd 6e3291be41e014514f06b4f2ad01f7fe *man/getMethods.Class.Rd feaa11e74ea1fe59c6c7570db47b52e8 *man/getName.Class.Rd 57b03bab837e08aa59ddbb4147fb1d72 *man/getName.Package.Rd c4150476fb649019a5bc485bbb5be059 *man/getName.environment.Rd 2286c4b9ae5f8a75c3bf897e94aedbaf *man/getNameFormat.Rdoc.Rd b26db8431a42f48bb1c6650c8de8ed3f *man/getPackage.Class.Rd 259b162127cc67b8a396a9adef3813cc *man/getPackage.InternalErrorException.Rd 40e4c0bb372498dfddb8f9f93e722b98 *man/getPackageNameOf.Rdoc.Rd cc7fbf6d2f01271d3f28f67079c59145 *man/getPath.Package.Rd 3570722216042431936a0103eeac4bfd *man/getPosition.Package.Rd 6b886fe4aa46ae00498cbbe282ffea34 *man/getRccUrl.RccViolationException.Rd a492acc6766b63e4decdf860d534f621 *man/getRdDeclaration.Class.Rd 3e79fa4abebf702cba1402ee681601ee *man/getRdDeclaration.classRepresentation.Rd dca312a51b46e57312c6ee66d4963f17 *man/getRdHierarchy.Class.Rd 4a8221276a3f8e34c0def7ae1d47c43f *man/getRdHierarchy.classRepresentation.Rd c49b100ae51c1bfd1e6058128ca71253 *man/getRdMethods.Class.Rd c895362780071f93961ffe17a66d777e *man/getRdMethods.classRepresentation.Rd ff9d8a2007a07fbb19d1b8cb3fa85e74 *man/getRdTitle.Rdoc.Rd c8083042384ebbd3b8c9a0f0a61da37a *man/getSource.RdocException.Rd f690e87faad36591bd1e18ef97d2d747 *man/getStackTrace.Exception.Rd 29f8a5ef04f38d61e09cfbdb096bc4e5 *man/getStackTraceString.Exception.Rd fc6ebe7910f61ab00261fe1610e7e204 *man/getStaticInstance.Class.Rd 15c76743165d81af9f3fd6bd88ad4410 *man/getStaticInstance.Object.Rd 20944717d9b2e5f7ebaad4ba70788f8a *man/getSuperclasses.Class.Rd cb604510292330dc2f269f235d35ddcb *man/getSuperclasses.classRepresentation.Rd 8179934a07e1cf2cd8427616a3bca4c9 *man/getTitle.Package.Rd a0818351a7a9c01a355d5f162ef0ac36 *man/getUrl.Package.Rd c31066275243a6a670448d885ca74e02 *man/getUsage.Rdoc.Rd 530be65fce5fb7d735afe9b285c0eff9 *man/getVersion.Package.Rd e6fa5c902f54603bce36f56571488179 *man/getWhen.Exception.Rd be9ff6d7bc02c93d8b01191406c24aa4 *man/hasField.BasicObject.Rd 01da01107c8b331cde76fdda9afa2b8d *man/hasField.Object.Rd fce21c7e3a0ffc4c2131f9baa2c328c7 *man/hashCode.BasicObject.Rd 91b51d77e4dc1292af617374187eca2b *man/hashCode.Object.Rd 7a43b6eec740945cf52e12061990eb9e *man/hashCode.Rd 77677cdee77b5f236042d8799d3f86ac *man/hierarchy.Rdoc.Rd 55099b79a40ba5f6a0cf1ad6fbdf1698 *man/intToChar.Rd f02ced2a5c71ffebebfdf69fa79b3d63 *man/isAbstract.Class.Rd 678d772de261b3f9c2c13e01fb11124e *man/isBeingCreated.Class.Rd a3c522084d8e5c8813b1762a74d2ee57 *man/isDeprecated.Class.Rd 06fe451b9c864d88361a56f871316795 *man/isKeyword.Rdoc.Rd feb192e19fb098fc35fc2870b1ff6e25 *man/isLoaded.Package.Rd ad3136d26208f867571cf49b529c42a3 *man/isOlderThan.Package.Rd eac324d09b15e47c75a8913f1f9c290d *man/isPrivate.Class.Rd 54fd4bc64092fdd525b4ec2e3006f559 *man/isProtected.Class.Rd 56b7f23a91292abe5deb489f92e01b25 *man/isPublic.Class.Rd 23816fe75c12a34339480ba7d2c35733 *man/isReferable.BasicObject.Rd 1a976205897dad0a1aeec0af1cd803b7 *man/isReferable.Object.Rd 1ca7ea2a162b650ea71aec1a0a371f54 *man/isStatic.Class.Rd 359f4c4f2623b5ed66b8854c361ac214 *man/isVisible.Rdoc.Rd 218e3fcfb2720eb4bd14cf1e59216d8c *man/ll.Object.Rd 8e973d973371138ced6f88e1ae5d6065 *man/ll.Package.Rd fffa65d12081d3e9018ace2d2541a556 *man/ll.Rd a4a7dffb88d8d2156ed94cdb7320ddca *man/load.Object.Rd e567d65f961b590bbbbcdbd9a64f3983 *man/load.Package.Rd 617f33a50d87fed3bb40b8a0d5f22ba1 *man/methodsInheritedFrom.Rdoc.Rd 41e25a27cf652e3e458ff96b7a75ee75 *man/newInstance.BasicObject.Rd b79f707fee846503fa18eaa1b27e498f *man/newInstance.Class.Rd 6efda2e014f303f0d01fc233287d5743 *man/newInstance.Object.Rd 38532629ff97e52b4c79dc779b565ff9 *man/novirtual.Object.Rd 149bd3fd88ad5c9d92f03a59aedc63e3 *man/objectSize.BasicObject.Rd 6b4039ee72992d32994f17eeb77702eb *man/objectSize.Object.Rd 9267cc66c0d8b4958231766da0682a17 *man/objectSize.Rd cf93f61f80fa5c3e9a861549f378b6bb *man/objectSize.environment.Rd 34099097c2f773cbb0a9bffd97f5cdf0 *man/print.BasicObject.Rd 09694ed3273406d399351e383760244b *man/print.Class.Rd 9e2a44a0f32747800d7db9fcf80c4f7c *man/print.Exception.Rd b54ea27602b0e6f077a8f6b28132d415 *man/print.Interface.Rd 26a32ca1a00af1412ce54686d78d056c *man/print.Object.Rd 36a7bdadf325e5674960f2aac5300531 *man/printStackTrace.Exception.Rd cee1fa2b48ea3f32132ba2245c6cb83c *man/save.Object.Rd 61bab55689f964e286d039225de4e174 *man/setConstructorS3.Rd fed641fb7d7e3502aee7e6828e294929 *man/setManPath.Rdoc.Rd d6050b2f3c1e7948c5eb84f5376d810e *man/setNameFormat.Rdoc.Rd e03ffc2ee8ea73bf254c2110ed9594e0 *man/showChangeLog.Package.Rd 3f7a21268d70a351943fce8ad01e8954 *man/showContents.Package.Rd 14c38f27651151e9dc36b0392a527304 *man/showDescriptionFile.Package.Rd 6e9b3b70f51896a148875bc525fb6eec *man/showHowToCite.Package.Rd 7c715a35da3815ffb921bf1ea1422d92 *man/startupMessage.Package.Rd 9c854e863e225e79413e332f501160d2 *man/staticCode.Object.Rd 55c32a75d7bef5d8ffe357a7f7bf0631 *man/throw.Exception.Rd af7fff78e313c2f34ef2ecca5adf6445 *man/throw.Rd b2069a677b1114406e7db4ea2e5dffc2 *man/throw.error.Rd a12028bb733485849439f3213fe8e52f *man/trim.Rd a9ecd083d17f289f95e3d1910b168df4 *man/typeOfClass.Rd a1f142be9c315739b230ec02c8e67706 *man/unload.Package.Rd a1d13ed5dd1fb6509995148daa54a192 *man/uses.Interface.Rd 7e20e770f311cd069c3c45e0dc40434b *tests/ASCII.R b18311f0f4c8fcf30747aa0105b39cda *tests/BasicObject.R 9e89dd7f03f7610820612b132711b5eb *tests/Class.R 6c95cfe7cc9617d5b99e1d6755f5a9a6 *tests/Exception.R 3c558a5db3f78af8caa30770f1db87bf *tests/Interface.R 0c9385711caf77f4681e6084c273638f *tests/InternalErrorException.reportBug.R 6b9295de71442e5a8d2e0c5907d0711a *tests/Object.R bb885403cb282ce2230ce2a51b59b241 *tests/Object.finalize,noattach.R 13e77cd617b44cf1e8af480c70001bc4 *tests/Object.finalize,onoff.R 66b5b1551498ad20595f3ad1a31fe371 *tests/Object.finalize.R 4d9b542eaa8e22dc13b8815c6ee364d3 *tests/Package.R 19a0210b7f75cc6addc00399431cca98 *tests/Package.unload.R 260cd18edfe192c9cc4e739eabf30985 *tests/StaticMethodsAndNamespaces.R d0bb42cb3b0727f37bc061c0e84720ec *tests/abort.R a6d6dafc1837ebf25a20d5da12a1fffe *tests/attachLocally.Object.R c14c98dd367a26bce140563350ff4a49 *tests/equals.R 2b5676d1b5a917158bfea6cca92da84a *tests/extend.default.R 3d331609f3d79fa4cf8840bcaf6655c8 *tests/getConstructorS3.R 3300674c6735c9f389e8b705e9b1ce20 *tests/hashCode.R 8d7daba42e53f552214734fad71f2df0 *tests/isBeingCreated.Class.R 6991fe671d618138be9d06745c866371 *tests/ll.R 2605f974d27c6b7b7cc16919cf4504b8 *tests/local.R 78f51ad0a149226925f8ed36bb1c6bbf *tests/objectSize.R ecc3a6634d974a69c2cc0ac52d25a180 *tests/throw.R 5e1580623cace2ce9f981b6aa2f32386 *tests/trim.R b62c10fecaa397495f9c15b7941cebea *tests/typeOfClass.R ad7cf11e55c47c52e1ae47c3ea552c9a *tests/zzz.Object.finalize,reentrant.R R.oo/R/0000755000176200001440000000000014711170612011270 5ustar liggesusersR.oo/R/getConstructorS3.R0000644000176200001440000000166114554071363014662 0ustar liggesusers###########################################################################/** # @RdocDefault getConstructorS3 # # @title "Get a constructor method" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{name}{The name of the constructor function.} # \item{...}{Not used.} # } # # \seealso{ # @see "setConstructorS3". # @see "R.methodsS3::getMethodS3". # @see "R.methodsS3::isGenericS3". # } # # @author # # @keyword "programming" # @keyword "methods" #*/########################################################################### setMethodS3("getConstructorS3", "default", function(name, ...) { # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (!exists(name, mode="function")) { throw("No such function found: ", name) } fcn <- get(name, mode="function") if (isGenericS3(fcn)) { throw("The function found is an S3 generic function: ", name) } fcn }) R.oo/R/error.throw.R0000644000176200001440000000140714554071363013720 0ustar liggesusers###########################################################################/** # @set "class=error" # @RdocMethod throw # # @title "Throws (rethrows) an object of class 'error'" # # \description{ # Rethrows an 'error' object. The 'error' class was introduced in R v1.8.1 # with the new error handling mechanisms. # } # # @synopsis # # \arguments{ # \item{error}{An object or class 'error'.} # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # See the \code{tryCatch()} method etc. # See the @see "Exception" class for more detailed information. # } # # \keyword{error} #*/########################################################################### setMethodS3("throw", "error", function(error, ...) { base::stop(error) }) R.oo/R/000.R0000644000176200001440000000031314554071363011717 0ustar liggesusers## Look for existing generic functions also in imported namespaces. ## This will affect whether setGenericS3() creates a generic function ## or not. options("R.methodsS3:checkImports:setGenericS3"=TRUE) R.oo/R/getNnnByName.R0000644000176200001440000000374114554071363013755 0ustar liggesusers.getFunctionByName <- function(name, where=c("ns", "search", "ns*"), envir=NULL, callEnvir=as.environment(-1L), class="function", mustExist=TRUE, ...) { # Backward compatibility (ignore where="ns*" if explicitly disabled) if (!getOption("R.oo::Class/searchNamespaces", TRUE)) { where <- setdiff(where, "ns*") } # Ignore where = "ns" if 'envir' was not specified if (is.null(envir)) { where <- setdiff(where, "ns") } # Search each 'where'... for (kk in seq_along(where)) { whereKK <- where[kk] # (a) Search a specific environment? # (which should be a namespace of package) if (whereKK == "ns") { if (exists(name, mode="function", envir=envir, inherits=TRUE)) { res <- get(name, mode="function", envir=envir, inherits=TRUE) if (inherits(res, class)) return(res) } } # (b) Search globally? if (whereKK == "search") { envirT <- callEnvir if (exists(name, mode="function", envir=envirT, inherits=TRUE)) { res <- get(name, mode="function", envir=envirT, inherits=TRUE) if (inherits(res, class)) return(res) } } # (c) Search all loaded namespaces? if (whereKK == "ns*") { for (pkg in loadedNamespaces()) { envirT <- getNamespace(pkg) if (exists(name, mode="function", envir=envirT, inherits=TRUE)) { res <- get(name, mode="function", envir=envirT, inherits=TRUE) if (inherits(res, class)) return(res) } } } } # for (kk in ...) if (mustExist) { # Don't use throw() here, because it may result in an endless loop # if Exception is not found. /HB 2012-11-23 stop(sprintf("INTERNAL ERROR: No such %s: %s", class, name)) } # Not found NULL } # .getFunctionByName() .getS3Method <- function(name, ...) { .getFunctionByName(name, class="function", ..., callEnvir=as.environment(-1L)) } .getClassByName <- function(name, ...) { .getFunctionByName(name, class="Class", ..., callEnvir=as.environment(-1L)) } R.oo/R/Class.misc.R0000644000176200001440000001250414554071363013424 0ustar liggesusers###########################################################################/** # @set "class=Class" # # @RdocMethod getRdDeclaration # # @title "Gets the class declaration in Rd format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getRdDeclaration", "Class", function(this, ...) { s <- "public"; # visibility(this) if (isAbstract(this)) s <- paste(s, "abstract") if (isStatic(this)) s <- paste(s, "static") if (inherits(this, "Class")) s <- paste(s, "class") else throw(getName(this), " is neither a class nor an interface.") s <- paste(s, " \\bold{", getName(this), "}\\cr\n", sep="") links <- getSuperclasses(this) if (length(links) > 0) { name <- links[1] link <- name cls <- .getClassByName(name, mustExist=FALSE) if (inherits(cls, "Class")) { pkg <- getPackage(cls) if (is.null(pkg)) link <- paste("\\link{", link ,"}", sep="") else link <- paste("\\link[", pkg, "]{", link ,"}", sep="") if (isAbstract(cls)) link <- paste("\\emph{", link, "}", sep="") } paste("\\code{", link ,"}", sep="") s <- paste(s, "extends ", link, "\\cr\n", sep="") } s }, private=TRUE) ###########################################################################/** # @RdocMethod getRdMethods # # @title "Gets the methods of a class in Rd format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{visibilities}{A @character string specifying what types of methods # to return.} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getRdMethods", "Class", function(class, visibilities=c("private", "protected", "public"), ...) { className <- getName(class) methods <- getMethods(class, private=TRUE); # Excludes empty classes! methods <- methods[[className]] methods <- names(methods) src <- "\\bold{Methods:}\\cr\n" tmpsrc <- "\\tabular{rll}{\n" count <- 0 for (method in methods) { fcnName <- paste(method, className, sep=".") fcn <- .getS3Method(fcnName) modifiers <- attr(fcn, "modifiers") if (Rdoc$isVisible(modifiers, visibilities)) { helpName <- Rdoc$createName(getName(class), method, escape=TRUE) label <- method title <- Rdoc$getRdTitle(class, method) package <- attr(title, "package") if (is.null(package)) package <- Rdoc$package # Is there a specific help document for this method or not? if (!is.null(title)) { link <- paste("\\link[", package, ":", helpName, "]{", label, "}", sep="") } else { link <- label } item <- paste(" \\tab \\code{", link, "} \\tab ", sep="") # Create the title if (!is.null(title)) { if (title != "") item <- paste(item, title, ".\\cr", sep="") } else { item <- paste(item, " -\\cr", sep="") } tmpsrc <- paste(tmpsrc, item, "\n", sep="") count <- count + 1 } # if(isVisible(...)) } tmpsrc <- paste(tmpsrc, "}\n", sep=""); # end of \tabular{rll} if (count == 0) src <- paste(src, "\\emph{No methods defined}.\n", sep="") else src <- paste(src, tmpsrc, sep="") src }, private=TRUE) ###########################################################################/** # @RdocMethod getRdHierarchy # # @title "Gets the class hierarchy in Rd format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getRdHierarchy", "Class", function(this, ...) { package <- getPackage(this) s <- paste("Package: ", package, "\\cr\n") what <- if (inherits(this, "Class")) "Class" else "Interface" s <- paste(s, "\\bold{", what, " ", getName(this), "}\\cr\n\n", sep="") indent <- "" for (extend in rev(getSuperclasses(this))) { link <- sapply(extend, FUN=function(name) { # isAbstract <- FALSE link <- name cls <- .getClassByName(name, mustExist=FALSE) if (inherits(cls, "Class")) { pkg <- getPackage(cls) if (is.null(pkg)) { link <- paste("\\link{", link ,"}", sep="") } else { link <- paste("\\link[", pkg, "]{", link ,"}", sep="") } # if (isAbstract(cls)) { # link <- paste("\\emph{", link, "}", sep="") # isAbstract <- TRUE } paste("\\code{", link ,"}", sep="") }) if (indent == "") { s <- paste(s, link, "\\cr\n", sep="") indent <- "~~" } else { s <- paste(s, "\\code{", indent, "+--}", link, "\\cr\n", sep="") indent <- paste(indent, "~~~~~", sep="") } s <- paste(s, "\\code{", indent, "|}\\cr\n", sep="") } link <- paste("\\code{", getName(this), "}", sep="") if (isAbstract(this)) link <- paste("\\emph{", link, "}", sep="") s <- paste(s, "\\code{", indent, "+--}", link, "\\cr\n\n", sep="") s }, private=TRUE) R.oo/R/hashCode.R0000644000176200001440000000412114554121067013134 0ustar liggesusers###########################################################################/** # @RdocDefault hashCode # # @title "Gets an integer hashcoded for R objects" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{object}{A @vector or @list of \R objects.} # \item{...}{Not used.} # } # # \value{ # Returns a @vector of @integer's. # } # # \details{ # A @character string is converted into a hashcode following Java # conventions by # \code{s[1]*31^(n-1) + s[2]*31^(n-2) + ... + s[n]} # using integer arithmetic, where \code{s[i]} is the \code{i}:th character # of the string, \code{n} is the length of the string. The hash value of # the empty string is zero. # # For all other types, \code{as.integer()} is called by default. # } # # @author # # @keyword programming # @keyword methods # @keyword internal #*/########################################################################### setMethodS3("hashCode", "default", function(object, ...) { asInt.Java <- function(x) { Integer.MIN.VALUE <- -2147483648 Integer.MAX.VALUE <- 2147483647 Integer.RANGE <- Integer.MAX.VALUE-Integer.MIN.VALUE + 1 x <- (x-Integer.MIN.VALUE) %% Integer.RANGE + Integer.MIN.VALUE as.integer(x) } hashCode <- c() for (obj in object) { if (is.character(obj)) { # The hashcode for a character string is computed as # # s[1]*31^(n-1) + s[2]*31^(n-2) + ... + s[n] # # using int arithmetic, where s[i] is the i:th character of the # string, n is the length of the string. The hash value of the # empty string is zero. s <- obj n <- nchar(s) if (n == 0) { hashCode <- c(hashCode, as.integer(0)) } else { s <- unlist(strsplit(as.character(s), NULL)) s <- charToInt(s) hashC <- 0 for (k in 1:n) { hashC <- 31 * hashC + s[k] hashC <- asInt.Java(hashC) } # Convert into range of Java int. hashCode <- c(hashCode, hashC) } } else { hashCode <- c(hashCode, as.integer(obj)) } } hashCode }) # hashCode.default() R.oo/R/typeOfClass.R0000644000176200001440000000266414554071363013667 0ustar liggesusers###########################################################################/** # @RdocDefault typeOfClass # # @title "Gets the type of a class (S3 or S4)" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{object}{The object to be checks.} # \item{...}{Not used.} # } # # \value{ # Returns a @character string \code{"S3"}, \code{"S3-Object"} or \code{"S4"}, # or @NA if neither. # } # # @author # # \keyword{character} #*/########################################################################### setMethodS3("typeOfClass", "default", function(object, ...) { if (is.null(object)) return(NA_character_) if (inherits(object, "classRepresentation")) return("S4") if (is.character(object)) { if (isClass(object)) { if (inherits(object, "oldClass")) return("S3") return("S4") } # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (!exists(object, mode="function")) return(NA_character_) object <- get(object, mode="function") } if (is.function(object) && inherits(object, "Class")) return("S3-Object") return(NA_character_) }) ############################################################################ # 2013-10-08 # o Now returning NA_character_ instead of NA. # 2005-02-15 # o Added arguments '...' in order to match any generic functions. ############################################################################ R.oo/R/dimension.default.R0000644000176200001440000000226014554071363015033 0ustar liggesusers###########################################################################/** # @RdocDefault dimension # # @title "Gets the dimension of the object" # # \description{ # Gets the dimension of the object similar to what \code{dim()} does, # but instead of @NULL it will return the length of a vector. # If a function is passed, @NULL is returned. # } # # @synopsis # # \arguments{ # \item{object}{The object for which the dimension should be obtained.} # \item{...}{Not used.} # } # # \value{ # Returns an @integer @vector or @NULL. # } # # \examples{ # dimension(matrix(1:100, ncol=10)) # 10 10 # dimension(1:14) # 14 # dimension(data.frame(a=1:10, b=10:1)) # 10 2 # dimension(print) # NULL # } # # @author # # \seealso{ # @see "ll.default". # @see "base::dim" and @see "base::length". # } # # @keyword attribute # @keyword utilities # @keyword internal #*/########################################################################### setMethodS3("dimension", "default", function(object, ...) { if (is.function(object)) return(NULL) size <- dim(object) if (is.null(size)) size <- length(object) as.integer(size) }) R.oo/R/BasicObject.R0000644000176200001440000005315614711170612013575 0ustar liggesusers###########################################################################/** # @RdocClass BasicObject # # @title "A root class like Object but without references" # # \description{ # R.oo\cr # \bold{Class BasicObject}\cr # # public class \bold{BasicObject}\cr # } # # @synopsis # # \arguments{ # \item{core}{The core value of the object.} # } # # \section{Fields and Methods}{ # @allmethods # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{internal} #*/########################################################################### setConstructorS3("BasicObject", function(core=NULL) { # Create a new environment and wrap it up as a private field of a list. if (is.null(core)) core <- NA this <- core class(this) <- unique(c("BasicObject", class(this))) if (getOption("R.oo::BasicObject/instantiationTime", FALSE)) { attr(this, "...instantiationTime") <- Sys.time() } this }) ###########################################################################/** # @RdocMethod isReferable # # @title "Checks if the object is referable or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @logical value, which by default is @TRUE for all # @see "BasicObject"'s. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("isReferable", "BasicObject", function(this, ...) { TRUE }) # isReferable() ###########################################################################/** # @RdocMethod as.character # # @title "Gets a character string representing the object" # # \description{ # @get "title". # } # # @synopsis # # \value{ # Returns a @character string representation of the object. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("as.character", "BasicObject", function(x, ...) { # To please R CMD check this <- x paste(class(this)[1L], ": ", getInstantiationTime(this), sep="") }) # as.character() ###########################################################################/** # @RdocMethod getInstantiationTime # # @title "Gets the time when the object was instantiated" # # \description{ # @get "title" (created) as a POSIXt object. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a POSIXt object, which extends class POSIXct. # } # # \details{ # The instantiation timestamp is set when the object is created, and # only of option \code{"R.oo::BasicObject/instantiationTime"} is @TRUE. # } # # \seealso{ # For more about time formats and POSIX see @see "base::DateTimeClasses". # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("getInstantiationTime", "BasicObject", function(this, ...) { time <- attr(this, "...instantiationTime") if (!is.null(time)) return(time) # Backward compatibility (due to a SPELLING ERROR in an earlier version) time <- attr(this, "...instanciationTime") NULL }) ###########################################################################/** # @RdocMethod hashCode # # @title "Gets a hash code for the object" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an @integer. # } # # @author # # \seealso{ # @seemethod "equals" # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("hashCode", "BasicObject", function(this, ...) { as.integer(getInstantiationTime(this)) }) ###########################################################################/** # @RdocMethod equals # # @title "Compares an object with another" # # \description{ # @get "title" and returns @TRUE if they are equal. # The equal property must be # # 1) \emph{reflexive}, i.e. \code{equals(o1,o1)} should be @TRUE. # # 2) \emph{symmetric}, i.e. \code{equals(o1,o2)} is @TRUE if and only # if \code{equals(o2,o1)} is @TRUE. # # 3) \emph{transitive}, i.e. \code{equals(o1,o2)} is @TRUE and # \code{equals(o2,o3)} is @TRUE, then \code{equals(o1,o3)} should # be @TRUE. # # 5) \emph{consistent}, i.e. \code{equals(o1,o2)} should return the same # result on multiple invocations as long as noting has changed. # # 6) \code{equals(o1,NULL)} should return @FALSE. # # By default, the method returns @TRUE if and only if the two # references compared refer to the same @see "BasicObject", i.e. # \code{( !is.null(obj) && (hashCode(this) == hashCode(obj)) )}. # } # # @synopsis # # \arguments{ # \item{other}{The other object this object should be compared to.} # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the objects are equal, otherwise @FALSE. # } # # \seealso{ # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("equals", "BasicObject", function(this, other, ...) { ( !is.null(other) && (hashCode(this) == hashCode(other)) ) }) ###########################################################################/** # @RdocMethod print # # @title "Prints a BasicObject" # # \description{ # For all objects of class @see "BasicObject", this method will print the # value of \code{as.character()} of the object. Note that this function is # not called if the argument is not an object of class @see "BasicObject". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # @author # # \seealso{ # @see "base::print.default" # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("print", "BasicObject", function(x, ...) { print(as.character(x)) }) # print() ###########################################################################/** # @RdocMethod objectSize # # @title "Gets the size of the BasicObject in bytes" # # \description{ # @get "title" by summing the sizes of all its members. For this reason, # the size of memory the BasicObject actually allocates might vary slightly. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an @integer specifying the size of the object in number of bytes. # } # # @author # # \seealso{ # @see "utils::object.size". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("objectSize", "BasicObject", function(this, ...) { object.size(this) }) # objectSize() ###########################################################################/** # @RdocMethod getFields # # @title "Returns the field names of a BasicObject" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{private}{If @TRUE, private fields will also be returned, # otherwise only public fields are returned.} # \item{...}{Not used.} # } # # \value{ # Returns a @character @vector of field names. # } # # @author # # \seealso{ # To check if a field exists or not, see @seemethod "hasField". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("getFields", "BasicObject", function(this, private=FALSE, ...) { members <- names(attributes(this)) if (!private) { isPrivate <- (regexpr("^[.].*", members) != -1) members <- members[!isPrivate] } members }) # getFields() ###########################################################################/** # @RdocMethod hasField # # @title "Checks if a field exists or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{field}{@vector of fields to be checked if they exists or not.} # \item{...}{Not used.} # } # # \value{ # Returns a @logical @vector indicating for each field if it exists or not. # } # # @author # # \seealso{ # To get the fields of an Object, see @seemethod "getFields". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("hasField", "BasicObject", function(this, field, ...) { !is.na(match(field, getFields(this, private=TRUE))) }) # hasFields() ###########################################################################/** # @RdocMethod attach # # @title "Attach a BasicObject to the R search path" # # \description{ # Attach the members of a BasicObject to the \R search path. # # If trying to attach the same BasicObject twice without detaching it # in between, a @warning will be generated and nothing will be done. # } # # @synopsis # # \arguments{ # \item{private}{If @TRUE, private fields will also be attached, # otherwise not.} # \item{pos}{The position at in search path where the BasicObject should be # inserted.} # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the @see "BasicObject" was attached, otherwise @FALSE. # } # # @author # # \seealso{ # @seemethod "detach" and @see "base::attach", @see "base::detach". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("attach", "BasicObject", function(this, private=FALSE, pos=2, ...) { # To please R CMD check attachX <- base::attach attachName <- as.character.BasicObject(this) if (is.element(attachName, search())) { warning(paste("Object is already attached:", attachName)) return(invisible(FALSE)) } if (is.list(this)) { attachX(unclass(this), name=attachName, pos=pos) } else { attachX(list(), name=attachName, pos=pos) } members <- names(attributes(this)) for (member in members) { assign(member, attr(this, member), pos=pos) } return(invisible(TRUE)) }) # attach() ###########################################################################/** # @RdocMethod detach # # @title "Detach a BasicObject from the R search path" # # \description{ # Detach, from the \R search path, a BasicObject that has previously been # attached. If the BasicObject was not attached, a @warning will be # generated and nothing will be done. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the BasicObject was detached, otherwise @FALSE. # } # # @author # # \seealso{ # @seemethod "attach" and @see "base::attach", @see "base::detach". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("detach", "BasicObject", function(this, ...) { attachName <- as.character.BasicObject(this) if (!is.element(attachName, search())) { warning(paste("Object is not attached:", attachName)) return(invisible(FALSE)) } pos <- which(search() == attachName) if (length(pos) == 1L) detach(pos=pos) return(invisible(TRUE)) }) # detach() ###########################################################################/** # @RdocMethod extend # # @title "Extends another class" # # \description{ # via a mechanism known as "parasitic inheritance". # Simply speaking this method "extends another class". What is actually # happening is that it creates an instance of class name \code{...className}, # by taking another BasicObject instance and add \code{...className} to # the class list and also add all the named values in @... as fields to the # new instance. # # The method should be used by the constructor of a class and nowhere else. # } # # @synopsis # # \arguments{ # \item{...className}{The name of new class.} # \item{...}{Named values representing the fields of the new instance.} # } # # \value{ # Returns a BasicObject of class \code{className}. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("extend", "BasicObject", function(this, ...className, ...) { fields <- list(...) names <- names(fields) for (ii in seq_along(fields)) { name <- names[ii] if (is.null(name) || nchar(name) == 0) { callNames <- names(sys.call()) callNames <- callNames[nchar(callNames) > 0] matchNames <- paste("^", callNames, sep="") for (jj in seq_along(matchNames)) { if (regexpr(matchNames[jj], "...className") != -1) { className <- sys.call()[[3]] throw("Could not set field of class (probably called ", className, ") because the field name is a prefix to the argument name ", "\"...className\": ", callNames[jj]) } } # for (jj ...) throw("Missing name of field #", ii, " in class definition: ", ...className) } attr(this, name) <- fields[[ii]] } # for (ii ...) class(this) <- c(...className, class(this)) this }) # extend() ###########################################################################/** # @RdocMethod newInstance # # @title "Creates a new instance of the same class as this object" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Arguments passed to the constructor of the corresponding # @see "BasicObject" class.} # } # # \value{ # Returns a reference to an instance of @see "BasicObject" or a subclass thereof. # } # # @author # # \seealso{ # @see "newInstance.Object". # @see "newInstance.Class". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("newInstance", "BasicObject", function(this, ...) { # Creates a new instance of the same class clazz <- Class$forName(class(this)[1]) newInstance(clazz, ...) }, private=TRUE) ###########################################################################/** # @RdocMethod $ # @aliasmethod [[ # # @title "Makes the fields and methods of a BasicObject accessible via the $ and the [[ operator" # # \description{ # @get "title". # } # # \usage{ # \method{$}{BasicObject}(this, name) # \method{[[}{BasicObject}(this, name, exact=TRUE) # } # # \arguments{ # \item{name}{The name of the field or method to be accessed.} # } # # \value{ # Returns the value of a field or a method (@function). # If no such field or method exists, @NULL is returned. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("$", "BasicObject", function(this, name) { memberAccessorOrder <- attr(this, ".memberAccessorOrder") if (is.null(memberAccessorOrder)) memberAccessorOrder <- c(1,2,3,4) for (memberAccessor in memberAccessorOrder) { if (memberAccessor == 1) { firstChar <- substr(name, 1,1) isPrivate <- identical(firstChar, ".") isField <- (regexpr(" ", name) != -1) # Do not try to access private fields using a get() method, # because such a functionality means that the user *expects* that # there actually is a field called '.', which he or she # should not do since it is a private field! if (!isField && !isPrivate && is.null(attr(this, "disableGetMethods"))) { # 1. Is it a get() method? getName <- paste(c("get", toupper(firstChar), substr(name,2,nchar(name))),collapse="") getMethodNames <- paste(getName, class(this), sep=".") for (getMethodName in getMethodNames) { # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (exists(getMethodName, mode="function")) { ref <- this attr(ref, "disableGetMethods") <- TRUE return( get(getMethodName, mode="function")(ref) ) } } } } else if (memberAccessor == 2) { # 2. Is it a field? value <- attr(this, name) if (!is.null(value)) return(value) } else if (memberAccessor == 3) { # 3. Is it a static S3 method? methodNames <- paste(name, class(this), sep=".") for (methodName in methodNames) { # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (exists(methodName, mode="function")) { # # Alt 1. Rather "obfuscated" code # method <- get(methodName, mode="function") # fcn <- function(...) method(this, ...) # Alt 3. Using explicit UseMethod() code code <- sprintf("function(...) \"%s\"(this, ...)", name) fcn <- eval(base::parse(text=code)) return(fcn) } } } } # for (memberAccessor in memberAccessorOrder) # 5. Otherwise, return NULL. NULL }) # $() setMethodS3("[[", "BasicObject", function(this, name, exact=TRUE) { .subset2Internal(this, name=name, exact=exact) }) setMethodS3(".subset2Internal", "BasicObject", function(this, name, exact=TRUE, ...) { memberAccessorOrder <- attr(this, ".memberAccessorOrder") if (is.null(memberAccessorOrder)) memberAccessorOrder <- c(1,2,3,4) for (memberAccessor in memberAccessorOrder) { if (memberAccessor == 1) { firstChar <- substr(name, 1,1) isPrivate <- identical(firstChar, ".") isField <- (regexpr(" ", name) != -1) # Do not try to access private fields using a get() method, # because such a functionality means that the user *expects* that # there actually is a field called '.', which he or she # should not do since it is a private field! if (!isField && !isPrivate && is.null(attr(this, "disableGetMethods"))) { # 1. Is it a get() method? getName <- paste(c("get", toupper(firstChar), substr(name,2,nchar(name))),collapse="") getMethodNames <- paste(getName, class(this), sep=".") for (getMethodName in getMethodNames) { # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (exists(getMethodName, mode="function")) { ref <- this attr(ref, "disableGetMethods") <- TRUE return( get(getMethodName, mode="function")(ref) ) } } } } else if (memberAccessor == 2) { # 2. Is it a field? value <- attr(this, name) if (!is.null(value)) return(value) } else if (memberAccessor == 3) { # 3. Is it a method? methodNames <- paste(name, class(this), sep=".") for (methodName in methodNames) { # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (exists(methodName, mode="function")) { method <- get(methodName, mode="function") return( function(...) method(this, ...) ) } } } } # for (memberAccessor in memberAccessorOrder) # 5. Otherwise, return NULL. NULL }, private=TRUE) # .subset2Internal() ###########################################################################/** # @RdocMethod $<- # @aliasmethod [[<- # # @title "Makes the fields and methods of a BasicObject assignable via the $<- and the [[<- operator" # # \description{ # @get "title". # } # # \usage{ # \method{$}{BasicObject}(this, name) <- value # \method{[[}{BasicObject}(this, name) <- value # } # # \arguments{ # \item{name}{The name of the \preformatted{set()} method or the # name of the field to be assigned the new value.} # \item{value}{The value to be assigned.} # } # # \value{ # Returns itself, i.e. \code{this}, as all \code{$<-} methods must do. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("$<-", "BasicObject", function(this, name, value) { memberAccessorOrder <- attr(this, ".memberAccessorOrder") if (is.null(memberAccessorOrder)) memberAccessorOrder <- c(1,2,3,4) for (memberAccessor in memberAccessorOrder) { if (memberAccessor == 1) { # Do not try to access private fields using a set() method, # because such a functionality means that the user *expects* that # there actually is a field called '.', which he or she # should not do since it is a private field! firstChar <- substr(name, 1,1) isPrivate <- identical(firstChar, ".") isField <- (regexpr(" ", name) != -1) if (!isField && !isPrivate && is.null(attr(this, "disableSetMethods"))) { # 1. Is it a set() method? setName <- paste(c("set", toupper(firstChar), substr(name,2,nchar(name))),collapse="") setMethodNames <- paste(setName, class(this), sep=".") for (setMethodName in setMethodNames) { # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (exists(setMethodName, mode="function")) { ref <- this attr(ref, "disableSetMethods") <- TRUE this <- get(setMethodName, mode="function")(ref, value) attr(this, "disableSetMethods") <- NULL return(this) } } } } else if (memberAccessor == 2) { # 2. If there exists a field, assign the value to that field. if (!is.null(attr(this, name))) { attr(this, name) <- value return(this) } } else if (memberAccessor == 4) { # 4. Otherwise, assign the value to a new field. attr(this, name) <- value return(this) } } # for (memberAccessor in memberAccessorOrder) this }) # $<-() setMethodS3("[[<-", "BasicObject", function(this, name, value) { ## Must use do.call() here; see detailed comment for `[[<-.Object`. do.call(`$<-`, args = list(this, name, value)) }) # "[[<-"() setMethodS3(".DollarNames", "BasicObject", .DollarNames.Object, appendVarArgs=FALSE, private=TRUE) R.oo/R/abort.R0000644000176200001440000000465514554071363012544 0ustar liggesusers## covr: skip=all ###########################################################################/** # @RdocDefault abort # @alias abort.condition # # @title "Aborts the current expression call" # # \description{ # @get "title" and returns to the top level prompt/browser # \emph{without signaling a condition}. # } # # @synopsis # # \arguments{ # \item{...}{(optional) Objects coerced to @character and pasted together without a separator, or a @condition object. If no object are given, no message is printed.} # \item{call.}{If @TRUE, the call is added to the message, otherwise not.} # \item{domain}{Used to translate the message (see @see "base::gettext"). If @NA, messages will not be translated.} # } # # \value{ # Returns nothing. # } # # \details{ # There are still cases where one can "catch" the abort and undo it, cf. [1]. # } # # \examples{\dontrun{ # @include "../incl/abort.Rex" # }} # # @author # # \seealso{ # @see "throw". # @see "base::stop". # Internally, @see "base::invokeRestart"\code{("abort")} is utilized. # } # # \references{ # [1] R-devel thread '', Sept 11, 2012, # \url{https://stat.ethz.ch/pipermail/r-devel/2012-September/064838.html}.\cr # } # # @keyword error # @keyword internal #*/########################################################################### setMethodS3("abort", "condition", function(cond, ..., call.=TRUE, domain=NULL) { message <- conditionMessage(cond) call <- conditionCall(cond) if (is.null(call)) { msg <- sprintf("%s", .makeMessage("Abort", domain=domain)) } else { call <- deparse(call) msg <- sprintf("%s %s", .makeMessage("Abort in", domain=domain), call) } msg <- sprintf("%s: %s\n", msg, message) cat(msg, file=stderr()) abort() }) setMethodS3("abort", "default", function(..., call.=TRUE, domain=NULL) { args <- list(...) if (nargs() > 0) { message <- .makeMessage(..., domain=domain) nframe <- sys.nframe() if (nframe <= 2) call. <- FALSE if (call.) { call <- sys.call(which=nframe-2L) if (is.null(call)) { msg <- sprintf("%s", .makeMessage("Abort", domain=domain)) } else { call <- deparse(call) msg <- sprintf("%s %s", .makeMessage("Abort in", domain=domain), call) } msg <- sprintf("%s: %s\n", msg, message) } else { msg <- sprintf("%s: %s\n", .makeMessage("Abort", domain=domain), message) } cat(msg, file=stderr()) } # Now abort R. invokeRestart("abort") }) R.oo/R/extend.default.R0000644000176200001440000000273114554071363014340 0ustar liggesusers###########################################################################/** # @RdocDefault extend # # @title "Extends a object" # # \description{ # via a mechanism known as "parasitic inheritance". # Simply speaking this method "extends" the class of an object. What is actually # happening is that it creates an instance of class name \code{...className}, # by taking another object and add \code{...className} to the class # list and also add all the named values in @... as attributes. # # The method should be used by the constructor of a class and nowhere else. # } # # @synopsis # # \arguments{ # \item{this}{Object to be extended.} # \item{...className}{The name of new class.} # \item{...}{Attribute fields of the new class.} # } # # \value{ # Returns an object of class \code{...className}. # } # # @author # # @examples "../incl/extend.default.Rex" # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("extend", "default", function(this, ...className, ...) { # Add class '...className' to the class vector class(this) <- unique(c(...className, class(this))) # Add attributes args <- list(...) names <- names(args) for (kk in seq_along(args)) { name <- names[kk] if (name == "class") throw("Trying to set class attribute: ", as.character(this)) arg <- args[[kk]] attr(this, name) <- arg } # Return modified object this }, conflict="quiet") R.oo/R/040.setConstructorS3.R0000644000176200001440000001504014554071363015174 0ustar liggesusers###########################################################################/** # @RdocDefault setConstructorS3 # # @title "Defines a class in S3/UseMethod style" # # \description{ # Defines a class in R.oo/S3 style. # What this function currently does is simply creating a constructor # function for the class. # } # # @synopsis # # \arguments{ # \item{name}{The name of the class.} # \item{definition}{The constructor definition. \emph{Note: The constructor # must be able to be called with no arguments, i.e. use default values # for all arguments or make sure you use \code{missing()} or similar!}} # \item{static}{If @TRUE this class is defined to be static, # otherwise not. Currently this has no effect expect as an indicator.} # \item{abstract}{If @TRUE this class is defined to be abstract, # otherwise not. Currently this has no effect expect as an indicator.} # \item{private}{If @TRUE this class is defined to be private.} # \item{protected}{If @TRUE this class is defined to be protected.} # \item{export}{A @logical setting attribute \code{"export"}.} # \item{trial}{If @TRUE this class is defined to be a trial class, # otherwise not. A trial class is a class that is introduced to be # tried out and it might be modified, replaced or even removed in a # future release. Some people prefer to call trial versions, beta # version. Currently this has no effect expect as an indicator.} # \item{deprecated}{If @TRUE this class is defined to be deprecated, # otherwise not. Currently this has no effect expect as an indicator.} # \item{envir}{The environment for where the class (constructor function) # should be stored.} # \item{enforceRCC}{If @TRUE, only class names following the R Coding # Convention is accepted. If the RCC is violated an RccViolationException # is thrown.} # \item{...}{Not used.} # # Note: If a constructor is not declared to be private nor protected, it # will be declared to be public. # } # # \section{A constructor must be callable without arguments}{ # The requirement that a constructor function should be callable without # arguments (e.g. \code{MyConstructor()}) is because that call is used # to create the static instance of a class. The reason for this is that # a static instance of the class is created automatically when the # constructor is called \emph{the first time} (only), that is, # when the first of object of that class is created. # All classes have to have a static instance. # # To make a constructor callable without arguments, one can either make # sure all arguments have default values or one can test for missing # arguments using \code{missing()}. # For instance the following definition is \emph{not} correct: # \code{setConstructorS3("Foo", function(x) extend(Object(), "Foo", x=x))} # whereas this one is # \code{setConstructorS3("Foo", function(x=NA) extend(Object(), "Foo", x=x))} # } # # \section{Code validation}{ # If argument \code{enforceRCC} is @TRUE, # the class name is validated so it starts with a letter and it # also gives a @warning if its first letter is \emph{not} capital. The # reason for this is to enforce a naming convention that names classes # with upper-case initial letters and methods with lower-case initial # letters (this is also the case in for instance Java). # } # # \examples{\dontrun{For a complete example see help(Object).}} # # \seealso{ # To define a method see @see "R.methodsS3::setMethodS3". # For information about the R Coding Conventions, see # @see "RccViolationException". # For a thorough example of how to use this method see @see "Object". # } # # @author # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("setConstructorS3", "default", function(name, definition, private=FALSE, protected=FALSE, export=TRUE, static=FALSE, abstract=FALSE, trial=FALSE, deprecated=FALSE, envir=parent.frame(), enforceRCC=TRUE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Assert that RCC naming conventions are followed. # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if (enforceRCC) { # Assert that the class name is a valid class name. firstLetter <- substring(name, 1,1) if (!is.element(tolower(firstLetter), letters)) throw(RccViolationException("Class names must begin with a letter: ", name)) # Check first letter if (firstLetter == tolower(firstLetter)) throw(RccViolationException("Class names should be nouns starting with a capital letter: ", name)) # Check if name contains . (period) if (regexpr("\\.", name) != -1) throw(RccViolationException("Class names must not contain . (period): ", name)) } # Check for forbidden names. ns <- getNamespace("R.methodsS3") R.methodsS3_R.KEYWORDS <- get("R.KEYWORDS", envir=ns) if (is.element(name, R.methodsS3_R.KEYWORDS)) throw(RccViolationException("Class names must not be same as a reserved keyword in R: ", name)) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Set up the modifiers # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if (private) protection="private" else if (protected) protection="protected" else protection="public" # Create the modifiers modifiers <- protection if (static == TRUE) modifiers <- c(modifiers, "static") if (abstract == TRUE) modifiers <- c(modifiers, "abstract") if (deprecated == TRUE) modifiers <- c(modifiers, "deprecated") if (trial == TRUE) modifiers <- c(modifiers, "trial") modifiers <- c(modifiers, "class") # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Create the constructor function (by default in the parent frame) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Create expr <- substitute({ ns <- getNamespace("R.oo") if (exists("Class", mode="function", envir=ns, inherits=FALSE)) { R.oo_Class <- get("Class", mode="function", envir=ns, inherits=FALSE) fcn <- R.oo_Class(name, definition) rm(list="R.oo_Class") } else { # Only used for/by R.oo itself. fcn <- Class(name, definition) } rm(list="ns") attr(fcn, "export") <- export attr(fcn, "modifiers") <- modifiers }, list(fcn=as.name(name), name=name, definition=definition, export=export, modifiers=modifiers) ) # Assign retValue <- eval(expr, envir=envir) invisible() }) # setConstructorS3() R.oo/R/InternalErrorException.R0000644000176200001440000000702314554071363016072 0ustar liggesusers###########################################################################/** # @RdocClass InternalErrorException # # @title "InternalErrorException represents internal errors" # # \description{ # @classhierarchy # # @get "title" that are likely to be due to implementation errors done by # the author of a specific package and not because the user made an error. # Errors that are due to unexpected input to functions etc falls under # this error type. # } # # @synopsis # # \arguments{ # \item{...}{Any arguments accepted by @see "Exception"}. # \item{package}{The name (@character string) of the package where the # error exists. Can also be a @see "Package" object. If @NULL, the # source of the error is assumed to be unknown.} # } # # \section{Fields and Methods}{ # @allmethods # } # # @author # # \seealso{ # For detailed information about exceptions see @see "Exception". # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setConstructorS3("InternalErrorException", function(..., package=NULL) { if (!is.null(package) && !inherits(package, "Package")) { package <- Package(as.character(package)) } extend(Exception(...), "InternalErrorException", .package=package ) }) ###########################################################################/** # @RdocMethod getPackage # # @title "Gets the suspicious package likely to contain an error" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @see "Package" object. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getPackage", "InternalErrorException", function(this, ...) { this$.package }) ###########################################################################/** # @RdocMethod getMessage # # @title "Gets the message of the exception" # # \description{ # @get "title" and adds a message that clarifies that the error is likely # due to an internal error and not due to the user. It also gives information # how to contact the maintainer or author of the suspicious package. This # information is retrieved from the DESCRIPTION file of the package. To help # the package developer, information about the current version of R, the # current version of the package etc are also returned so the user can # easily cut'n'paste that information into a bug report. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getMessage", "InternalErrorException", function(this, ...) { msg <- getMessage.Exception(this) msg <- paste(msg, " This error is likely to be due to an internal error", sep="") pkg <- getPackage(this) if (!is.null(pkg)) { msg <- paste(msg, " related to package ", getName(pkg), " v", getVersion(pkg), ". Please report this problem to the maintainer ", getMaintainer(pkg), " or the author ", getAuthor(pkg), " of that package", sep="") } R.oo <- Package("R.oo") msg <- paste(msg, ". Do not forget to report that you are using R v", getVersion(Package("base")), " on a ", R.Version()$platform, " platform together with R.oo v", getVersion(R.oo), ".", sep="") msg }) R.oo/R/020.makeObjectFinalizer,private.R0000644000176200001440000002156514554071363017313 0ustar liggesusers###########################################################################/** # @RdocFunction .makeObjectFinalizer # # @title "Creates a standalone finalizer function for Object" # # \description{ # @get "title", which assumes only that the \pkg{base} package is available. # } # # @synopsis # # \arguments{ # \item{this}{The @Object to be finalized.} # \item{reloadRoo}{If @TRUE, the finalizer will try to temporary # reload the \pkg{R.oo} package if not loaded.} # } # # \value{ # Returns a @function that can be passed to @see "base::reg.finalizer". # } # # \details{ # The created finalizer is reentrant. # This is always the case when the \pkg{R.oo} package is already # loaded when the finalizer is called. # It is also always the case on R v2.15.2 Patched r61487 and beyond. # In other cases, the finalizer inspects the call stack # (via @see "sys.calls") to check whether @see "base::parse" # has been called or not. If it is on the call stack, it indicates # that @see "base::parse" triggered the garbage collection, and # the \pkg{R.oo} package will \emph{not} be reloaded in order to # avoid risking @see "base::parse" being called again. # } # # @keyword internal #*/########################################################################### .makeObjectFinalizer <- function(this, reloadRoo=TRUE) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - getObjectInfo <- function(this) { env <- attr(this, ".env") if (is.null(env)) return(NA_character_) # base::environmentName() was added to R v2.5.0 if (exists("environmentName", mode="function", envir=getNamespace("base"), inherits=FALSE)) { name <- environmentName(env) } else { name <- "" } if (name == "") { # Cannot assume 'utils' is loaded name <- utils::capture.output(print.default(env)) name <- name[1L]; # Just in case name <- gsub("[<]*environment:[ ]*([^>]*)[>]", "\\1", name) } className <- class(this)[1L] name <- paste(className, ": ", name, sep="") # More debug information if (className == "Package") { name <- sprintf("%s {.name='%s'}", name, env$.name) } name } # getObjectInfo() isLibraryReentrant <- function() { getRversion2 <- function() { rVer <- R.version[c("major", "minor", "status", "svn rev")] names(rVer)[3:4] <- c("patched", "rev") rVer$patched <- ifelse(identical(rVer$patched, "Patched"), 1L, 0L) rVer$rev <- ifelse(is.null(rVer$rev), 0L, rVer$rev) rVer <- lapply(rVer, FUN=as.numeric) rVer } # getRversion2() rVer <- getRversion2() if (rVer$major >= 3) return(TRUE) if (rVer$major < 2) return(FALSE) if (rVer$minor >= 15.3) return(TRUE) if (rVer$minor < 15.2) return(FALSE) if (rVer$patched < 1) return(FALSE) if (rVer$rev < 61487) return(FALSE) TRUE } # isLibraryReentrant() isParseCalled <- function() { calls <- sys.calls() if (length(calls) == 0L) return(FALSE) for (kk in seq_along(calls)) { call <- calls[[kk]] name <- call[[1L]] if (!is.symbol(name)) next if (name == "do.call") { name <- call[[2L]] if (!is.symbol(name)) next name <- as.character(name) } if (name == "parse") { return(TRUE) } } # for (kk ...) FALSE } # isParseCalled() isLibraryActive <- function() { # Just in case the below won't work one day due to R updates... tryCatch({ # Identify the environment/frame of interest by making sure # it at least contains all the arguments of source(). argsToFind <- names(formals(base::library)) # Scan the call frames/environments backwards... srcfileList <- list() for (ff in sys.nframe():0) { env <- sys.frame(ff) # Does the environment look like a library() environment? exist <- sapply(argsToFind, FUN=exists, envir=env, inherits=FALSE) if (!all(exist)) { # Nope, then skip to the next one next } return(TRUE) } # for (ff ...) }, error = function() {}) FALSE } # isLibraryActive() isRooLoading <- function() { for (n in sys.nframe():1) { env <- sys.frame(n) if (exists("__NameSpacesLoading__", envir=env, inherits=FALSE)) { pkgs <- get("__NameSpacesLoading__", envir=env, inherits=FALSE) if (is.element("R.oo", pkgs)) return(TRUE) } } # for (n ...) FALSE } # isRooLoading() isRooLoaded <- function() { is.element("R.oo", loadedNamespaces()) } # isRooLoaded() # NOTE: The finalizer() depends on the 'this' object. # /HB 2011-04-02 # Note, R.oo might be detached when this is called! If so, reload # it, this will be our best chance to run the correct finalizer(), # which might be in a subclass of a different package that is still # loaded. finalizer <- function(env) { debug <- FALSE if (debug) message(sprintf("finalizer(): reloadRoo=%s", reloadRoo)) if (debug) message(paste(capture.output(print(sessionInfo())), collapse="\n")) # Classes for which it is known that finalizer() does nothing if (is.element(class(this)[1L], c("Object", "Class", "Package"))) { return() } # Do nothing if R.oo is being loaded if (isRooLoading()) return() # Is R.oo::finalize() available? if (isRooLoaded()) { if (debug) message(sprintf("finalizer(): Call finalize()...")) R.oo::finalize(this) if (debug) message(sprintf("finalizer(): Call finalize()...done")) return() } # Nothing to do? if (!reloadRoo) return() warning(sprintf("Object was not be finalize():d properly because the R.oo package was not loaded: %s", getObjectInfo(this))) return() # Skip the finalizer()? genv <- globalenv() if (exists("...R.oo::skipFinalizer", envir=genv, inherits=FALSE)) { if (debug) message(sprintf("Skipping finalizer().")) return() } # Skip because library() is active? if (isLibraryActive()) { warning(sprintf("Detected finalization of Object while library() is working on attaching a package and the R.oo package is not loaded. This is most likely due to a *temporary* Object allocated in .onLoad()/.onAttach(), which is not allowed. Finalization of Object will *not* be skipped: %s", getObjectInfo(this))) return() } # Check if base::library() is reentrant... if (!isLibraryReentrant()) { # If not, check if base::parse() triggered the garbage collection # and/or has been called, because then we must not call library(), # because it will in turn call parse() potentially causing R to # crash. if (isParseCalled()) { warning("Object may not be finalize():d properly because the R.oo package was not loaded and will not be reloaded, because if done it may crash R (running version of R is prior to R v2.15.2 Patched r61487 and the garbage collection was triggered by base::parse()): ", getObjectInfo(this)) return() } } warnMsg <- "" # (1) Load the 'R.oo' package if (debug) message(sprintf("finalizer(): Reloaded R.oo...")) suppressMessages({ warnMsg <- suppressWarnings({ loadNamespace("R.oo") }) }) if (debug) message(sprintf("finalizer(): Reloading R.oo...done")) if (is.character(warnMsg)) { warnMsg <- sprintf(" (with warning %s)", warnMsg) } else { warnMsg <- "" } # For unknown reasons R.oo might not have been loaded. if (!isRooLoaded()) { warning(sprintf("Object may not be finalize():d properly because the R.oo package failed to reload%s: %s", warnMsg, getObjectInfo(this))) return() } # Make sure to unload R.oo at the end on.exit(unloadNamespace("R.oo")) if (debug) message(sprintf("finalizer(): Call finalize()...")) R.oo::finalize(this) if (debug) message(sprintf("finalizer(): Call finalize()...done")) # NOTE! Before unloading R.oo again, we have to make sure the Object:s # allocated by R.oo itself (e.g. an Package object), will not reload # R.oo again when being garbage collected, resulting in an endless # loop. We do this by creating a dummy finalize() function, detach # R.oo, call garbage collect to clean out all R.oo's objects, and # then remove the dummy finalize() function. # (2) Put a dummy finalize() function on the search path. if (!exists("...R.oo::skipFinalizer", envir=genv, inherits=FALSE)) { assign("...R.oo::skipFinalizer", TRUE, envir=genv, inherits=FALSE) on.exit({ rm(list="...R.oo::skipFinalizer", envir=genv, inherits=FALSE) }, add=TRUE) } # (4) Force all R.oo's Object:s to be finalize():ed. if (debug) message(sprintf("finalizer(): Calling base::gc()")) base::gc() if (debug) message(sprintf("finalizer(): done")) } # finalizer() return(finalizer) } # .makeObjectFinalizer() R.oo/R/objectSize.environment.R0000644000176200001440000000277014554071363016075 0ustar liggesusers###########################################################################/** # @set "class=environment" # @RdocMethod objectSize # # @title "Gets the size of an environment in bytes" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{envir}{An @see "base::environment".} # \item{...}{Arguments passed to @see "base::ls".} # } # # \value{ # Returns an @integer. # } # # @author # # \seealso{ # Internally @see "utils::object.size" is used. # } # # \keyword{attribute} # \keyword{utilities} #*/########################################################################### setMethodS3("objectSize", "environment", function(envir, ...) { ## Keep track of already scanned environments ## in order to avoid endless recursion. args <- list(...) .scannedEnvs <- args$.scannedEnvs if (is.null(.scannedEnvs)) .scannedEnvs <- list() alreadyScanned <- function(envir) { if (!is.environment(envir)) return(FALSE) for (env in .scannedEnvs) { if (identical(env, envir)) return(TRUE) } FALSE } ## Get all objects in the environment args <- list(envir=envir, all.names=TRUE, ...) args$.scannedEnvs <- NULL names <- do.call(ls, args=args) # Nothing to do? if (length(names) == 0L) return(0) ## Avoid scanning the current environment again .scannedEnvs <- c(.scannedEnvs, envir) size <- 0 for (name in names) { obj <- envir[[name]] if (!alreadyScanned(obj)) { size <- size + objectSize(obj, .scannedEnvs=.scannedEnvs) } } size }) R.oo/R/compileRdoc.R0000644000176200001440000000532414554071363013667 0ustar liggesusers###########################################################################/** # @RdocFunction compileRdoc # # @title "Compiles the Rdoc help comments in a package" # # \description{ # @get "title" by parsing the source code files and writes Rd help files. # } # # @synopsis # # \arguments{ # \item{pkgname}{A @character string specifying the package name. # If @NULL, the package name is inferred from the DESCRIPTION file # that is automatically search for in the subdirectories.} # \item{path}{A @character string specifying the path of the # package source directory.} # \item{...}{Additional arguments passed to \code{Rdoc\$compile()}.} # \item{verbose}{If @TRUE, verbose output is printed, otherwise not.} # } # # \value{ # Returns nothing. # } # # \details{ # To compile all Rdoc comments in a package 'PkgA' that is located # under the current working directory (e.g. \code{PkgA/R/*.R}) from # the system command line, do: # \preformatted{ # Rscript -e R.oo::compileRdoc() # } # } # # @author # # \seealso{ # See the @see "Rdoc" class. # } # # @keyword documentation # @keyword IO # @keyword internal #*/########################################################################### compileRdoc <- function(pkgname=NULL, path=pkgname, ..., verbose=TRUE) { require("R.oo") || stop("Package not loaded: R.oo") # Infer package name from DESCRIPTION? if (is.null(pkgname)) { dirs <- list.files() dirs <- dirs[file_test("-d", dirs)] pathnames <- file.path(dirs, "DESCRIPTION") pathnames <- pathnames[file_test("-f", pathnames)] if (length(pathnames) == 0L) { throw("Failed to infer package name, since no */DESCRIPTION file was found.") } if (length(pathnames) > 1L) { throw("Failed to infer unique package name, because more than one */DESCRIPTION file was found: ", paste(sQuote(pathnames), collapse=", ")) } pathname <- pathnames[1L] pi <- read.dcf(file=pathname) pkgname <- pi[,"Package", drop=TRUE] if (length(pkgname) == 0L) { throw("Failed to infer package name. No 'Package' was listed in ", sQuote(pathname), ".") } if (length(pkgname) > 1L) { throw("Failed to infer package name. More than one 'Package' were listed in ", sQuote(pathname), ": ", paste(sQuote(pkgname), collapse=", ")) } } if (is.null(path)) { path <- pkgname } if (!file_test("-d", path)) { throw("No such package directory: ", path) } pathR <- file.path(path, "R") if (!file_test("-d", pathR)) { throw("No such package R/ directory: ", pathR) } require(pkgname, character.only=TRUE) || throw("Package not loaded: ", pkgname) opwd <- setwd(pathR) on.exit(setwd(opwd)) Rdoc$compile(..., verbose=verbose) } # compileRdoc() R.oo/R/zzz.R0000644000176200001440000000174114554071363012263 0ustar liggesusers## covr: skip=all # Detach the 'R.oo' attached in file 030.ObjectClassFunctions.R if (is.element("R.oo", search())) detach("R.oo") .onUnload <- function(libpath) { ## message("R.oo::.onUnload()") # Force finalize() on Object:s base::gc() } # .onUnload() .onLoad <- function(libname, pkgname) { ns <- getNamespace(pkgname) ## Doing assign(pkgname, Package(pkgname), envir=ns) seems to ## introduce potential cyclic loading of the R.oo namespace. ## My best guess is that it has to do with garbage collection. ## Because of this, we use a "delayed" assignment. /HB 2013-10-10 delayedAssign(pkgname, Package("R.oo"), eval.env=ns, assign.env=ns) # Create getCall() generic function, iff missing (R < 2.14.0) if (!exists("getCall", mode="function")) { assign("getCall", function(...) UseMethod("getCall"), envir=ns) } } # .onLoad() .onAttach <- function(libname, pkgname) { pkg <- get(pkgname, envir=getNamespace(pkgname)) startupMessage(pkg) } # .onAttach() R.oo/R/throw.default.R0000644000176200001440000000307514554071363014216 0ustar liggesusers###########################################################################/** # @RdocDefault throw # # @title "Throws an Exception" # # \description{ # Throws an exception similar to \code{stop()}, but with support for # @see "Exception" classes. The first argument (\code{object}) is by # default pasted together with other arguments (@...) and with separator # \code{sep=""}. For instance, to throw an exception, write # # \code{throw("Value out of range: ", value, ".")}. # # which is short for # # \code{throw(Exception("Value out of range: ", value, "."))}. # # Note that \code{throw()} can be defined for classes inheriting # @see "Exception", which can then be caught (or not) # using \code{\link[base:conditions]{tryCatch}()}. # } # # @synopsis # # \arguments{ # \item{...}{One or several strings that are concatenated and collapsed # into on message string.} # } # # \value{ # Returns nothing. # } # # \examples{ # rbern <- function(n=1, prob=1/2) { # if (prob < 0 || prob > 1) # throw("Argument 'prob' is out of range: ", prob) # rbinom(n=n, size=1, prob=prob) # } # # rbern(10, 0.4) # # [1] 0 1 0 0 0 1 0 0 1 0 # tryCatch(rbern(10, 10*0.4), # error=function(ex) {} # ) # } # # @author # # \seealso{ # See the @see "Exception" class for more detailed information. # } # # \keyword{error} #*/########################################################################### setMethodS3("throw", "default", function(...) { throw(Exception(...)) }, overwrite=TRUE, conflict="quiet") setGenericS3("throw", overwrite=TRUE, force=TRUE) R.oo/R/getName.environment.R0000644000176200001440000000216014554071363015345 0ustar liggesusers###########################################################################/** # @class "environment" # @RdocMethod getName # # @title "Gets the name of an environment" # # \description{ # @get "title", e.g. \code{"R_GlobalEnv"} or \code{"0x01ddd060"}. # } # # @synopsis # # \arguments{ # \item{env}{An @environment.} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # name <- getName(globalenv()) # print(name) # stopifnot(identical(name, "R_GlobalEnv")) # # getName(new.env()) # } # # @author # # \seealso{ # \code{\link[base:environment]{environmentName}()}. # } # # \keyword{programming} #*/########################################################################### setMethodS3("getName", "environment", function(env, ...) { # base::environmentName() was added to R v2.5.0 if (exists("environmentName", mode="function")) { name <- environmentName(env) } else { name <- "" } if (name == "") { name <- capture.output(print.default(env)) name <- name[1]; # Just in case name <- gsub("[<]*environment:[ ]*([^>]*)[>]", "\\1", name) } name }) R.oo/R/999.package.R0000644000176200001440000000513214554071363013350 0ustar liggesusers#########################################################################/** # @RdocPackage R.oo # # \description{ # @eval "getDescription(R.oo)" # # Please note that the Rdoc syntax/grammar used to convert Rdoc comments # in code into Rd files is not strictly defined and is modified by the # need of the author. Ideally, there will be a well defined Rdoc language # one day. # } # # \section{Installation and updates}{ # To install this package do\cr # # \code{install.packages("R.oo")} # } # # \section{Dependencies and other requirements}{ # This package requires a standard \R installation and # the \pkg{R.methodsS3} package. # } # # \section{To get started}{ # To get started,It is very useful to understand that: # \enumerate{ # \item The @see "R.methodsS3::setMethodS3"() function, which is # defined in the \pkg{R.methodsS3} package (used to be part of # \pkg{R.oo}), is nothing but a conveniency wrapper for setting # up S3 methods, and automatically create an S3 generic # function, if missing. For more information, see the help of # \pkg{R.methodsS3}. # \item The @see "Object" class is a top-level "root" class # that provides support for \emph{reference variables}. # Any class inheriting from this class supports # reference variables. # \item The @see "Object" class is basically a wrapper around an # @environment, which some additional accessors etc. It is the # environment data type that provides the "emulation" of # reference variables - the Object class structure makes # it easier to extends this class and adds some level of coding # protection. The Object class features is not intended for # referencing individual elements of basic \R data types, # but rather for the whole variable of such. # For instance, you can reassign a whole matrix \code{X} part of # the object this way, but you cannot reassign \code{X[1,1]} # without creating a completely new copy. # } # } # # \section{Further readings}{ # For a detailed introduction to the package see [1] (part of the # package distribution). # } # # \section{How to cite this package}{ # Whenever using this package, please cite [1] as\cr # # @howtocite "R.oo" # } # # @author # # \section{License}{ # The releases of this package is licensed under # LGPL version 2.1 or newer. # } # # \references{ # [1] @include "../incl/BengtssonH_2003.bib.Rdoc" \cr # } # # \seealso{ # People interested in \pkg{R.oo} may also be interested in # packages \pkg{proto} and \pkg{mutatr}. # } #*/######################################################################### R.oo/R/ASCII.R0000644000176200001440000001354314554071363012261 0ustar liggesusers#########################################################################/** # @RdocObject ASCII # # @alias ASCII.BEL # @alias ASCII.BS # @alias ASCII.HT # @alias ASCII.LF # @alias ASCII.FF # @alias ASCII.CR # @alias ASCII.SO # @alias ASCII.SI # @alias ASCII.DC1 # @alias ASCII.DC3 # @alias ASCII.ESC # # @title "8-bit ASCII table" # # \description{ # ASCII is the 8-bit ASCII table with ASCII characters from 0-255. # } # # \examples{ # ch <- ASCII[65+1]; # ch == "A" # } # # @author # # \seealso{ # @see charToInt # @see intToChar # } # # @keyword character # @keyword internal #*/######################################################################### ASCII <- c( "","\001","\002","\003","\004","\005","\006","\007", # 000-007 "\010","\011","\012","\013","\014","\015","\016","\017", # 010-017 "\020","\021","\022","\023","\024","\025","\026","\027", # 020-027 "\030","\031","\032","\033","\034","\035","\036","\037", # 030-037 "\040","\041","\042","\043","\044","\045","\046","\047", # 040-047 "\050","\051","\052","\053","\054","\055","\056","\057", # 050-057 "\060","\061","\062","\063","\064","\065","\066","\067", # 060-067 "\070","\071","\072","\073","\074","\075","\076","\077", # 070-077 "\100","\101","\102","\103","\104","\105","\106","\107", # 100-107 "\110","\111","\112","\113","\114","\115","\116","\117", # 110-117 "\120","\121","\122","\123","\124","\125","\126","\127", # 120-127 "\130","\131","\132","\133","\134","\135","\136","\137", # 130-137 "\140","\141","\142","\143","\144","\145","\146","\147", # 140-147 "\150","\151","\152","\153","\154","\155","\156","\157", # 150-157 "\160","\161","\162","\163","\164","\165","\166","\167", # 160-167 "\170","\171","\172","\173","\174","\175","\176","\177", # 170-177 "\200","\201","\202","\203","\204","\205","\206","\207", # 200-207 "\210","\211","\212","\213","\214","\215","\216","\217", # 210-217 "\220","\221","\222","\223","\224","\225","\226","\227", # 220-227 "\230","\231","\232","\233","\234","\235","\236","\237", # 230-237 "\240","\241","\242","\243","\244","\245","\246","\247", # 240-247 "\250","\251","\252","\253","\254","\255","\256","\257", # 250-257 "\260","\261","\262","\263","\264","\265","\266","\267", # 260-267 "\270","\271","\272","\273","\274","\275","\276","\277", # 270-277 "\300","\301","\302","\303","\304","\305","\306","\307", # 300-307 "\310","\311","\312","\313","\314","\315","\316","\317", # 310-317 "\320","\321","\322","\323","\324","\325","\326","\327", # 320-327 "\330","\331","\332","\333","\334","\335","\336","\337", # 330-337 "\340","\341","\342","\343","\344","\345","\346","\347", # 340-347 "\350","\351","\352","\353","\354","\355","\356","\357", # 350-357 "\360","\361","\362","\363","\364","\365","\366","\367", # 360-367 "\370","\371","\372","\373","\374","\375","\376","\377" # 370-377 ) # We removed ASCII 0x00, because it represents an empty string in # R v2.7.0 (and maybe some earlier version) and in R v2.8.0 we will get # a warning. However, for backward compatibility we will still use it # for version prior to R v2.7.0. See also email from Brian Ripley # on 2008-04-23 on this problem. if (compareVersion(as.character(getRversion()), "2.7.0") < 0) { ASCII[1] <- eval(parse(text="\"\\000\"")) } # Alternatively one can do like this. Idea by Peter Dalgaard, # Dept. of Biostatistics, University of Copenhagen, Denmark. # ASCII <- c("\000", sapply(1:255, function(i) parse(text=paste("\"\\", # structure(i,class="octmode"), "\"", sep=""))[[1]]) ) # Some special ASCII characters. ASCII.BEL <- "\007" ASCII.BS <- "\010" ASCII.HT <- "\011" ASCII.LF <- "\012" ASCII.FF <- "\014" ASCII.CR <- "\015" ASCII.SO <- "\016" ASCII.SI <- "\017" ASCII.DC1 <- "\021" ASCII.DC3 <- "\023" ASCII.ESC <- "\033" #########################################################################/** # @RdocDefault charToInt # # @title "Converts a vector of ASCII characters into a vector of integers" # # \description{ # Converts a @vector of ASCII @characters to a equal length vector of ASCII # @integers. # } # # @synopsis # # \arguments{ # \item{ch}{A @character @vector.} # \item{...}{Not used.} # } # # \value{ # Returns an ASCII @integer @vector. # } # # @author # # \examples{ # i <- charToInt(unlist(strsplit("Hello world!", split=NULL))) # # Gives: 72 101 108 108 111 32 119 111 114 108 100 33 # ch <- intToChar(c(72,101,108,108,111,32,119,111,114,108,100,33)) # # Gives: "H" "e" "l" "l" "o" " " "w" "o" "r" "l" "d" "!" # } # # \seealso{ # @see intToChar # @see "base::utf8Conversion". # @see "base::rawConversion" # } # # @keyword character # @keyword internal #*/######################################################################### setMethodS3("charToInt", "default", function(ch, ...) { match(ch, ASCII) - 1L }) #########################################################################/** # @RdocDefault intToChar # # @title "Converts a vector of integers into a vector of ASCII characters" # # \description{ # Converts a vector of ASCII integers to a equal length vector of ASCII # characters. To make sure that all values in the input vector are in # the range [0,255], the input vector is taken modulo 256. # } # # @synopsis # # \arguments{ # \item{i}{An @integer @vector.} # \item{...}{Not used.} # } # # \value{ # Returns an ASCII @character @vector. # } # # @author # # \examples{ # i <- charToInt(unlist(strsplit("Hello world!", split=NULL))) # # Gives: 72 101 108 108 111 32 119 111 114 108 100 33 # ch <- intToChar(c(72,101,108,108,111,32,119,111,114,108,100,33)) # # Gives: "H" "e" "l" "l" "o" " " "w" "o" "r" "l" "d" "!" # } # # \seealso{ # @see "base::utf8Conversion". # @see charToInt # } # # @keyword character # @keyword internal #*/######################################################################### setMethodS3("intToChar", "default", function(i, ...) { ASCII[i %% 256 + 1] }) R.oo/R/030.ObjectClassFunctions.R0000644000176200001440000000434714554071363016021 0ustar liggesusers############################################################################ # This source code file contains constructor and function definitions that # are used for loading this package only. ############################################################################ # To please R CMD check attachX <- base::attach attachX(list( Object = function(core=NA, finalize=TRUE) { # Create a new environment and wrap it up as a private field of a list. this <- core this.env <- new.env() attr(this, ".env") <- this.env class(this) <- "Object" if (getOption("R.oo::Object/instantiationTime", FALSE)) { attr(this, "...instantiationTime", Sys.time()) } finalizer <- function(env) { # Nothing needed to be done in this temporary finalizer factory, # because it is only utilized by this very package and none of # the classes in this package created Object:s that needs to be # finalized. } # finalizer() # Should this Object be finalized? if (finalize) { onexit <- getOption("R.oo::Object/finalizeOnExit", FALSE) reg.finalizer(this.env, finalizer, onexit=onexit) } assign("...finalize", finalize, envir=this.env, inherits=FALSE) this }, extend = function(this, ...className, ..., ...finalize=TRUE) { fields <- list(...) names <- names(fields) this.env <- attr(this, ".env") for (name in names) assign(name, fields[[name]], envir=this.env) class(this) <- c(...className, class(this)) # Override this (=unregister finalizer) according to argument # '...finalize' of extend()? if (!is.na(...finalize) && !isTRUE(...finalize)) { # Unregister finalizer (by registering a dummy one) reg.finalizer(this.env, f=function(...) {}) } this }, Class = function(name=NULL, constructor=NULL) { if (is.null(name)) { constructor <- NA } else if (!is.function(constructor)) { throw("Argument 'constructor' must be a function: ", mode(constructor)) } # This is an example where one wants to have the core of an Object to not # be NA, but something else. this <- extend(Object(constructor), "Class", .staticInstance = NULL ) this } ), name="R.oo") # Cleanup rm(list="attachX") R.oo/R/050.Object.R0000644000176200001440000017103314554071363013141 0ustar liggesusers###########################################################################/** # @RdocClass Object # # @title "The root class that every class must inherit from" # # \description{ # R.oo\cr # \bold{Class Object}\cr # # public class \bold{Object}\cr # # \code{Object} is the root class of all other classes. All classes # \emph{must} extends this class, directly or indirectly, which means # that they all will inherit the methods in this class. # } # # @synopsis # # \arguments{ # \item{core}{The core value of each \emph{reference} referring to the # Object. By default, this is just the smallest possible \R object, but # there are situations where it is useful to have another kind of core, # which is the case with the Class class. # \emph{Note that this value belongs to the reference variable # and not to the Object, which means it can not be referenced.}} # \item{finalize}{If @TRUE, method @seemethod "finalize" will # be called on this Object when it is garbage collected.} # } # # \section{Fields and Methods}{ # @allmethods # } # # \section{Defining static fields}{ # To define a static field of an Object class, use a private field # \code{<.field>} and then create a virtual field \code{} by # defining methods \code{get()} and \code{set()}. # These methods should retrieve and assign the value of the field # \code{<.field>} of the \emph{static} instance of the class. The # second example below shows how to do this. The example modifies # also the static field already in the constructor, which is something # that otherwise may be tricky. # } # # \examples{ # @include "../incl/Person.Rex" # # @include "../incl/StaticFields.Rex" # } # # @author # # \references{ # [1] @include "../incl/BengtssonH_2003.bib.Rdoc" \cr # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setConstructorS3("Object", Object) ###########################################################################/** # @RdocMethod as.character # # @title "Gets a character string representing the object" # # \description{ # @get "title". In the class Object, # this method simply returns the class name and the hashCode() value # of the object. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string representation of the Object. By default it # is "\{class name\}: \{hash code\}". # } # # \examples{ # obj <- Object() # as.character(obj) # "Object: 0x000000000ab6a7a8" # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("as.character", "Object", function(x, ...) { # To please R CMD check this <- x addr <- getInternalAddress(this, format="hexstring") paste(class(this)[1], ": ", addr, sep="") }) # as.character() ###########################################################################/** # @RdocMethod getInstantiationTime # # @title "Gets the time when the object was instantiated" # # \description{ # @get "title" (created) as a POSIXt object. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a POSIXt object, which extends class POSIXct. # } # # \details{ # The instantiation time stamp is set when the object is created, and # only of option \code{"R.oo::BasicObject/instantiationTime"} is @TRUE. # } # # \examples{ # oopts <- options("R.oo::Object/instantiationTime"=TRUE) # obj <- Object() # print(getInstantiationTime(obj)) # options(oopts) # } # # \seealso{ # For more about time formats and POSIX see @see "base::DateTimeClasses". # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("getInstantiationTime", "Object", function(this, ...) { time <- attr(this, "...instantiationTime") if (!is.null(time)) return(time) # Backward compatibility (due to a SPELLING ERROR in an earlier version) time <- attr(this, "...instanciationTime") NULL }) ###########################################################################/** # @RdocMethod clone # # @title "Clones an Object" # # \description{ # Creates an identical copy of the object and returns a reference to the # new object. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # A reference to the new object. # } # # \examples{ # o1 <- Object() # o2 <- clone(o1) # # print(equals(o1, o2)) # } # # \details{ # Please note that no constructors are called during the creation of the # clone and neither is any static class code called. # } # # \seealso{ # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} #*/########################################################################### setGenericS3("clone", overwrite = TRUE) setMethodS3("clone", "Object", function(this, ...) { # Copy the reference. clone <- this # Create a new environment, i.e. a new Object. clone.env <- new.env() attr(clone, ".env") <- clone.env # Copy all variables in the environment. this.env <- attr(this, ".env") fields <- getFields(this, private=TRUE) for (field in fields) { value <- get(field, envir=this.env, inherits=FALSE) # The following line must be included to do nothing, but the effect # is that it fools the lazy evaluation (?) to create a true copy of # the object. If this is not done, it won't be a true clone even if # the value is assigned to another environment. Example: # b <- clone(a) # b$matrix[1,1] <- 2 # will otherwise also change a$matrix[1,1]. /HB 021023 attr(value, "R.oo::.clone.Object") <- NULL assign(field, value, envir=clone.env) } clone }) ###########################################################################/** # @RdocMethod equals # # @title "Compares an object with another" # # \description{ # @get "title" and returns @TRUE if they are equal. # The equal property must be # # 1) \emph{reflexive}, i.e. \code{equals(o1,o1)} should be @TRUE. # # 2) \emph{symmetric}, i.e. \code{equals(o1,o2)} is @TRUE if and only # if \code{equals(o2,o1)} is @TRUE. # # 3) \emph{transitive}, i.e. \code{equals(o1,o2)} is @TRUE and # \code{equals(o2,o3)} is @TRUE, then \code{equals(o1,o3)} should # be @TRUE. # # 5) \emph{consistent}, i.e. \code{equals(o1,o2)} should return the same # result on multiple invocations as long as nothing has changed. # # 6) \code{equals(o1,}@NULL\code{)} should return @FALSE, unless # \code{o1} is also @NULL. # # By default, the method returns @TRUE if and only if the two # references compared refer to the same @Object, i.e. # \code{( !is.null(obj) && (hashCode(this) == hashCode(obj)) )}. # } # # @synopsis # # \arguments{ # \item{other}{The other object this @Object should be compared to.} # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the Object's are equal, otherwise @FALSE. # } # # \examples{ # o1 <- Object() # o2 <- clone(o1) # equals(o1, o1) # TRUE # equals(o1, o2) # FALSE # } # # \seealso{ # @seemethod "hashCode". # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("equals", "Object", function(this, other, ...) { ( !is.null(other) && (hashCode(this) == hashCode(other)) ) }) ###########################################################################/** # @RdocMethod finalize # # @title "Finalizer methods called when object is clean out" # # \description{ # Finalizer methods are called just the moment before the object is # about to be deleted by the garbage collector. # # \bold{If creating a custom \code{finalize()} method for a subclass # in a package, then it needs to be exported in the NAMESPACE of # that package. If not, it will not be found nor called and # there will be no error message.} # # \bold{A finalizer method should never be called explicitly!} # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # @examples "../incl/Object.finalize.Rex" # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("finalize", "Object", function(this, ...) { }) ###########################################################################/** # @RdocMethod hashCode # # @title "Gets a hash code for the Object" # # \description{ # @get "title". This makes it possible to put any @Object in a hash table. # # The hash code returned must: # # 1) be \emph{consistent}, i.e. \code{hashCode(obj)} should return the same # value on multiple invocations as long as nothing has changed. # # 2) tell same same thing as \code{equals()}, if \code{equals(o1,o2)} is # @TRUE, then \code{hashCode(o1) == hashCode(o2)} should also be # @TRUE. # # Note that if \code{equals(o1,o2)} is @FALSE, \code{hashCode(o1)} # \code{hashCode(o2)} may be \emph{either} equal or non-equal. # # By default, the method returns the internal memory address where the # Object is located. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @double. # } # # \examples{ # obj <- Object() # hashCode(obj) # 26979608 # } # # @author # # \seealso{ # @seemethod "equals" # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("hashCode", "Object", function(this, ...) { getInternalAddress(this, format="numeric") }) # hashCode() ###########################################################################/** # @RdocMethod getInternalAddress # # @title "Gets the memory location where the Object resides" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{format}{A @character string specifying what format to return.} # \item{...}{Not used.} # } # # \value{ # The address is returned as a @numeric integer if # \code{format == "numeric"}, and as a @character string if # \code{format == "hexstring"}. # } # # \examples{ # obj <- Object() # getInternalAddress(obj, format="numeric") # 179742632 # getInternalAddress(obj, format="hexstring") # "0x000000000ab6a7a8" # } # # @author # # \seealso{ # \code{\link[=getName.environment]{getName()}}. # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("getInternalAddress", "Object", function(this, format=c("numeric", "hexstring"), ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - hexStringToDouble <- function(hex) { hexDigits <- unlist(strsplit("0123456789ABCDEF", "")) digits16 <- unlist(strsplit(toupper(hex), "")) digits10 <- match(digits16, hexDigits) - 1 bases10 <- rev(16^(seq_along(digits10)-1)) sum(digits10 * bases10) } hexStringToInt <- function(hex) { as.integer(hexStringToDouble(hex)) } # Argument 'format': format <- match.arg(format) pointer <- getName(attr(this, ".env")) if (format == "numeric") { pointer <- gsub("0x", "", pointer) pointer <- hexStringToDouble(pointer) } pointer }, private=TRUE) # getInternalAddress() ###########################################################################/** # @RdocMethod print # # @title "Prints an Object" # # \description{ # For all objects of class @see "Object", this method will print the # value of \code{as.character()} of the object. Note that this function is # not called if the argument is not an object of class @Object. # } # # @synopsis # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @see "base::print.default" # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("print", "Object", function(x, ...) { print(as.character(x)) }) # print() ########################################################################/** # @RdocMethod attachLocally # # @title "Attaches an Object locally to an environment" # # @synopsis # # \description{ # @get "title". By default, the fields of the Object are attached to # the parent frame, that is, the calling environment. # } # # \arguments{ # \item{private}{If @TRUE, private fields are included, otherwise not. # This is only effective if \code{fields==NULL}.} # \item{fields}{A @character @vector specifying elements to be copied. # If @NULL, all elements are considered.} # \item{excludeFields}{A @character @vector specifying elements not to # be copied. This has higher priority than \code{fields}.} # \item{overwrite}{If @FALSE, fields that already exists will not be # copied.} # \item{envir}{The @environment where fields are copied to.} # \item{...}{Not used.} # } # # \value{ # Returns (invisibly) a @character @vector of the fields copied. # } # # @examples "../incl/attachLocally.Object.Rex" # # @author # # \seealso{ # @seemethod attach # @seeclass # } # # @keyword "utilities" # @keyword "programming" #*/######################################################################### setMethodS3("attachLocally", "Object", function(this, private=FALSE, fields=NULL, excludeFields=NULL, overwrite=TRUE, envir=parent.frame(), ...) { if (is.null(fields)) { fields <- getFields(this, private=private) } fields <- setdiff(fields, excludeFields) attachedFields <- c() for (field in fields) { if (overwrite || !hasField(this, field)) { assign(field, this[[field]], envir=envir) attachedFields <- c(attachedFields, field) } } invisible(attachedFields) }) ###########################################################################/** # @RdocMethod attach # # @title "Attaches an Object to the R search path" # # \description{ # Attach the members of an Object to the \R search path. # # If trying to attach the same Object twice without detaching it in between, # a @warning will be generated and nothing will be done. # } # # @synopsis # # \arguments{ # \item{private}{If @TRUE, private fields will also be attached, # otherwise not.} # \item{pos}{The position at in search path where the Object should be # inserted.} # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the @Object was attached, otherwise @FALSE. # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seemethod "detach" and @see "base::attach", @see "base::detach". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("attach", "Object", function(this, private=FALSE, pos=2, ...) { # To please R CMD check attachX <- base::attach attachName <- as.character.Object(this) if (is.element(attachName, search())) { warning(paste("Object is already attached:", attachName)) return(invisible(FALSE)) } envir <- attr(this, ".env") attachX(list(), name=attachName, pos=pos) members <- ls(envir=envir, all.names=private) for (member in members) { assign(member, get(member, envir=envir), pos=pos) } return(invisible(TRUE)) }) # attach() ###########################################################################/** # @RdocMethod detach # # @title "Detach an Object from the R search path" # # \description{ # Detach, from the \R search path, an Object that has previously been # attached. If the Object was not attached, a @warning will be generated # and nothing will be done. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the Object was detached, otherwise @FALSE. # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seemethod "attach" and @see "base::attach", @see "base::detach". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("detach", "Object", function(this, ...) { attachName <- as.character.Object(this) if (!is.element(attachName, search())) { warning(paste("Object is not attached:", attachName)) return(invisible(FALSE)) } pos <- which(search() == attachName) if (length(pos) == 1L) detach(pos=pos) return(invisible(TRUE)) }) # detach() ###########################################################################/** # @RdocMethod save # # @title "Saves an Object to a file or a connection" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{file}{Filename or @connection to which the Object should be saved. # If @NULL, the Object will be save to a file named # "\{class name\}.\{memory location\}.RData", e.g. "Object.26979608.RData".} # \item{path}{The path where the file should be saved.} # \item{compress}{If @TRUE, the file is compressed to, otherwise not.} # \item{...}{Other arguments accepted by \code{save()} in the base package.} # \item{safe}{If @TRUE and \code{file} is a file, then, in order to lower # the risk for incomplete files, the object is first written to a # temporary file, which is then renamed to the final name.} # } # # \value{ # Returns nothing. # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seemethod "load" and @see "base::save", @see "base::load". # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{IO} #*/########################################################################### setMethodS3("save", "Object", function(this, file=NULL, path=NULL, compress=TRUE, ..., safe=TRUE) { if (is.null(file)) { file <- sprintf("%s.%d.RData", class(this)[1], getInternalAddress(this, format="numeric")) } # Saving to a file? saveToFile <- (!inherits(file, "connection")) if (saveToFile) { if (!is.null(path) && path != "") { # 1. Remove any '/' or '\' at the end of the path string. path <- gsub("[/\\]*$", "", path) # 2. Add a '/' to the end. if (regexpr("/$", path) == -1) path <- paste(path, "/", sep="") # 3. Paste the path and the file together. file <- as.character(file) file <- paste(path, file, sep="") } } # Write to a temporary file? if (safe && saveToFile) { # Final pathname pathname <- file # Temporary pathname pathnameT <- sprintf("%s.tmp", pathname) if (file.exists(pathnameT)) { throw("Cannot save to file. Temporary file already exists: ", pathnameT) } # Write to a temporary file file <- pathnameT on.exit({ if (!is.null(pathnameT) && file.exists(pathnameT)) { file.remove(pathnameT) } }, add=TRUE) } # For some unknown reason is save.default() adding the variables # 'exp', 'object', 'row' and 'value' to environment of this object. # /HB 031020 saveLoadReference <- this res <- base::save(saveLoadReference, file=file, ..., compress=compress) # Rename temporary file? if (safe && saveToFile) { file.rename(pathnameT, pathname) if (!file.exists(pathname) || file.exists(pathnameT)) { throw("Failed to rename temporary file: ", pathnameT, " -> ", pathname) } pathnameT <- NULL file <- pathname } invisible(res) }) # save() ###########################################################################/** # @RdocMethod load # # @title "Static method to load an Object from a file or a connection" # # \description{ # @get "title", which previously have been saved using \code{save()} of # class Object. # } # # @synopsis # # \arguments{ # \item{file}{Filename or @connection from where to read the Object.} # \item{path}{The path where the file exists.} # \item{...}{Not used.} # } # # \value{ # Returns a reference to the loaded Object. # } # # \details{ # Please note that no constructors are called when an Object is loaded # and neither is any static class code called. # } # # \section{Type control}{ # Typically this static method is called as \code{$load(...)} # where \code{} is any Object class. When an Object has been # loaded, it is verified that it inherits from \code{}. If it # does not, an exception is thrown. Thus, \code{Object$load(...)} will # load any Object, but \code{MyClass$load(...)} will only load an Object # that inherits from MyClass. If loaded object is not of correct class, # an exception is thrown. # } # # \section{Troubleshooting}{ # Due to a bug, likely in \R itself, one can not specify the \code{file} # argument by its name, i.e. \code{Object$load(file="foo.RData")} will # not work, but \code{Object$load("foo.RData")} work just fine. # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seemethod "save" and # @see "base::save", @see "base::load". # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{IO} #*/########################################################################### setMethodS3("load", "Object", function(static, file, path=NULL, ...) { if (!inherits(file, "connection")) { if (!is.null(path) && path != "") { # 1. Remove any '/' or '\' at the end of the path string. path <- gsub("[/\\]*$", "", path) # 2. Add a '/' to the end. if (regexpr("/$", path) == -1) path <- paste(path, "/", sep="") # 3. Paste the path and the file together. file <- as.character(file) file <- paste(path, file, sep="") } } # load.default() recognized gzip'ed files too. saveLoadReference <- NULL; # To please R CMD check R v2.6.0 vars <- load.default(file=file) if (!is.element("saveLoadReference", vars)) throw("The file does not contain an R.oo Object: ", file) object <- saveLoadReference # Assert that the loaded object inherits from the same class as the # static object used to call this method. if (!inherits(object, class(static)[1])) { throw("Loaded an Object from file, but it does not inherit from ", class(static)[1], " as expected: ", paste(class(object), collapse=", ")) } object }, static=TRUE) # load() ###########################################################################/** # @RdocMethod objectSize # # @title "Gets the size of the Object in bytes" # # \description{ # @get "title" by summing the sizes of all its # members. For this reason, the size of memory the Object actually # allocates might vary slightly. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an @integer specifying the size of the object in number of bytes. # } # # \examples{ # obj <- Object() # obj$x <- 1:100 # obj$y <- 100:1 # objectSize(obj) # 856 # } # # @author # # \seealso{ # To clear fields that are declared \code{cached}, # see @seemethod "clearCache". # @see "utils::object.size". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("objectSize", "Object", function(this, ...) { envir <- attr(this, ".env") members <- ls(envir=envir, all.names=TRUE) totalSize <- 0 for (member in members) { size <- eval(substitute(object.size(member), list(member=as.name(member))), envir=envir) totalSize <- totalSize + size } totalSize }) # objectSize() ###########################################################################/** # @RdocMethod getStaticInstance # # @title "Gets the static instance of this objects class" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a reference to an @Object. # } # # \examples{ # ex <- Exception("Oops!") # obj <- getStaticInstance(ex) # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("getStaticInstance", "Object", function(this, ...) { className <- class(this)[1L] # WAS: clazz <- get(className) # (a) Search namespace of package specified by internal field # '...package' of the Object environment. This field is # set by the constructor. Since it was introduced in # R.oo v1.14.0, it is not guaranteed to exist. envir <- getEnvironment(this) package <- envir$...package if (!is.null(package)) { ## As long as package supports R (< 2.14.0) if (!exists("requireNamespace", envir=baseenv(), inherits=TRUE)) { requireNamespace <- function(package, quietly=TRUE, ...) { tryCatch({ suppressPackageStartupMessages({ loadNamespace(package, ...) }) TRUE }, error = function(ex) FALSE) } } # Check if namespace can be retrieved. This may not possible if # for instance an Object is loaded from disk and the package name # has changed since it was last saved. if (requireNamespace(package, quietly=TRUE)) { ns <- getNamespace(package) clazz <- .getClassByName(className, where="ns", envir=ns, mustExist=FALSE) if (!is.null(clazz)) { static <- getStaticInstance(clazz) return(static) } } } # (b) Search all loaded namespaces clazz <- .getClassByName(className, where=c("ns*", "search"), mustExist=FALSE) if (!is.null(clazz)) { static <- getStaticInstance(clazz) return(static) } # (c) Search parent environment clazz <- .getClassByName(className, where="ns", envir=parent.frame(2L), mustExist=FALSE) if (!is.null(clazz)) { static <- getStaticInstance(clazz) return(static) } stop("Cannot get static instance. Failed to locate Class object for class '", className, "'.") }, protected=TRUE) # getStaticInstance() ###########################################################################/** # @RdocMethod getFields # @aliasmethod names # # @title "Returns the field names of an Object" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{private}{If @TRUE, private fields will also be returned, # otherwise only public fields are returned.} # \item{...}{Not used.} # } # # \value{ # Returns a @character @vector of field names. # } # # \examples{ # obj <- Object() # obj$x <- 1:100 # obj$y <- 100:1 # getFields(obj) # # \dontrun{ # gives: # # [1] "x" "y" # } # } # # @author # # \seealso{ # To check if a field exists or not, see @seemethod "hasField". # For more extensive information about the fields in an Object see # @seemethod "ll". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("getFields", "Object", function(this, private=FALSE, ...) { envir <- attr(this, ".env") ls(envir=envir, all.names=private) }) # getFields() setMethodS3("names", "Object", function(x, ...) { getFields(x, ...) }, private=TRUE) # names() ###########################################################################/** # @RdocMethod hasField # # @title "Checks if a field exists or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{field}{@vector of fields to be checked if they exists or not.} # \item{...}{Not used.} # } # # \value{ # Returns a @logical @vector indicating for each field if it exists or not. # } # # \examples{ # obj <- Object() # obj$x <- 1:100 # obj$y <- 100:1 # hasField(obj, c("x", "a", "b", "y")) # # \dontrun{ # gives: # # [1] TRUE FALSE FALSE TRUE # } # } # # @author # # \seealso{ # To get the fields of an Object, see @seemethod "getFields". # For more extensive information about the fields in an Object see # @seemethod "ll". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("hasField", "Object", function(this, field, ...) { !is.na(match(field, getFields(this, private=TRUE))) }) # hasField() ###########################################################################/** # @RdocMethod ll # # @title "Generates a list of informative properties of all members of an Object" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Any arguments accepted by the underlying function \code{ll()}.} # } # # \value{ # Returns a @data.frame containing information about all the members. # } # # \examples{ # obj <- Object() # obj$x <- 1:100 # obj$y <- 100:1 # ll(obj) # # \dontrun{ # gives: # # member data.class dimension objectSize # 1 x numeric 100 424 # 2 y numeric 100 424 # } # } # # @author # # \seealso{ # @see "ll.default". # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("ll", "Object", function(this, ...) { ll(..., envir=attr(this, ".env")) }) # ll() ###########################################################################/** # @RdocMethod staticCode # # @title "Method that will be call each time a new instance of a class is created" # # \description{ # @get "title". # # By extending this method it is possible to have static code that is called # each time a new instance of a class is created. # } # # @synopsis # # \arguments{ # \item{static}{The static instance of this class.} # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # \details{ # The method \code{extend()} in the Object class will call this method just # before returning and it will pass the static instance of the class as a # reference. Note that method should never be called explicitly. # # Any value returned by this method will be ignored. # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("staticCode", "Object", function(static, ...) { # Note that this code will never be called when a "pure" # Object is created, but for instances of all other # class staticCode() will be called. }, private=TRUE) ###########################################################################/** # @RdocMethod extend # # @title "Extends another class" # # \description{ # via a mechanism known as "parasitic inheritance". # Simply speaking this method "extends another class". What is actually # happening is that it creates an instance of class name \code{...className}, # by taking another Object instance and add \code{...className} to the class # list and also add all the named values in @... as fields to the # new instance. # # The method should be used by the constructor of a class and nowhere else. # } # # @synopsis # # \arguments{ # \item{...className}{The name of new class.} # \item{...}{Named values representing the fields of the new instance.} # \item{...fields}{An optional named @list of fields. This makes it possible # to specify a set of fields using a @list object.} # \item{...envir}{An @environment.} # \item{...finalize}{ # A @logical controlling whether method @seemethod "finalize" should # be called on the @see Object when it is garbage collected or not. # If @TRUE, it will be called. If @FALSE, it will not be called. # If @NA, it will be called according to argument \code{finalize} # of the @see Object constructor. # } # } # # \value{ # Returns an Object of class \code{className}. # } # # \details{ # The reason for the strange name of argument \code{"...className"} is that # if one tries to set a field with a name that is a prefix of the name of # this arguments and one at the same time does not specify the name of this # argument one would run into strange errors. For instance, try # \code{extend(Object(), "MyClass", ...c=0)}. # } # # \section{Field modifiers}{ # It is possible to specify modifiers to some of the fields. Currently it # is only the \code{cached} modifier that is recognized. A field that is # cached will be assigned @NULL when @seemethod "clearCache" is called. # To specify a modifier, append a comma separated list of modifiers followed # by a colon, e.g. "cached:foo". # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### if (is.element("R.oo", search())) { rm(list="extend", pos="R.oo"); # To avoid warning about renaming existing extend() } setMethodS3("extend", "Object", function(this, ...className, ..., ...fields=NULL, ...envir=parent.frame(), ...finalize=NA) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - parseModifiers <- function(args, ...) { names <- names(args) pattern <- "([abcdefghijklmnopqrstuvwxyz ]*):(.*)$" modifiers <- rep("", length(names)) idx <- grep(pattern, names) modifiers[idx] <- gsub(pattern, "\\1", names[idx]) modifiers <- strsplit(modifiers, split=" ") modifiers <- lapply(modifiers, gsub, pattern=" *", replacement="") # Get the real names names[idx] <- gsub("[abcdefghijklmnopqrstuvwxyz ]*:", "", names[idx]) names(args) <- names # Set modifier attributes mods <- list() for (type in c("cached")) { mods[[type]] <- names[modifiers == type] } attr(args, "modifiers") <- mods args } # parseModifiers() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Main # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # The environment of 'this' Object this.env <- attr(this, ".env") fields <- c(list(...), ...fields) # Identify and renamed fields that have modifiers in their names fields <- parseModifiers(fields) names <- names(fields) for (ii in seq_along(fields)) { name <- names[ii] if (is.null(name) || nchar(name) == 0) { callNames <- names(sys.call()) callNames <- callNames[nchar(callNames) > 0] matchNames <- paste("^", callNames, sep="") for (jj in seq_along(matchNames)) { if (regexpr(matchNames[jj], "...className") != -1) { className <- sys.call()[[3]] throw("Could not set field of class (probably called ", className, ") because the field name is a prefix to the argument name ", "\"...className\": ", callNames[jj]) } } # for (jj ...) throw("Missing name of field #", ii, " in class definition: ", ...className) } assign(name, fields[[ii]], envir=this.env) } # for (ii ...) # Set class class(this) <- unique(c(...className, class(this))) # Should the Object be finalized? finalize <- TRUE if (exists("...finalize", envir=this.env, inherits=FALSE)) { finalize <- get("...finalize", finalize, envir=this.env, inherits=FALSE) finalize <- isTRUE(finalize) } # Override by extend(..., ...finalize=TRUE/FALSE)? if (!is.na(...finalize)) finalize <- isTRUE(...finalize) if (finalize) { # Note, we have to re-register the finalizer here and not in Object(), # because here the reference variable 'this' will have the correct # class attribute, which it does not in Object(). finalizer <- .makeObjectFinalizer(this, reloadRoo=TRUE) onexit <- getOption("R.oo::Object/finalizeOnExit", FALSE) reg.finalizer(this.env, finalizer, onexit=onexit) } # extend(..., ...finalize=FALSE) should always remove any # previously registered finalizers. if (!is.na(...finalize) && !isTRUE(...finalize)) { # Unregister finalizer (by registering a dummy one) reg.finalizer(this.env, f=function(...) {}) } # Finally, create the static instance? if (!is.element("Class", ...className)) { static <- getStaticInstance(this, envir=...envir) if (!is.null(static)) { staticCode(static) } } # Record field modifiers # Get the field modifiers (always a list) modifiers <- attr(fields, "modifiers") # Append already existing modifiers? if (exists("...modifiers", envir=this.env, inherits=FALSE)) { modifiersT <- get("...modifiers", envir=this.env, inherits=FALSE) for (key in names(modifiersT)) { modifiers[[key]] <- c(modifiers[[key]], modifiersT[[key]]) } } # Drop duplicated modifier entries and sort modifiers <- lapply(modifiers, FUN=function(mods) { sort(unique(mods)) }) # Record modifiers assign("...modifiers", modifiers, envir=this.env) this }) # extend() ###########################################################################/** # @RdocMethod $ # @aliasmethod [[ # # @title "Makes the fields and methods of an Object accessible via the $ and the [[ operator" # # \description{ # Makes the fields and methods of an Object accessible via the \code{$} # operator. This method is never called explicitly, but through an indirect # usage of the \code{$} operator, e.g. \code{obj$name} or # \code{obj$getValue()}. # # 1) This method will first search for a \code{get()} method, e.g. if # name has the value \code{"age"}, a \code{getAge()} will be looked for. # If such a method exists it will be called with the Object as the first # and only argument, e.g. \code{getAge(this)}. # # A \code{get()} is only looked for if \code{} is not a private # field. A private field is a name \emph{beginning} with a \code{.} # (period). The rational for this naming convention is to be consistent # with how @see "base::ls" works, which will not list such members # by default. # # 2) If no such method exists, first then, this method will look a field in # the Object can has the name \code{name}. # # 3) If such neither exists, a method with name \code{name} will be # searched for and returned. # # 4) Otherwise, a static field will be looked for. # # 5) If no fields or methods are found at all, @NULL is returned. # } # # \usage{ # \method{$}{Object}(this, name) # \method{[[}{Object}(this, name, exact=TRUE) # } # # \arguments{ # \item{name}{The name of the field or method to be accessed.} # } # # \value{ # Returns the value of a field or a method (@function). # If no such field or method exists, @NULL is returned. # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("$", "Object", function(this, name) { .subset2Internal(this, name=name, exact=TRUE) }) setMethodS3("[[", "Object", function(this, name, exact=TRUE) { .subset2Internal(this, name=name, exact=exact) }) setMethodS3(".subset2Internal", "Object", function(this, name, exact=TRUE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - .getStaticInstance <- function(this, static=NULL) { if (!is.null(static)) return(static) getStaticInstance(this) } # .getStaticInstance() memberAccessorOrder <- attr(this, ".memberAccessorOrder") if (is.null(memberAccessorOrder)) { memberAccessorOrder <- c(1L, 2L, 3L, 4L, 5L) } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # (a) Check if there is a cache lookup available. # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - envir <- attr(this, ".env") cacheName <- paste("...$.lookup", name, sep=".") if (!is.null(envir) && exists(cacheName, envir=envir, inherits=FALSE)) { envirCache <- envir lookup <- get(cacheName, envir=envirCache, inherits=FALSE) if (identical(attr(lookup, "memberAccessorOrder"), memberAccessorOrder)) { if (lookup == 1L) { # Still to be figured out how to do! /HB 2003-01-18 # memberAccessorOrder <- attr(lookup, "possibilities") } else if (lookup == 2L) { envir2 <- envir return( get(name, envir=envir2) ) } else if (lookup == 3L) { return( attr(this, name) ) } else if (lookup == 4L) { fcn <- attr(lookup, "fcn") if (!is.null(fcn)) { return(fcn) } # Backward compatibility for Object:s saved with R.oo < 1.10.0, # which used deprecated attr(lookup, "method"). The below code # will NULL the 'lookup' and force an updated. } else if (lookup == 5L) { return( get(name, envir=attr(lookup, "static.envir")) ) } } # if (identical(attr(lookup, ...))) lookup <- NULL } else { lookup <- NULL } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # (b) Otherwise search # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static <- NULL for (memberAccessor in memberAccessorOrder) { if (memberAccessor == 1L) { if (is.null(attr(this, "disableGetMethods"))) { firstChar <- substr(name, start=1L, stop=1L) # Do not try to access private fields using a get() method, # because such a functionality means that the user *expects* that # there actually is a field called '.', which he or she # should not do since it is a private field! # Is it a private field? if (!identical(firstChar, ".")) { # Field names can not contain spaces... if (regexpr(" ", name) == -1L) { # 1. Is there a get() method? capitalizedName <- name substr(capitalizedName, start=1L, stop=1L) <- toupper(firstChar) getMethodNames <- paste("get", capitalizedName, ".", class(this), sep="") static <- .getStaticInstance(this, static=static) envirS <- environment(static) for (getMethodName in getMethodNames) { method <- .getS3Method(getMethodName, envir=envirS, mustExist=FALSE) if (!is.null(method)) { ref <- this attr(ref, "disableGetMethods") <- TRUE # For caching purposes, if the field is trying to be # accessed, we do not want to call get() again! If # is not a virtual field, the it has to be a real field, an # attribute, a static field etc. We do not know in advance, # but we know it is nothing we already tried, hence lookup <- memberAccessor attr(lookup, "memberAccessorOrder") <- memberAccessorOrder pos <- which(memberAccessorOrder == memberAccessor) attr(lookup, "possibilities") <- memberAccessorOrder[-(1:pos)] assign(cacheName, lookup, envir=envir) return(method(ref)) } } # for (...) } # if ("no space in the name") } # if ("is private field") } # if (is.null(attr(this, "disableGetMethods"))) } else if (memberAccessor == 2L) { # 2. Is it a field? # For static method calls, e.g. Object$load, 'this' has no # environment assigned and therefore, for now, no static # fields. if (!is.null(envir) && exists(name, envir=envir, inherits=FALSE)) { lookup <- memberAccessor attr(lookup, "memberAccessorOrder") <- memberAccessorOrder assign(cacheName, lookup, envir=envir) envirStatic <- envir return(get(name, envir=envirStatic, inherits=FALSE)) } } else if (memberAccessor == 3L) { # 3. Is it an attribute field (slot)? if (is.element(name, names(attributes(this)))) { lookup <- memberAccessor attr(lookup, "memberAccessorOrder") <- memberAccessorOrder assign(cacheName, lookup, envir=envir) return(attr(this, name)) } } else if (memberAccessor == 4L) { # 4. Is it a static S3 method? static <- .getStaticInstance(this, static=static) envirS <- environment(static) methodNames <- paste(name, class(this), sep=".") for (methodName in methodNames) { method <- .getS3Method(methodName, envir=envirS, mustExist=FALSE) if (!is.null(method)) { # Using explicit UseMethod() code code <- sprintf("function(...) \"%s\"(this, ...)", name) fcn <- eval(base::parse(text=code)) ## environment(fcn) <- environment(method) lookup <- memberAccessor attr(lookup, "memberAccessorOrder") <- memberAccessorOrder attr(lookup, "fcn") <- fcn assign(cacheName, lookup, envir=envir) return(fcn) } } } else if (memberAccessor == 5L) { # 5. Finally, if nothing is found, it might be that it is a static field static <- .getStaticInstance(this, static=static) static.envir <- attr(static, ".env") # For static method calls, e.g. Object$load, 'this' has no # environment assigned and therefore, for now, no static # fields. if (!is.null(static.envir) && exists(name, envir=static.envir, inherits=FALSE)) { lookup <- memberAccessor attr(lookup, "memberAccessorOrder") <- memberAccessorOrder attr(lookup, "static.envir") <- static.envir assign(cacheName, lookup, envir=envir) return(get(name, envir=static.envir, inherits=FALSE)) } } } # for (memberAccessor in memberAccessorOrder) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # (c) If not found, return NULL. # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - lookup <- -1L attr(lookup, "memberAccessorOrder") <- memberAccessorOrder assign(cacheName, lookup, envir=envir) NULL }, private=TRUE) # .subset2Internal() ###########################################################################/** # @RdocMethod $<- # @aliasmethod [[<- # # @title "Makes the fields and methods of an Object assignable via the $<- and the [[<- operator" # # \description{ # Makes the fields and methods of an Object assignable via the \code{$<-} # operator. This method is never called explicitly, but through an indirect # usage of the \code{$<-} operator, e.g. \code{obj$name <- "foo"}. # # 1) This method will first search for a \code{set()} method, e.g. if # name has the value \code{"age"}, a \code{setAge()} will be looked for. # If such a method exists it will be called with the Object as the first # argument and \code{value} as the second, e.g. \code{setAge(this, value)}. # # A \code{set()} is only looked for if \code{} is a non-private # field. A private field is a name \emph{beginning} with a \code{.} (period). # The rational for this naming convention is to be consistent # with how @see "base::ls" works, which will not list such members # by default. # Moreover, excluding private fields for the search of a \code{set()} # will decrease the overhead for such field. # # 2) If no such method exists the \code{value} will be assigned to an # existing field named \code{name}, if such exists. # # 3) Otherwise, the value will be assigned to a static field, # if such exists. # # 4) In all other case, the value is assigned to a new field. # # Because any \code{set()} is called first, it is possible to # \emph{encapsulate} (hide away) fields with certain names or to put # restrictions to what values can be assigned to them. # } # # \usage{ # \method{$}{Object}(this, name) <- value # \method{[[}{Object}(this, name) <- value # } # # \arguments{ # \item{name}{The name of the \code{set()} method or the name of # the field to be assigned the new value.} # \item{value}{The value to be assigned.} # } # # \value{ # Returns itself, i.e. \code{this}, as all \code{$<-} methods must do. # } # # \examples{\dontrun{For a complete example see help(Object).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("$<-", "Object", function(this, name, value) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - .getStaticInstance <- function(this, static=NULL) { if (!is.null(static)) return(static) getStaticInstance(this) } # .getStaticInstance() memberAccessorOrder <- attr(this, ".memberAccessorOrder") if (is.null(memberAccessorOrder)) { memberAccessorOrder <- c(1,2,3,4,5) } static <- NULL for (memberAccessor in memberAccessorOrder) { if (memberAccessor == 1) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Search for a set() method # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if (is.null(attr(this, "disableSetMethods"))) { firstChar <- substr(name, 1,1) # Do not try to access private fields using a set() method, # because such a functionality means that the user *expects* that # there actually is a field called '.', which he or she # should not do since it is a private field! # Is it a private field? if (!identical(firstChar, ".")) { # Field names can not contain spaces... if (regexpr(" ", name) == -1) { # 1. Is it a set() method? capitalizedName <- name substr(capitalizedName,1,1) <- toupper(firstChar) setMethodNames <- paste("set", capitalizedName, ".", class(this), sep="") static <- .getStaticInstance(this, static=static) envirS <- environment(static) for (setMethodName in setMethodNames) { method <- .getS3Method(setMethodName, envir=envirS, mustExist=FALSE) if (!is.null(method)) { ref <- this attr(ref, "disableSetMethods") <- TRUE method(ref, value) return(invisible(this)) } } } # if ("no space in the name") } # if ("is private field") } # if (is.null(attr(this, "disableSetMethods"))) } else if (memberAccessor == 2) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Search for a field # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # 2. If there exists a field, assign the value to that field. envir <- attr(this, ".env") if (exists(name, envir=envir, inherits=FALSE)) { assign(name, value, envir=envir) return(invisible(this)) } } else if (memberAccessor == 3) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Search for a attribute. /Should this be removed? # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # 3. If there exists an attribute field, assign the value to that field. if (is.element(name, names(attributes(this)))) { attr(this, name) <- value return(invisible(this)) } } else if (memberAccessor == 4) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Search for a static field # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # 4. If not, it might be that it is a static field static <- .getStaticInstance(this, static=static) static.envir <- attr(static, ".env") # For static method calls, e.g. Object$load, 'this' has no # environment assigned and therefore, for now, no static # fields. if (!is.null(static.envir) && exists(name, envir=static.envir, inherits=FALSE)) { assign(name, value, envir=static.envir) return(invisible(this)) } } else if (memberAccessor == 5) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Create a new field # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # 5. Otherwise, assign the value to a new field. assign(name, value, envir=envir) return(invisible(this)) } } # for (memberAccessor in memberAccessorOrder) invisible(this) }) # $<-() setMethodS3("[[<-", "Object", function(this, name, value) { ## (1) R.oo (>= 0.47 && <= 1.21.0) [2002-10-23 -- 2016-10-30]: ## ## Using UseMethod("$<-") will fail in R (>= 3.6.0) with: ## _R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_=true ## _R_S3_METHOD_LOOKUP_USE_TOPENV_AS_DEFENV_=true ## Exactly like that, both need to be TRUE. ## ## Example from aroma.cn R CMD checks: ## *** S3 method lookup problem *** ## [1] "$<-" ## ## ## Error in UseMethod("$<-") : ## no applicable method for '$<-' applied to an object of ## class "c('CopyNumberRegions', 'Object')" ## Calls: +.CopyNumberRegions -> [[<- -> [[<-.Object ## Execution halted ## ## ## (2) R.oo (<= 0.46) [prior to 2002-10-14]: ## ## `$<-`(this, name, value) ## ## This approach does not work, because the `name` argument will ## carry the value "name", not the value of argument 'name'. ## TESTS: tests/Object.R and tests/BasicObject.R test for this. ## ## ## (3) R.oo (>= 1.22.0) [since 2018-04-21]: ## ## Using do.call() works around the problem in (2). do.call(`$<-`, args = list(this, name, value)) }) # "[[<-"() ###########################################################################/** # @RdocMethod isReferable # # @title "Checks if the object is referable or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @logical value, which by default is @TRUE for all @Object's. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("isReferable", "Object", function(this, ...) { TRUE }, private=TRUE) # isReferable() ###########################################################################/** # @RdocMethod novirtual # # @title "Returns a reference to the same Object with virtual fields turned off" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an @Object. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("novirtual", "Object", function(this, ...) { attr(this, "disableGetMethods") <- TRUE attr(this, "disableSetMethods") <- TRUE this }, private=TRUE) setMethodS3("callSuperMethodS3", "default", function(this, methodName, ..., nbrOfClassesAbove=1) { if (nbrOfClassesAbove < 0) { throw("Argument 'nbrOfClassesAbove' is negative.") } classes <- class(this) nbrOfClassesAbove <- min(nbrOfClassesAbove, length(classes)) classes <- classes[-seq_len(nbrOfClassesAbove)] if (length(classes) == 0) { methods <- methodName } else { methods <- c(paste(methodName, classes, sep="."), methodName) } availableMethods <- c(methods(methodName), methodName) for (method in methods) { if (is.element(method, availableMethods)) { # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (exists(method, mode="function")) { return(do.call(method, args=list(this, ...))) } } } throw("No applicable methods '", methodName, "' available among the superclasses: ", classes) }, private=TRUE) ###########################################################################/** # @RdocMethod newInstance # # @title "Creates a new instance of the same class as this object" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Arguments passed to the constructor of the corresponding # @see "Object" class.} # } # # \value{ # Returns a reference to an instance of @see "Object" or a subclass thereof. # } # # @author # # \seealso{ # @see "newInstance.Class". # @see "newInstance.BasicObject". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("newInstance", "Object", function(this, ...) { # Creates a new instance of the same class clazz <- Class$forName(class(this)[1]) newInstance(clazz, ...) }, private=TRUE) ###########################################################################/** # @RdocMethod getEnvironment # # @title "Gets the environment of this object" # # \description{ # @get "title". # This is the environment where the members of the Object are stored. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an @environment. # } # # \examples{ # ll(R.oo) # ll(envir=getEnvironment(R.oo)) # } # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getEnvironment", "Object", function(fun, ...) { # To please R CMD check this <- fun attr(this, ".env") }, protected=TRUE) ###########################################################################/** # @RdocMethod clearLookupCache # # @title "Clear internal fields used for faster lookup" # # \description{ # @get "title" by removing these fields. # This method is called whenever @seemethod "clearCache" is called on the # object. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns itself (invisible). # } # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("clearLookupCache", "Object", function(this, ...) { env <- this$.env names <- ls(envir=env, pattern="^...\\$.lookup", all.names=TRUE) rm(list=names, envir=env) invisible(this) }, protected=TRUE) ###########################################################################/** # @RdocMethod clearCache # # @title "Clear fields that are defined to have cached values" # # \description{ # @get "title" by assigning @NULL to these fields. # } # # @synopsis # # \arguments{ # \item{recursive}{If @TRUE, the same method is called also on all # fields that are @see "Object":s. Circular dependencies can exists.} # \item{gc}{If @TRUE, the garbage collector is called, otherwise not.} # \item{...}{Not used.} # } # # \value{ # Returns itself (invisible). # } # # @examples "../incl/gc.clearCache.Rex" # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("clearCache", "Object", function(this, recursive=TRUE, gc=FALSE, ...) { env <- attr(this, ".env") fields <- getFieldModifier(this, "cached") for (field in fields) { # Or remove them? assign(field, NULL, envir=env) } this <- clearLookupCache(this) if (recursive) { # Make sure that this object has not already been called # earlier in the same clear-cache request. if (!exists("...clearCache", envir=env, inherits=FALSE)) { assign("...clearCache", TRUE, envir=env) on.exit(rm(list="...clearCache", envir=env)) fields <- getFields(this, private=TRUE) for (field in fields) { object <- get(field, envir=env, inherits=FALSE) if (inherits(object, "Object")) { clearCache(object, recursive=TRUE, gc=FALSE) } } } } # Run the garbage collector? if (gc) base::gc() invisible(this) }) ###########################################################################/** # @RdocMethod getFieldModifiers # @aliasmethod getFieldModifier # # @title "Gets all types of field modifiers" # # \description{ # @get "title", if any. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a named @list. # } # # @author # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getFieldModifiers", "Object", function(this, ...) { env <- attr(this, ".env") if (!exists("...modifiers", envir=env, inherits=FALSE)) { return(list()) } get("...modifiers", envir=env, inherits=FALSE) }, protected=TRUE) setMethodS3("getFieldModifier", "Object", function(this, name, ...) { getFieldModifiers(this, ...)[[name]] }, protected=TRUE) setMethodS3(".DollarNames", "Object", function(x, pattern="") { ns <- getNamespace("utils") if (exists("findMatches", mode="function", envir=ns)) { findMatches <- get("findMatches", mode="function", envir=ns) } else { findMatches <- function(pattern, values) { grep(pattern, values, value=TRUE) } } findMatches(pattern, names(x)) }, appendVarArgs=FALSE, private=TRUE) R.oo/R/060.Class.R0000644000176200001440000011575614711170612013003 0ustar liggesusers###########################################################################/** # @RdocClass Class # # @title "The Class class describes an Object class" # # \description{ # @classhierarchy # # @get "title". # First of all, this class is most commonly used \emph{internally} and # neither the end user nor the programmer need to no about the class Class. # } # # @synopsis # # \arguments{ # \item{name}{Name of the class.} # \item{constructor}{Constructor (@function) of any Object class.} # } # # \section{Fields and Methods}{ # @allmethods # } # # \details{ # The class Class describes the Object class or one of its subclasses. # All classes and constructors created by \code{setConstructorS3()} will # be of class Class. Its methods provide ways of accessing static fields # and static methods. Its \emph{print()} method will print detailed # information about the class and its fields and methods. # } # # @author # # @keyword programming # @keyword methods #*/########################################################################### setConstructorS3("Class", Class) # Class() ###########################################################################/** # @RdocMethod as.character # # @title "Returns a short string describing the class" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # print(as.character(Object)) # # # gives: "Class Object: no fields, 8 methods (no inherited)" # } # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("as.character", "Class", function(x, ...) { # To please R CMD check this <- x if (is.null(getStaticInstance(this))) return(as.character.Object(this)) fields <- getFields(this) nbrOfFields <- length(fields) methods <- getMethods(this, unique=TRUE) count <- unlist(lapply(methods, FUN=length)) names(count) <- names(methods) nbrOfMethods <- sum(count) count <- count[-1L] s <- paste(class(this)[1L], " ", getName(this), " has ", nbrOfFields, " field" , if (nbrOfFields != 1L) "s", " and ", nbrOfMethods, " method", if (nbrOfMethods != 1L) "s", sep="") if (length(count) > 0L) { isAre <- c("is", "are")[1L + (count != 1L)] isAre[1L] <- paste(isAre[1L], "implemented in") isAre[-1L] <- "in" s <- paste(sep="", s, " of which ", paste(paste(count, isAre, names(count)), collapse=", "), ".") } else { s <- paste(s, ".", sep="") } s }) # as.character() ###########################################################################/** # @RdocMethod print # # @title "Prints detailed information about the class and its fields and methods" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Arguments passed to @seemethod "getDetails".} # } # # \value{ # Returns nothing. # } # # \examples{ # print(Object) # } # # @author # # \seealso{ # @seemethod "getDetails" # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("print", "Class", function(x, ...) { cat(getDetails(x, ...)) }) # print() ###########################################################################/** # @RdocMethod getName # # @title "Gets the name of the class" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # print(getName(Object)) # "Object" # print(getName(Class)) # "Class" # } # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getName", "Class", function(this, ...) { static <- getStaticInstance(this) class(static)[1L] }) # getName() ###########################################################################/** # @RdocMethod getSuperclasses # # @title "Gets the super classes of this class" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @vector of @character strings. # } # # \examples{ # print(getSuperclasses(RccViolationException)) # \dontrun{ # returns # [1] "Exception" "try-error" "Object" # } # } # # @author # # \seealso{ # @see "base::class". # @seemethod "getKnownSubclasses". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getSuperclasses", "Class", function(this, ...) { class(getStaticInstance(this))[-1L] }) # getSuperclasses() ###########################################################################/** # @RdocMethod getKnownSubclasses # # @title "Gets all subclasses that are currently loaded" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @vector of @character strings. # } # # \examples{ # \dontrun{ # # Due to a bug in R CMD check (R v1.7.1) the MicroarrayData$read() call # # below will call getKnownSubclasses(), which will generate # # "Error in exists(objectName, mode = "function") : # # [2003-07-07 23:32:41] Exception: F used instead of FALSE" # # Note that the example still work, just not in R CMD check # # print(getKnownSubclasses(Exception)) # } # \dontrun{ # returns # [1] "Exception" "try-error" "Object" # } # } # # @author # # \seealso{ # @seemethod "getSuperclasses". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getKnownSubclasses", "Class", function(this, sort=TRUE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - getKnownSubclassesInEnvironment <- function(name, envir, ...) { # Get all objects objectNames <- ls(envir=envir) # Exclude itself (to avoid recursive calls) objectNames <- setdiff(objectNames, name) # Nothing to do? if (length(objectNames) == 0L) return(NULL) # Keep only functions that are Class objects keep <- suppressWarnings({ sapply(objectNames, FUN=function(objectName) { expr <- substitute({ tryCatch({ is.function(x) && inherits(x, "Class") }, error=function(ex) FALSE) }, list(x=as.name(objectName))) eval(expr, envir=envir) }) }) objectNames <- objectNames[keep] # Nothing to do? if (length(objectNames) == 0L) return(NULL) classes <- NULL for (objectName in objectNames) { clazz <- get(objectName, mode="function", envir=envir, inherits=FALSE) # Get all its super classes... extends <- getSuperclasses(clazz) # Does it extend this class? if (is.element(name, extends)) { classes <- c(classes, getName(clazz)) } } # for (objectName ...) classes } # getKnownSubclassesInEnvironment() name <- getName(this) classes <- c() ## # (a) Search loaded namespaces ## for (ns in loadedNamespaces()) { ## envir <- getNamespace(ns) ## classesT <- getKnownSubclassesInEnvironment(name, envir=envir) ## classes <- c(classes, classesT) ## } # (a) Search attached search paths for (pos in seq_along(search())) { envir <- as.environment(pos) classesT <- getKnownSubclassesInEnvironment(name, envir=envir) classes <- c(classes, classesT) } # Drop duplicates classes <- unique(classes) if (sort && length(classes) > 1L) classes <- sort(classes) classes }) ###########################################################################/** # @RdocMethod newInstance # # @title "Creates a new instance of this class" # # \description{ # @get "title". # Important: It should always be possible to create a new Object by # calling the constructor without arguments. # This method is simply calling the constructor method of the class. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a reference to an @see "Object". # } # # \examples{ # obj <- newInstance(Object, NA) # # # equivalent to # # obj <- Object(NA) # } # # @author # # \seealso{ # @see "newInstance.Object". # @see "newInstance.BasicObject". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("newInstance", "Class", function(this, ...) { this(...) }) # newInstance() ###########################################################################/** # @RdocMethod isAbstract # # @title "Checks if a class is abstract or not" # # \description{ # @get "title". A class is abstract if it has abstract methods. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the class is abstract, otherwise @FALSE. # } # # \examples{ # if (isAbstract(RccViolationException)) # throw("The class RccViolationException should NOT be abstract.") # } # # @author # # \seealso{ # @see "base::class". # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("isAbstract", "Class", function(this, ...) { methods <- getMethods(this) methods <- unlist(methods) methods <- methods[nchar(methods) > 0L] for (method in methods) { mtd <- .getS3Method(method, envir=environment(this)) if (is.element("abstract", attr(mtd, "modifiers"))) return(TRUE) } FALSE }) ###########################################################################/** # @RdocMethod isStatic # # @title "Checks if a class is static or not" # # \description{ # @get "title". A class is static if it has static methods. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the class is static, otherwise @FALSE. # } # # \examples{ # if (!isStatic(RccViolationException)) # throw("RccViolationException should be static because Exception is.") # } # # @author # # \seealso{ # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("isStatic", "Class", function(this, ...) { methods <- getMethods(this) methods <- unlist(methods) methods <- methods[nchar(methods) > 0L] for (method in methods) { mtd <- .getS3Method(method, envir=environment(this)) if (is.element("static", attr(mtd, "modifiers"))) return(TRUE) } FALSE }) ###########################################################################/** # @RdocMethod isPrivate # # @title "Checks if a class is defined private or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the class is private, otherwise @FALSE. # } # # \examples{ # if (isPrivate(RccViolationException)) # throw("The class RccViolationException should NOT be private.") # } # # @author # # \seealso{ # @see "base::class". # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("isPrivate", "Class", function(this, ...) { is.element("private", attr(this, "modifiers")) }) ###########################################################################/** # @RdocMethod isProtected # # @title "Checks if a class is defined protected or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the class is protected, otherwise @FALSE. # } # # \examples{ # if (isProtected(RccViolationException)) # throw("The class RccViolationException should NOT be protected.") # } # # @author # # \seealso{ # @see "base::class". # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("isProtected", "Class", function(this, ...) { is.element("protected", attr(this, "modifiers")) }) ###########################################################################/** # @RdocMethod isPublic # # @title "Checks if a class is defined public or not" # # \description{ # @get "title". A class is public if it is neither private nor protected. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the class is public, otherwise @FALSE. # } # # \examples{ # if (!isPublic(RccViolationException)) # throw("The class RccViolationException should be public.") # } # # @author # # \seealso{ # @see "base::class". # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("isPublic", "Class", function(this, ...) { !isPrivate(this) && !isProtected(this) }) ###########################################################################/** # @RdocMethod isDeprecated # # @title "Checks if a class is deprecated or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the class is deprecated, otherwise @FALSE. # } # # @author # # \seealso{ # @see "base::class". # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("isDeprecated", "Class", function(this, ...) { is.element("deprecated", attr(this, "modifiers")) }) ###########################################################################/** # @RdocMethod forName # # @title "Gets a Class object by a name of a class" # # \description{ # @get "title". If no such class exists and exception is thrown. # } # # @synopsis # # \arguments{ # \item{...}{Optional arguments passed to internal lookup function.} # } # # \value{ # Returns a @see "Class". # } # # \examples{ # print(Class$forName("Exception")) # } # # @author # # \seealso{ # @see "base::class". # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("forName", "Class", function(static, name, ...) { .getClassByName(name, ..., mustExist=TRUE) }, static=TRUE) # forName() ###########################################################################/** # @RdocMethod getPackage # # @title "Gets the package to which the class belongs" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @see "Package". # } # # \examples{ # print(getPackage(Object)) # } # # @author # # \seealso{ # @see "Package". # @see "base::class". # @see "setConstructorS3". # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getPackage", "Class", function(this, ...) { name <- getName(this) pkgName <- NULL # (a) Search name spaces envirLast <- NULL envir <- environment(this) while (!identical(envir, globalenv()) && !identical(envir, envirLast)) { envirLast <- envir if (exists(name, mode="function", envir=envir, inherits=FALSE)) { res <- get(name, mode="function", envir=envir, inherits=FALSE) if (inherits(res, "Class")) { pkgName <- environmentName(envir) pkgName <- gsub("^package:", "", pkgName) return(pkgName) } } # Next envir <- parent.env(envir) } # while (...) # (b) Search attached ("loaded") packages packages <- search() for (pos in seq_along(packages)) { envir <- pos.to.env(pos) if (exists(name, mode="function", envir=envir, inherits=FALSE)) { res <- get(name, mode="function", envir=envir, inherits=FALSE) if (inherits(res, "Class")) { pkgName <- environmentName(envir) pkgName <- gsub("^package:", "", pkgName) return(pkgName) } } } # for (pos ...) NULL }) ###########################################################################/** # @RdocMethod getStaticInstance # # @title "Gets the static instance of this class" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a reference to an @see "Object". # } # # \examples{ # obj <- getStaticInstance(Object) # } # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getStaticInstance", "Class", function(this, ...) { # First, make sure you have a reference to the actual Class object. if (!is.function(this)) { this <- .getClassByName(class(this)[1L], envir=environment(this)) } # If the static instance of this class is missing create one. envir <- attr(this, ".env") static <- get(".staticInstance", envir=envir) if (is.null(static)) { if (!exists(".isCreatingStaticInstance", envir=envir, inherits=FALSE)) { assign(".isCreatingStaticInstance", TRUE, envir=envir, inherits=FALSE) on.exit({ rm(list=".isCreatingStaticInstance", envir=envir) }, add=TRUE) constructor <- this static <- constructor() # Set the environment of the static instance to be the same # as the constructor function, i.e. the Class. environment(static) <- environment(this) assign(".staticInstance", static, envir=envir) } else { # Otherwise, just create a dummy instance in case any code is trying # to access it. static <- Object() # Set the environment of the static instance to be the same # as the constructor function, i.e. the Class. environment(static) <- environment(this) } } else { # BACKWARD PATCH: In case an old static object has been loaded # then it may not have the proper environment set. environment(static) <- environment(this) } static }) # getStaticInstance() ###########################################################################/** # @RdocMethod isBeingCreated # # @title "Checks if a class is currently being initiated initiated" # # \description{ # @get "title". # When extending a class for the first time, which is # typically done in a constructor, a static instance of the class is # created by calling the constructor without parameters. # This method provides a way to detect that second call inside the # constructor. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if a static instance exists, otherwise @FALSE. # } # # @examples "../incl/isBeingCreated.Class.Rex" # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("isBeingCreated", "Class", function(this, ...) { # First, make sure you have a reference to the actual Class object. if (!is.function(this)) { this <- get(class(this)[1L], mode="function") if (!inherits(this, "Class")) throw("Not a Class object: ", class(this)[1L]) } # If the static instance of this class is missing create one. envir <- attr(this, ".env") staticInstance <- get(".staticInstance", envir=envir) if (!is.null(staticInstance)) return(FALSE) if (!exists(".isCreatingStaticInstance", envir=envir, inherits=FALSE)) return(FALSE) get(".isCreatingStaticInstance", envir=envir, inherits=FALSE) }) ###########################################################################/** # @RdocMethod getFields # # @title "Returns the field names of a class" # # \description{ # @get "title". # } # # \arguments{ # \item{private}{If @TRUE, private fields will also be returned, # otherwise only public fields are returned.} # \item{...}{Not used.} # } # # @synopsis # # \value{ # Returns a @character @vector of field names. # } # # \examples{ # print(getFields(Exception)) # } # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getFields", "Class", function(this, private=FALSE, ...) { static <- getStaticInstance(this) if (inherits(static, "Class")) { # Do not do a recursive call! class(static) <- setdiff(class(static), "Class") } getFields(static, private=private) }) # getFields() if (getRversion() >= "4.5.0") { setGenericS3("getMethods", overwrite = TRUE) } ###########################################################################/** # @RdocMethod getMethods # # @title "Returns the method names of class and its super classes" # # \description{ # @get "title" as a list. # } # # @synopsis # # \arguments{ # \item{private}{If @TRUE, private methods are also returned, # otherwise only public ones are returned.} # \item{deprecated}{If @TRUE, deprecated methods are also returned.} # \item{unique}{If @TRUE, only methods that are not implemented # in one of the subclasses are returned for each class.} # \item{...}{Not used.} # } # # \value{ # Returns a named @list of named @character strings. # } # # \examples{ # names <- getMethods(Exception) # print(names) # } # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getMethods", "Class", function(this, private=FALSE, deprecated=TRUE, unique=TRUE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - findS3MethodsByEnvironment <- function(classNames, envir, exclMods=NULL, res=list()) { # Get all objects names <- ls(envir=envir, all.names=private) # 1. Keep only names with a . (period), because the others cannot # be methods of an S3 class. names <- grep("\\.", names, value=TRUE) # 2. For each class find the methods belong to that class. for (className in classNames) { pattern <- paste("\\.", className, "$", sep="") namesT <- grep(pattern, names, value=TRUE) # Nothing todo? if (length(namesT) == 0L) next # For all methods identified, see which are functions isFunction <- sapply(namesT, FUN=exists, mode="function", envir=envir) isFunction <- unlist(isFunction, use.names=FALSE) namesT <- namesT[isFunction] names(namesT) <- gsub(pattern, "", namesT) # Nothing todo? if (length(namesT) == 0L) next # Keep only non-private methods? if (!is.null(exclMods)) { keep <- sapply(namesT, FUN=function(name) { fcn <- get(name, mode="function", envir=envir) modifiers <- attr(fcn, "modifiers") !any(is.element(exclMods, modifiers)) }) namesT <- namesT[keep] } # Nothing todo? if (length(namesT) == 0L) next namesT <- c(res[[className]], namesT) # Drop duplicates dups <- duplicated(namesT) namesT <- namesT[!dups] res[[className]] <- namesT } # for (className) res } # findS3MethodsByEnvironment() findS3Methods <- function(classNames, where=c("ns", "search")[-1L], envir=NULL, exclMods=NULL) { res <- list() # Nothing todo? if (length(classNames) == 0L) return(res) if (!is.null(envir)) { res <- findS3MethodsByEnvironment(classNames, envir=envir, exclMods=exclMods, res=res) } ## # (a) Search loaded namespaces ## if (is.element("ns", where)) { ## for (ns in loadedNamespaces()) { ## envir <- getNamespace(ns) ## res <- findS3MethodsByEnvironment(classNames, envir=envir, exclMods=exclMods, res=res) ## } ## } # (a) Search attached search paths if (is.element("search", where)) { for (pos in seq_along(search())) { envir <- as.environment(pos) res <- findS3MethodsByEnvironment(classNames, envir=envir, exclMods=exclMods, res=res) } } res } # findS3Methods() # Argument 'private': private <- as.logical(private) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Find all related S3 classes # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Exclude methods with certain modifiers? exclMods <- NULL if (!private) { exclMods <- c(exclMods, "private") } if (!deprecated) { exclMods <- c(exclMods, "deprecated") } # Scan for such methods static <- getStaticInstance(this) classNames <- class(static) envir <- environment(static) result <- findS3Methods(classNames, envir=envir, exclMods=exclMods) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Cleanup # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Keep only unique method names, regardless of Class? nClasses <- length(result) if (unique && nClasses >= 2L) { names <- lapply(result, FUN=names) for (kk in seq_len(nClasses-1L)) { # Nothing todo? if (length(names[[kk]]) == 0L) next for (ll in (kk+1L):nClasses) { # Nothing todo? if (length(names[[ll]]) == 0L) next uniqueNames <- setdiff(names[[ll]], names[[kk]]) unique <- match(uniqueNames, names[[ll]]) result[[ll]] <- result[[ll]][unique] names[[ll]] <- names[[ll]][unique] } # for (ll ...) } # for (kk ...) } } # if (unique) # Remove classes with no methods if (nClasses > 0L) { result <- result[sapply(result, FUN=function(x) (length(x) > 0L))] } result }, protected=TRUE, dontWarn="base") # getMethods() ###########################################################################/** # @RdocMethod argsToString # # @title "Gets the arguments of a function as a character string" # # \description{ # Gets the arguments (with default values) of a function as a character # string, which can be used for debugging purposes etc. # Used by: classinfo(). # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # Class$argsToString(plot) # } # # \seealso{ # @seeclass # } # # @author # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("argsToString", "Class", function(this, fcn, ...) { a <- args(fcn) if (is.null(a)) return("[primitive function]") if (typeof(a) != "closure") throw("Expected closure but found something else.") args <- formals(a) argsNames <- names(args) res <- list() for (kk in seq_along(args)) { arg <- args[kk] argName <- argsNames[kk] s <- argName argDefault <- arg[[1L]] if (!missing(argDefault)) { if (is.character(argDefault)) { s <- paste(s, "=", "\"", argDefault, "\"", sep="", collapse="") } else if (is.null(argDefault)) { s <- paste(s, "=NULL", sep="", collapse="") } else if (is.language(argDefault)) { argDefault <- as.character(arg[1L]) s <- paste(s, "=", argDefault, sep="", collapse="") } else { s <- paste(s, "=", argDefault, sep="", collapse="") } } res <- c(res, list(s)) } res }, private=TRUE, static=TRUE) # argsToString ###########################################################################/** # @RdocMethod getDetails # # @title "Lists the fields and methods of a class" # # \description{ # @get "title" (or an object). # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an invisible @character string of the class information. # } # # \examples{ # getDetails(Exception) # } # # @author # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("getDetails", "Class", function(this, private=FALSE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # The class name # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - class <- getName(this) s <- class # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # The super classes # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - superclasses <- getSuperclasses(this) if (length(superclasses) > 0L) { s <- paste(s, " extends ", paste(superclasses, collapse=", "), " {", sep="") } s <- paste(s, "\n", sep="") indent <- 2L indentStr <- paste(rep(" ", length.out=indent), collapse="") # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # The fields # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - fields <- getFields(this, private=private) if (length(fields) > 0L) { modifiers <- rep("public", length.out=length(fields)) isPrivate <- (regexpr("^\\.", fields) != -1L) modifiers[isPrivate] <- "private" for (kk in seq_along(fields)) { s <- paste(s, indentStr, modifiers[kk], " ", fields[kk], "\n", sep="") } } ## formalsToString <- function(methodName, isConstructor=FALSE) { ## args <- argsToString(Class, method, argOffset) ## s <- paste(sep="", s, methodName, "(", args, ")\n") ## } ## formalsToString(...) methodsPerClass <- getMethods(this, private=private) if (length(methodsPerClass) > 0L) { envir <- environment(this) for (methods in methodsPerClass) { if (length(methods) > 0L) { methodNames <- names(methods) modifiers <- rep("public", length.out=length(methodNames)) isPrivate <- (regexpr("^\\.", methodNames) != -1L) modifiers[isPrivate] <- "private" for (kk in seq_along(methodNames)) { fcn <- .getS3Method(methods[kk], envir=envir, mustExist=TRUE) fcnModifiers <- attr(fcn, "modifiers") if (is.element("protected", fcnModifiers)) { modifiers[kk] <- "protected" } else if (is.element("private", fcnModifiers)) { modifiers[kk] <- "private" } if (is.element("public", fcnModifiers) || private == TRUE) { if (is.element("abstract", fcnModifiers)) modifiers[kk] <- paste(modifiers[kk], " ", "abstract", sep="") if (is.element("static", fcnModifiers)) modifiers[kk] <- paste(modifiers[kk], " ", "static", sep="") s <- paste(s, indentStr, modifiers[kk], " ", methodNames[kk], "(", sep="") args <- paste(argsToString(Class, fcn)[-1L], collapse=", ") s <- paste(s, args, ")\n", sep="") } } } } } s <- paste(s, "}\n", sep="") invisible(s) }, private=TRUE); # getDetails() ###########################################################################/** # @RdocMethod $ # @aliasmethod [[ # # @title "Makes the fields and methods of a Class accessible via the $ and the [[ operator" # # \usage{ # \method{$}{Class}(this, name) # \method{[[}{Class}(this, name, exact=TRUE) # } # # \description{ # Makes the fields and methods of a Class accessible via the \code{$} # operator. This method is never called explicitly, but through an indirect # usage of the \code{$} operator, e.g. \code{obj$name} or # \code{obj$getValue()}. # # \enumerate{ # \item This method will first search for a \code{get()} method, # e.g. if name has the value \code{"age"}, a \code{getAge()} will be # looked for. If such a method exists it will be called with the Class # as the first and only argument, e.g. \code{getAge(this)}. # A \code{get()} is only looked for if \code{} is not a # private field. A private field is a name \emph{beginning} with a # \code{.} (period). The rational for this naming convention is to be # consistent with how \code{\link[base]{ls}()} works, which will not list # such members by default. # # \item If no such method exists, first then, this method will look a # field in the Class can has the name \code{name}. # # \item If such neither exists, a method with name \code{name} will be # searched for and returned. # # \item If no fields or methods are found at all, @NULL is returned. # } # } # # \arguments{ # \item{name}{The name of the field or method to be accessed.} # } # # \value{ # Returns the value of a field or a method (@function). # If no such field or method exists, @NULL is returned. # } # # \examples{\dontrun{For a complete example see help(Class).}} # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("$", "Class", function(this, name) { .subset2Internal(this, name=name, exact=TRUE) }) setMethodS3("[[", "Class", function(this, name, exact=TRUE) { .subset2Internal(this, name=name, exact=exact) }) setMethodS3(".subset2Internal", "Class", function(this, name, exact=TRUE, ...) { if (is.function(this)) { static <- getStaticInstance(this) } else { static <- this } firstChar <- substr(name, start=1L, stop=1L) isPrivate <- identical(firstChar, ".") # Do not try to access private fields using a get() method, # because such a functionality means that the user *expects* that # there actually is a field called '.', which he or she # should not do since it is a private field! if (!isPrivate && is.null(attr(static, "disableGetMethods"))) { # 1. Is it a get() method? capitalizedName <- name substr(capitalizedName, start=1L, stop=1L) <- toupper(firstChar) getMethodNames <- paste("get", capitalizedName, ".", class(static), sep="") envir <- environment(static) for (getMethodName in getMethodNames) { fcn <- .getS3Method(getMethodName, envir=envir, mustExist=FALSE) if (!is.null(fcn)) { ref <- static attr(ref, "disableGetMethods") <- TRUE return(fcn(ref)) } } } # 2. Is it a field? envir <- attr(static, ".env") # For static method calls, e.g. Class$load, 'static' has no # environment assigned and therefore, for now, no static # fields. if (!is.null(envir) && exists(name, envir=envir, inherits=FALSE)) { return(get(name, envir=envir, inherits=FALSE)) } # 3. Is it an attribute field (slot)? if (is.element(name, names(attributes(static)))) { return(attr(static, name)) } # 4. Is it a static S3 method? envir <- environment(static) methodNames <- paste(name, class(static), sep=".") for (methodName in methodNames) { mtd <- .getS3Method(methodName, envir=envir, mustExist=FALSE) if (!is.null(mtd)) { # Using explicit UseMethod() code code <- sprintf("function(...) \"%s\"(static, ...)", name) expr <- base::parse(text=code) fcn <- eval(expr) # Set the environment of the static function to inherit from the # environment of the static instance/object, which in turn is the # same as the environment of the Class/constructor. envT <- environment(static) # BACKWARD COMPATIBILTY/ROBUSTNESS: In case an old static object # has been loaded, make sure to not crash, i.e. behave as before. if (!is.null(envT)) { env <- new.env(parent=envT) env$static <- static environment(fcn) <- env } return(fcn) } } NULL }, private=TRUE) # .subset2Internal() ###########################################################################/** # @RdocMethod $<- # @aliasmethod [[<- # # @title "Makes the fields and methods of a Class assignable via the $<- and the [[<- operator" # # \usage{ # \method{$}{Class}(this, name) <- value # \method{[[}{Class}(this, name) <- value # } # # \description{ # Makes the fields and methods of a Class assignable via the \code{$<-} # operator. This method is never called explicitly, but through an indirect # usage of the \code{$<-} operator, e.g. \code{obj$name <- "foo"}. # # \enumerate{ # \item This method will first search for a \preformatted{set()} # method, e.g. if name has the value \code{"age"}, a \code{setAge()} will # be looked for. If such a method exists it will be called with the Class # as the first argument and \code{value} as the second, e.g. # \code{setAge(this, value)}. # A \code{get()} is only looked for if \code{} is not a # private field. A private field is a name \emph{beginning} with a # \code{.} (period). The rational for this naming convention is to be # consistent with how \code{\link[base]{ls}()} works, which will not # list such members by default. # # \item If no such method exists it will assign the \code{value} to a # (existing or a non-existing) field named \code{name}. # } # # Because any \preformatted{set()} is called first, it is possible # to \emph{encapsulate} (hide away) fields with certain names or to put # restrictions to what values can be assigned to them. # } # # \arguments{ # \item{name}{The name of the \preformatted{set()} method or the # name of the field to be assigned the new value.} # \item{value}{The value to be assigned.} # } # # \value{ # Returns itself, i.e. \code{this}, as all \code{$<-} methods must do. # } # # \examples{\dontrun{For a complete example see help(Class).}} # # @author # # \seealso{ # @seeclass # } # # @keyword programming # @keyword methods #*/########################################################################### setMethodS3("$<-", "Class", function(this, name, value) { if (is.function(this)) static <- getStaticInstance(this) else static <- this firstChar <- substr(name, start=1L, stop=1L) isPrivate <- identical(firstChar, ".") # Do not try to access private fields using a set() method, # because such a functionality means that the user *expects* that # there actually is a field called '.', which he or she # should not do since it is a private field! if (!isPrivate && is.null(attr(static, "disableSetMethods"))) { # 1. Is it a set() method? capitalizedName <- name substr(capitalizedName,start=1L, stop=1L) <- toupper(firstChar) setMethodNames <- paste("set", capitalizedName, ".", class(static), sep="") envir <- environment(static) for (setMethodName in setMethodNames) { mtd <- .getS3Method(setMethodName, envir=envir, mustExist=FALSE) if (!is.null(mtd)) { ref <- static attr(ref, "disableSetMethods") <- TRUE mtd(ref, value) return(this) } } } # 3. Is it an attribute field (slot)? if (is.element(name, names(attributes(static)))) { attr(static, name) <- value return(this) } # 4. Otherwise, assign the value to an (existing or non-existing) field. assign(name, value, envir=attr(static, ".env")) invisible(this) }) # $<-() setMethodS3("[[<-", "Class", function(this, name, value) { do.call(`$<-`, list(this, name, value)) }) # "[[<-"() setMethodS3(".DollarNames", "Class", .DollarNames.Object, appendVarArgs=FALSE, private=TRUE) R.oo/R/Rdoc.R0000644000176200001440000026004014554071363012314 0ustar liggesusers##########################################################################/** # @RdocClass Rdoc # # @title "Class for converting Rdoc comments to Rd files" # # \description{ # @classhierarchy # # @get "title". # } # # @synopsis # # \section{Fields and Methods}{ # @allmethods # } # # @author # # \examples{\dontrun{@include "../incl/Rdoc.Rex"}} # # \references{ # R developers, # \emph{Guidelines for Rd files}, # \url{https://developer.r-project.org/Rds.html}, # 2003 # } # # @keyword documentation #*/########################################################################### setConstructorS3("Rdoc", function() { extend(Object(), "Rdoc", .START = paste(sep="", "/", "**"), # To hide it from itself!!! .STOP = paste(sep="", "*", "/"), # - " - .nameFormat = "method.class", .manPath = "../man/", package = NULL, source = NULL ) }) ###########################################################################/** # @RdocMethod getNameFormat # # @title "Gets the current name format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seemethod "setNameFormat" # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getNameFormat", "Rdoc", function(static, ...) { Rdoc$.nameFormat }, static=TRUE) ###########################################################################/** # @RdocMethod setNameFormat # # @title "Sets the current name format" # # \description{ # @get "title". # Throws a @see "RccViolationException" if an unknown format is requested. # } # # @synopsis # # \arguments{ # \item{nameFormat}{ # If \code{"method.class"}, help files for methods belonging to classes are # named .. # If \code{"class.method"}, help files for methods belonging to classes are # named .. # These are currently the only name formats supported. # } # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seemethod "getNameFormat" # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("setNameFormat", "Rdoc", function(static, nameFormat, ...) { if (nameFormat == "class.method") { } else if (nameFormat == "method.class") { } else { throw(RdocException("Unknown name format: ", nameFormat)) } Rdoc$.nameFormat <- nameFormat }, static=TRUE) ###########################################################################/** # @RdocMethod getKeywords # # @title "Gets the keywords defined in R with descriptions" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seemethod "setManPath" # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getKeywords", "Rdoc", function(this, fullInfo=FALSE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Locate the KEYWORDS.db file # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - path <- Sys.getenv("R_DOC_DIR") if (is.null(path) || nchar(path) == 0) { # Backward compatibility path <- file.path(Sys.getenv("R_HOME"), "doc") tryCatch({ path <- R.home("doc") }, error = function(ex) {}) if (!file.exists(path)) { throw("Cannot determine the R doc directory. R_DOC_DIR was not set and R_HOME/doc/ does not exist: ", path) } } pathname <- file.path(path, "KEYWORDS.db") if (!file.exists(pathname)) { throw("The KEYWORDS.db file was not found: ", pathname) } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Read keywords # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - keywords <- readLines(pathname, warn=FALSE) keywords <- strsplit(keywords, ":") names <- lapply(keywords, FUN=function(x) x[1]) names <- unlist(names) names <- gsub("[[:space:]]+$", "", gsub("^[[:space:]]+", "", names)) desc <- lapply(keywords, FUN=function(x) x[2]) desc <- unlist(desc) desc <- gsub("[[:space:]]+$", "", gsub("^[[:space:]]+", "", desc)) keywords <- strsplit(names, "\\|") len <- unlist(lapply(keywords, FUN=length)) keywords <- unlist(lapply(keywords, FUN=function(x) x[length(x)])) keywords <- keywords[len > 1] desc <- desc[len > 1] names(keywords) <- desc keywords }, static=TRUE) ###########################################################################/** # @RdocMethod isKeyword # # @title "Checks if a word is a Rd keyword" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @logical. # } # # @author # # \seealso{ # @seemethod "getKeywords" # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("isKeyword", "Rdoc", function(this, word, ...) { is.element(word, Rdoc$getKeywords()) }, static=TRUE) ###########################################################################/** # @RdocMethod getManPath # # @title "Gets the path to the directory where the Rd files will be saved" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seemethod "setManPath" # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getManPath", "Rdoc", function(this, ...) { this$.manPath }, static=TRUE) ###########################################################################/** # @RdocMethod setManPath # # @title "Sets the path to the directory where the Rd files should be saved" # # \description{ # @get "title". By default the path is \code{../man/} assuming that the # current directory is \code{../R/}, which is where source files commonly # are placed. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seemethod "getManPath" # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("setManPath", "Rdoc", function(this, path="../man/", ...) { info <- file.info(path) if (is.na(info$isdir)) path <- gsub("/$", "", path) info <- file.info(path) if (is.na(info$isdir)) throw("Path does not exists: ", path) if (info$isdir != TRUE) throw("Specified path is not a directory: ", path) this$.manPath <- as.character(path) }, static=TRUE) ###########################################################################/** # @RdocMethod createManPath # # @title "Creates the directory where the Rd files should be saved" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the directory was creates, @FALSE if it already exists # and throws an @Exception if failed. # } # # @author # # \seealso{ # @seemethod "getManPath" # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("createManPath", "Rdoc", function(this, ...) { # Check if the path already exists, otherwise create it. path <- getManPath(this) # file.exists() and file.info() is sensitive to trailing '/'. path <- gsub("/$", "", path) isdir <- as.logical(file.info(path)["isdir"]) if (file.exists(path) && isdir) return(FALSE) # Path 'destPath' does not exist at all. It might be that there is # a file with the same name, but in any case, the OS should # take care of conflict if it thinks it is a conflict. if (!dir.create(path)) throw(Exception("Could not create destination directory: ", path)) return(TRUE) }, static=TRUE, protected=TRUE) ###########################################################################/** # @RdocMethod createName # # @title "Creates a class-method name" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{class}{A class name (@character string).} # \item{method}{A method name (@character string).} # \item{escape}{If @TRUE, non-valid filename characters are escaped into # valid character strings.} # \item{...}{Not used.} # } # # \value{ # Returns @character string. # } # # @author # # \seealso{ # @seemethod "escapeRdFilename". # @seeclass # } # # @keyword documentation # @keyword internal #*/########################################################################### setMethodS3("createName", "Rdoc", function(static, class, method, escape=TRUE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Get name format to be used (can be set globally) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - nameFormat <- Rdoc$getNameFormat() if (nameFormat == "class.method") { name <- paste(class, ".", method, sep="") } else if (nameFormat == "method.class") { name <- paste(method, ".", class, sep="") } else { throw(RdocException("Unknown name format: ", nameFormat)) } if (escape) { name <- Rdoc$escapeRdFilename(name) } name }, static=TRUE, private=TRUE) ###########################################################################/** # @RdocMethod escapeRdFilename # # @title "Escape non-valid characters in a filename" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{filename}{A filename (@character string) to be escaped.} # \item{...}{Not used.} # } # # \value{ # Returns @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("escapeRdFilename", "Rdoc", function(static, filename, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Escape non-valid filenames # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - filename <- gsub("\\\\\\$", "DOLLAR", filename) filename <- gsub("[$]", "DOLLAR", filename) filename <- gsub("<-", "< -", filename) filename <- gsub("<", "LT", filename) filename <- gsub("[[]", "-LB-", filename) # From R v1.8.1 can't Rd filenames contain whitespace. filename <- gsub("[ \t]", "_", filename) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # A filename must start with a letter or a digit # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - startOk <- (regexpr("^[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0-9]", filename) != -1) if (!startOk) { # Fix Rd filename (not really important actually). filename <- paste("000", filename, sep="") } filename }, protected=TRUE, static=TRUE) # escapeRdFilename() ###########################################################################/** # @RdocMethod compile # # @title "Compile source code files containing Rdoc comments into Rd files" # # \description{ # @get "title". # # \emph{Note, the class and methods to be compiled have to be loaded into # \R by for instance \code{library()} or \code{source()} before calling # this method.} # } # # @synopsis # # \arguments{ # \item{filename}{The pathname or filename pattern of the Rdoc files to be # compiled.} # \item{destPath}{The path where the generated Rd files should be saved.} # \item{showDeprecated}{If @TRUE, Rd files are generated for deprecated # objects too, otherwise not.} # \item{addTimestamp}{If @TRUE, a date and time stamp is added to the # Rd header comments. This timestamp might be confusing for version # control systems, which is why it can be turned off with @FALSE.} # \item{locale}{The locale to be set/used when compiling Rdoc comments. # This help assuring strings are sorted the same way across systems.} # \item{source}{If @TRUE, the Rdoc files will be \code{source()}:ed first. # This work of course only for Rdoc files that are R source files.} # \item{verbose}{If @TRUE, detailed compilation information is printed.} # \item{debug}{If @TRUE, extra debug information is printed.} # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("compile", "Rdoc", function(this, filename=".*[.]R$", destPath=getManPath(this), showDeprecated=FALSE, addTimestamp=FALSE, locale="C", verbose=FALSE, source=FALSE, check=TRUE, debug=FALSE, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Global variables # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - authorWarn <- FALSE pkgAuthors <- NULL # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - isCapitalized <- function(str) { first <- substring(str,1,1) (first == toupper(first)) } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # a d d K e y w o r d ( ) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - validateKeyword <- function(keyword) { knownKeywords <- Rdoc$getKeywords() if (!is.element(keyword, knownKeywords)) { alts <- agrep(keyword, knownKeywords) alts <- paste("'", knownKeywords[alts], "'", collapse=", ", sep="") if (nchar(alts) > 0) alts <- paste("Did you mean ", alts, "?", sep="") throw(RdocException("Unknown keyword: ", keyword, ". ", alts, source=sourcefile)) } } # validateKeyword() rdocKeywords <- c() addKeyword <- function(keyword) { keyword <- as.character(keyword) # A remove keyword? if (regexpr("^-", keyword) != -1) { rdocKeywords <<- unique(c(rdocKeywords, keyword)) keyword <- gsub("^-", "", keyword) } else { rdocKeywords <<- unique(c(rdocKeywords, keyword)) } # Validate keyword validateKeyword(keyword) } # addKeyword() getRdKeywords <- function(...) { # Get all keywords if (length(rdocKeywords) == 0) return("") isRemove <- (regexpr("^-", rdocKeywords) != -1) keywords <- rdocKeywords[!isRemove] exclKeywords <- gsub("^-", "", rdocKeywords[isRemove]) keywords <- setdiff(keywords, exclKeywords) keywords <- unique(keywords) # Empty current list of keywords rdocKeywords <<- c() if (length(keywords) == 0) return(NULL) lines <- paste("\\keyword{", keywords, "}", sep="") lines <- paste(lines, collapse="\n") lines } # getRdKeywords() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # e s c a p e N a m e ( ) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # From the help: # \name{name} # name typically is the basename of the Rd file containing the # documentation. It is the "name" of the Rd object represented # by the file, has to be unique in a package, and must not # contain LaTeX special characters (#, $, %, &, ~, _, ^, \, {, }). escapeName <- function(name) { name <- gsub("\\#", "POUND", name) name <- gsub("\\$", "DOLLAR", name) name <- gsub("\\%", "PERCENT", name) name <- gsub("\\&", "AND", name) name <- gsub("\\~", "TILDE", name) name <- gsub("\\_", "UNDERSCORE", name) name <- gsub("\\^", "POWER", name) name <- gsub("\\\\", "BACKSLASH", name) name <- gsub("\\{", "LCURLY", name) name <- gsub("\\}", "RCURLY", name) name <- gsub("<-", "< -", name) name } # escapeName() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # e s c a p e A l i a s ( ) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - escapeAlias <- function(alias) { # Don't escape aliases?!? /HB 2004-03-03 alias <- gsub("\\%", "\\\\%", alias) # alias <- gsub("\\$", "\\\\$", alias) # alias <- gsub("<-", "< -", alias) alias } # escapeAlias() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # e x t r a c t R d o c s ( ) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - extractRdocs <- function(filename, verbose=FALSE, debug=FALSE) { if (!file.exists(filename)) throw(RdocException("File not found: ", filename)) # Read all lines from the source code file lines <- readLines(filename, warn=FALSE) if (length(lines) == 0) return(list()) # Keep only the lines that are comments. lines <- lines[(regexpr("^ *#", lines) != -1)] if (length(lines) == 0) return(list()) # Find all Rdoc begins and ends begins <- which(regexpr("/\\*\\*", lines) != -1) ends <- which(regexpr("\\*/", lines) != -1) if (length(begins) != length(ends)) throw(RdocException("Number of Rdoc begins do not match number of Rdoc ends: ", filename)) if (any(begins - ends > 0)) throw(RdocException("Some of the Rdoc begins comes after the Rdoc ends: ", filename)) rdocs <- list() for (k in seq_along(begins)) { idx <- begins[k]:ends[k] tmp <- lines[idx] # Remove everything before the begin tag including the tag tmp[1] <- gsub("^#.*/\\*\\*", "", tmp[1]) # Remove everything after the end tag including the tag last <- length(tmp) tmp[last] <- gsub("^#.*\\*/.*", "", tmp[last]) # Remove all leading single and double comment characters tmp <- gsub("^#{1,3}", "", tmp) # Find (minimum) indentation indents <- regexpr("[^ ]", tmp[nchar(tmp) > 0]) indent <- min(indents) tmp <- substring(tmp, first=indent) # Remove all trailing whitespace tmp <- gsub("[ \t\v\r\n]$", "", tmp) # Remove all empty lines at the beginning while (nchar(tmp[1]) == 0) tmp <- tmp[-1] # Remove all empty lines at the end while (nchar(tmp[length(tmp)]) == 0) tmp <- tmp[-length(tmp)] attr(tmp, "sourcefile") <- filename rdocs[[k]] <- tmp } rdocs } # extractRdocs() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # w r i t e R d ( ) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - sourcefile <- NA writeRd <- function(rds, path=getManPath(this), addTimestamp=TRUE, verbose=FALSE, debug=FALSE) { for (rd in rds) { name <- attr(rd, "name") if (!is.null(path)) { if (regexpr("/$", path) == -1 && regexpr("\\$", path) == -1) path <- paste(path, "/", sep="") } filename <- Rdoc$escapeRdFilename(name) filename <- paste(path, filename, ".Rd", sep="") if (verbose) { cat("Generating ", filename, "...", sep="") } sourcefile <<- sourcefile <- attr(rd, "sourcefile") hdr <- c("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") hdr <- c(hdr, "% Do not modify this file since it was automatically generated from:") hdr <- c(hdr, "% ") hdr <- c(hdr, paste("% ", sourcefile, sep="")) hdr <- c(hdr, "% ") if (addTimestamp) { hdr <- c(hdr, paste("% on ", date(), ".", sep="")) hdr <- c(hdr, "% ") } hdr <- c(hdr, "% by the Rdoc compiler part of the R.oo package.") hdr <- c(hdr, "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") bfr <- paste(c(hdr, "", rd, ""), collapse="\n") writeChar(bfr, eos=NULL, con=filename) } } # writeRd() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # c o m p i l e R d o c () # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - compileRdoc <- function(rdocs, showDeprecated=FALSE, verbose=FALSE, debug=FALSE) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Validate arguments # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if (!is.list(rdocs)) throw(RdocException("Internal error: Expected a list: ", class(rdocs)[1L])) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Defines all simple tags that are shortcuts to different help documents. # Example: @TRUE -> \\code{\\link[base:logical]{TRUE}} # NA means that the text should just be place inside \code{}. # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - shorttags <- list( # Package base: "0" = NA, "1" = NA, "..." = NA, "." = NA, # Must come *after* "..." "array" = "base", "attributes" = "base", "attr" = "base", "ANY" = NA, "call" = "base", "character" = "base", "complex" = "base", "connection" = "base:connections", "data.frame" = "base", "dimnames" = "base", "dim" = "base", "double" = "base", "environment" = "base", "expression" = "base", "factor" = "base", "FALSE" = "base:logical", "formula" = "base", "function" = "base", "Inf" = "base:is.finite", "integer" = "base", "length" = "base", "list" = "base", "logical" = "base", "matrix" = "base", "names" = "base", "name" = "base", "NA" = "base", "NaN" = "base:is.finite", "NULL" = "base", "numeric" = "base", "table" = "base", "TRUE" = "base:logical", "raw" = "base", "ts" = "base", "vector" = "base", "warning" = "base", # Package R.oo: "Object" = "R.oo", "Exception" = "R.oo", "throw" = "R.oo" ) names <- names(shorttags) match <- gsub("\\.", "\\\\.", names) attr(shorttags, "beginsWith") <- paste("^@", match, sep="") attr(shorttags, "contains") <- paste("[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0-9.]@", match, sep="") replace <- paste("\\link[", unlist(shorttags), "]{", names, "}", sep="") replace[is.na(shorttags)] <- names[is.na(shorttags)] replace <- paste("\\code{", replace, "}", sep="") attr(shorttags, "replace") <- replace # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - getTagValue <- function(bfr) { # 1. Remove all leading whitespace bfr <- gsub("^[ \t]", "", bfr) # 2a. Is there a '{' + '}' pair? (nesting brackets are not allowed) if ((beginPos <- regexpr("^\\{", bfr)) != -1L) { # Find the end '}' endPos <- regexpr("\\}", bfr) if (endPos == -1L) throw(RdocException("Closing } is missing: ", substring(bfr, first=1L, last=20L), source=sourcefile)) value <- substring(bfr, first=beginPos+1L, last=endPos-1L) bfr <- substring(bfr, first=endPos+1L) } # 2b. ...or a '"' + '"' pair? (*internal* escaped " are ignored) else if ((beginPos <- regexpr("^\"", bfr)) != -1L) { endPos <- regexpr("[^\\]\"", bfr) if (endPos == -1L) throw(RdocException("Closing \" is missing: ", substring(bfr, first=1L, last=20L), source=sourcefile)) value <- substring(bfr, first=beginPos+1L, last=endPos) bfr <- substring(bfr, first=endPos+2L) } # 2c. ...otherwise the value is the first word found # (on the same line!) else { beginPos <- 1L endPos <- regexpr("([ \t\n\r]|$)", bfr) value <- substring(bfr, first=1L, last=endPos-1L) # Ad hoc. /HB 2013-03-25 if (value != "}") { bfr <- substring(bfr, first=endPos) } else { value <- "" } } attr(bfr, "value") <- value bfr } # getTagValue() isObjectDeprecated <- function(name, ...) { obj <- getObject(this, name=name, ...) mods <- attr(obj, "modifiers") is.element("deprecated", mods) } # isObjectDeprecated() # Read and parse authors from DESCRIPTION's 'Authors@R' or 'Author'. getPackageAuthors <- function() { if (!is.null(pkgAuthors)) { return(pkgAuthors) } pkg <- Package(Rdoc$package) authors <- getAuthor(pkg, as="person") authorsN <- format(authors, include=c("given", "family")) maintainers <- getMaintainer(pkg, as="person") maintainersN <- format(maintainers, include=c("given", "family")) # Append maintainers, if not already listed as authors keep <- !is.element(maintainersN, authorsN) maintainers <- maintainers[keep] if (length(maintainers) > 0L) { ## authors <- c(authors, maintainers) } authors } # getPackageAuthors() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocClass <- function(bfr) { bfr <- getTagValue(bfr) class <<- attr(bfr, "value") typeOfClass <- typeOfClass(class) if (is.na(typeOfClass)) { throw(RdocException("Class is either not defined or loaded, or not an S4/setClass() or S3/setConstructorS3() class: ", class)) } if (typeOfClass == "S4") { clazz <<- getClass(class) } else if (typeOfClass == "S3-Object") { clazz <<- Class$forName(class) } line <- paste("\\name{", escapeName(class), "}\n", sep="") line <- paste(line, "\\docType{class}\n", sep="") line <- paste(line, "\\alias{", class, "}\n", sep="") addKeyword("classes") if (typeOfClass == "S4") { line <- paste(line, "\\alias{", class, "-class}\n", sep="") usage <- Rdoc$getClassS4Usage(clazz) } else if (typeOfClass == "S3-Object") { usage <<- Rdoc$getUsage(method=class) isDeprecated <<- isDeprecated(clazz) } name <<- class objectName <<- class rd <<- paste(rd, line, sep="") bfr } # tagRdocClass() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagClass <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") class <<- value bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocMethod <- function(bfr) { bfr <- getTagValue(bfr) method <- attr(bfr, "value") objectName <<- paste(method, class, sep=".") isDeprecated <<- isObjectDeprecated(objectName) # Find method fcn <- NULL tryCatch({ fcn <- Rdoc$getObject(objectName, mode="function") }, error = function(ex) { cat("Failed...\n") print(ex) cat("Failed...done\n") }) if (!is.function(fcn)) { throw(RdocException("Could not get method. Function was not found: ", objectName, "()", source=Rdoc$source)) } methodName <- createName.Rdoc(NULL, class, method, escape=FALSE) isStatic <- is.element("static", attr(fcn, "modifiers")) if (isStatic) { staticName <- paste(class, method, sep="$") name <- staticName alias <- c(staticName, escapeAlias(methodName)) } else { name <- escapeName(methodName) alias <- escapeAlias(methodName) } # Treat internal and non-internal methods differently if (isCapitalized(class)) { alias <- c(alias, paste(class, method, sep=".")) alias <- c(alias, paste(method, ",", class, "-method", sep="")) } alias <- c(alias, paste(method, class, sep=".")) # Multiple aliases(?) alias <- unique(alias) alias <- paste("\\alias{", alias, "}", sep="") line <- paste("\\name{", name, "}", sep="") line <- c(line, alias) line <- paste(line, collapse="\n") # Treat internal and non-internal methods differently if (isCapitalized(class)) { addKeyword("internal") } addKeyword("methods") name <<- methodName; # Filename usage <<- Rdoc$getUsage(method=method, class=class) rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocDefault <- function(bfr) { bfr <- getTagValue(bfr) default <- attr(bfr, "value") objectName <<- default isDeprecated <<- isObjectDeprecated(objectName) name <- default name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, ".default}\n", sep="") line <- paste(line, "\\alias{", name, "}", sep="") usage <<- Rdoc$getUsage(method=default, class="default") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocGeneric <- function(bfr) { bfr <- getTagValue(bfr) generic <- attr(bfr, "value") objectName <<- generic isDeprecated <<- isObjectDeprecated(objectName) name <- generic name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, "}\n", sep="") addKeyword("methods") usage <<- Rdoc$getUsage(method=generic) rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocFunction <- function(bfr) { bfr <- getTagValue(bfr) fcn <- attr(bfr, "value") objectName <<- fcn isDeprecated <<- isObjectDeprecated(objectName) name <- fcn name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, "}\n", sep="") usage <<- Rdoc$getUsage(method=fcn) rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocObject <- function(bfr) { bfr <- getTagValue(bfr) object <- attr(bfr, "value") objectName <<- object isDeprecated <<- isObjectDeprecated(objectName) name <- object name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, "}", sep="") usage <<- NULL rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocData <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") name <- value name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, "}\n", sep="") line <- paste(line, "\\docType{data}\n", sep="") addKeyword("datasets") objectName <<- value usage <<- NULL rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocDocumentation <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") name <- value name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, "}\n", sep="") addKeyword("documentation") hasTitle <- (regexpr("(@|[\\])title", bfr) != -1) if (!hasTitle) line <- paste(line, "\\title{", name, "}\n", sep="") objectName <<- value usage <<- NULL rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocAbout <- function(bfr) { # An @RdocAbout does *not* have a value # bfr <- getTagValue(bfr) name <- ". About this package" name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, "}\n", sep="") addKeyword("documentation") line <- paste(line, "\n", sep="") hasTitle <- (regexpr("(@|[\\])title", bfr) != -1) if (!hasTitle) line <- paste(line, "\\title{About this package}\n", sep="") objectName <<- name usage <<- NULL rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagRdocPackage <- function(bfr) { # An @RdocPackage takes the package name as an argument bfr <- getTagValue(bfr) name <- attr(bfr, "value") name <<- name <- escapeName(name) line <- paste("\\name{", name, "-package}\n", sep="") line <- paste(line, "\\alias{", name, "-package}\n", sep="") line <- paste(line, "\\alias{", name, "}\n", sep="") line <- paste(line, "\\docType{package}\n", sep="") addKeyword("package") line <- paste(line, "\n", sep="") hasTitle <- (regexpr("(@|[\\])title", bfr) != -1) if (!hasTitle) line <- paste(line, "\\title{Package ", name, "}\n", sep="") name <<- paste(name, "-package", sep="") objectName <<- name usage <<- NULL rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagName <- function(bfr) { bfr <- getTagValue(bfr) if (!is.null(name)) { warning("Tag ignored: @RdocDefault is not needed if @RdocClass is specified.") return(bfr) } value <- attr(bfr, "value") name <- value name <<- name <- escapeName(name) line <- paste("\\name{", name, "}\n", sep="") line <- paste(line, "\\alias{", name, "}", sep="") objectName <<- value usage <<- Rdoc$getUsage(method=value) rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagAlias <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") alias <- value alias <- escapeAlias(alias) line <- paste("\\alias{", alias, "}", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagAliasMethod <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") method <- value method <- escapeAlias(method) line <- paste("\\alias{", class, ".", method, "}\n", sep="") line <- paste(line, "\\alias{", method, ".", class, "}\n", sep="") line <- paste(line, "\\alias{", method, ",", class, "-method}\n", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagAliasUndocumented <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") alias <- unlist(tools::undoc(package=value)) alias <- sapply(alias, FUN=escapeAlias) lines <- paste("\\alias{", alias, "}", sep="") lines <- paste(lines, collapse="\n") rd <<- paste(rd, lines, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagUsage <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") if (nchar(value) == 0L) { # Usage is inferred from the @RdocNnn tag. } else if (nchar(value) > 0L) { # Usage is inferred from the @usage tag. parts <- strsplit(value, split=",", fixed=TRUE)[[1]] nparts <- length(parts) method <- parts[1L] if (nparts == 1L) { usage <- Rdoc$getUsage(method=method) } else if (nparts == 2L) { class <- parts[2L] usage <- Rdoc$getUsage(method=method, class=class) } } usage <- paste(usage, collapse="\n") line <- usage rd <<- paste(rd, line, sep="") bfr } tagSynopsis <- function(bfr) { usage <- c("", usage, "") usage <- paste(usage, collapse="\n") line <- paste("\\usage{", usage, "}", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagKeyword <- function(bfr) { bfr <- getTagValue(bfr) keyword <- attr(bfr, "value") addKeyword(keyword) bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagInclude <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") if (!file.exists(value)) { throw(RdocException("File to be included not found: ", value, source=sourcefile)) } else { include <- readLines(value, warn=FALSE) include <- paste(include, collapse="\n") include <- gsub("\\%", "\\\\%", include) line <- paste(include, "\n", sep="") rd <<- paste(rd, line, sep="") } bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagExamples <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") if (!file.exists(value)) { throw(RdocException("File containing examples to be included not found: ", value, source=sourcefile)) } else { include <- readLines(value, warn=FALSE) include <- paste(include, collapse="\n") include <- gsub("\\%", "\\\\%", include) line <- paste("\\examples{\n", include, "\n}", sep="") } rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagVisibility <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") visibility <<- value if (!is.element(visibility, c("private", "protected", "public"))) throw(RdocException("Unknown type of visibility: ", value, source=sourcefile)) if (visibility == "private") addKeyword("internal") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagGet <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") if (exists(value)) { line <- as.character(get(value)) } else if (!is.null(getOption(value))) { line <- as.character(getOption(value)) } else { throw(RdocException("R variable does not exist: ", value, source=sourcefile)) } rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagSet <- function(bfr, envir=parent.frame()) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") keyValue <- strsplit(value, "=")[[1]] assign(keyValue[1], value=keyValue[2], envir=envir) bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagAuthor <- function(bfr) { bfrT <- getTagValue(bfr) value <- attr(bfrT, "value") value <- as.character(value) hasValue <- (nchar(value) > 0L) hasValue <- hasValue && (regexpr("^[ \t]*[\n\r]", value) == -1L) # Does the @author tag has a value? if (hasValue) { # Non-empty @author tag with value, e.g. '@author "HB"' value <- gsub("^[ \t]*['\"]?", "", value) value <- gsub("['\"]?[ \t]*$", "", value) # (i) All authors? if (value == "*") { pkgAuthors <<- authors <- getPackageAuthors() } else { # (ii) All initials? An initial = 2-5 upper case letters tmp <- unlist(strsplit(value, split=",", fixed=TRUE)) tmp <- gsub("^[ \t]*", "", tmp) tmp <- gsub("[ \t]*$", "", tmp) tmpU <- toupper(tmp) pattern <- sprintf("^[%s]{2,5}$", paste(base::LETTERS, collapse="")) allInitials <- all( (tmpU == tmp) & (regexpr(pattern, tmp) != -1L) ) if (allInitials) { initials <- tmp # Create all initials of the 'authors' pkgAuthors <<- authors <- getPackageAuthors() fullnames <- format(authors, include=c("given", "family")) known <- abbreviate(fullnames, minlength=2L) known <- toupper(known) # Check if the initials match idxs <- match(initials, known) unknown <- initials[is.na(idxs)] if (length(unknown) > 0L) { known <- paste(sQuote(known), sQuote(fullnames), sep="=") throw(RdocException("Rdoc 'author' tag specifies initials (", paste(sQuote(unknown), collapse=", "), ") that are not part of the known ones (", paste(known, collapse=", "), ")", source=sourcefile)) } authors <- authors[idxs] } else { authors <- as.person(value) } } bfr <- bfrT } else { # Empty @author tag, i.e. '@author' pkgAuthors <<- authors <- getPackageAuthors() # If there are creators of the package (which there should be), # use those as the default for an empty '@author' tag. isCreator <- sapply(authors, FUN=function(a) is.element("cre", a$role)) if (any(isCreator)) { authors <- authors[isCreator] } if (exists("author", mode="character", envir=globalenv())) { if (!authorWarn) { author <- get("author", mode="character", envir=globalenv()) warning("Detected an 'author' character variable in the global environment. Note that, since R.oo 1.13.0, the author for an (empty) Rdoc @author tag is inferred from the 'Authors@R' or 'Author' DESCRIPTION field and no longer take from the global 'author' variable: ", sQuote(author)) authorWarn <<- TRUE } } } authorsTag <- format(authors, include=c("given", "family")) authorsTag <- paste(authorsTag, collapse=", ") line <- paste("\\author{", authorsTag, "}", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagHowToCite <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") package <- Package(value) howToCite <- getHowToCite(package, newline=NULL) if (is.null(howToCite)) { line <- "\\emph{No citation information available.}\n" } else { line <- gsub("\n", " ", howToCite) line <- gsub("[ ]+", " ", line) line <- lapply(line, FUN=strwrap, width=85L) line <- lapply(line, FUN=paste, collapse="\n") line <- unlist(line, use.names=FALSE) line <- paste(line, collapse="\n\n") line <- paste("\\preformatted{\n", line, "\n}\n", sep="") ## Not sure exactly when this was fixed in R, but now the workaround ## triggers an 'R CMD check' NOTE on "Warning: trimming empty

". ## /HB 2022-06-11 if (getRversion() < "4.0.0") { # Add the following line to fix a "R CMD check-bug" in LaTeX. # /HB 2004-03-10 line <- paste(line, "\\emph{}\n", sep="") } } rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagSeeclass <- function(bfr) { line <- paste("For more information see \\code{\\link{", class, "}}.", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagSeemethod <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") line <- paste("\\code{\\link[", package, ":", Rdoc$createName(class, value), "]{*", value, "}()}", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagSeeOtherMethods <- function(bfr) { clazz <<- Class$forName(class) method <- gsub(paste("[.]", class, "$", sep=""), "", objectName) classes <- list(getSuperclasses(clazz), getKnownSubclasses(clazz)) for (k in 1:2) { methods <- paste(method, classes[[k]], sep=".") exists <- sapply(methods, FUN=exists, mode="function") classes[[k]] <- classes[[k]][exists] methods <- methods[exists] for (l in seq_along(methods)) { fcn <- get(methods[l], mode="function") modifiers <- attr(fcn, "modifiers") isPrivate <- is.element("private", modifiers) isDeprecated <- is.element("deprecated", modifiers) if (isPrivate || isDeprecated) methods[l] <- NA } classes[[k]] <- classes[[k]][!is.na(methods)] } for (k in 1:2) { classes[[k]] <- paste("\\code{\\link[", package, ":", Rdoc$createName(classes[[k]], method), "]{", classes[[k]], "}}", sep="") } line <- "\\cr\\bold{Implementations of this method in}" line <- paste(line, " i) \\bold{superclasses:} ") line <- paste(line, paste(classes[[1]], collapse=", "), sep="") line <- paste(line, ", and ii) \\bold{subclasses:} ") line <- paste(line, paste(classes[[2]], collapse=", "), ".", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagSee <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") pkgObject <- strsplit(value, "::", value)[[1]] fcn <- "" if (length(pkgObject) == 1) { pkg <- NULL obj <- pkgObject[1] if (exists(obj, mode="function")) { expr <- substitute(inherits(fcn, "Class"), list(fcn=as.name(obj))) if (!eval(expr)) fcn <- "()" } } else { pkg <- pkgObject[1] obj <- pkgObject[2] .require <- require; # To please R CMD check if (.require(package=pkg, character.only=TRUE)) { pos <- which(paste("package:", "base", sep="") == search()) if (exists(obj, where=pos, mode="function", inherits=FALSE)) fcn <- "()" } pkg <- paste("[", pkg, "]", sep="") } line <- paste("\\code{\\link", pkg, "{", obj, "}}", fcn, sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagClasshierarchy <- function(bfr) { txt <- getRdHierarchy(clazz) subclasses <- getKnownSubclasses(clazz) # If possible, create links to Rd docs for each of the subclasses. links <- c() for (name in subclasses) { link <- name if (exists(name, mode="function")) { cls <- get(name, mode="function") if (inherits(cls, "Class")) { pkg <- getPackage(cls) if (is.null(pkg)) link <- paste("\\link{", link ,"}", sep="") else link <- paste("\\link[", pkg, "]{", link ,"}", sep="") if (isAbstract(cls)) link <- paste("\\emph{", link, "}", sep="") } } # link <- paste("\\code{", link ,"}", sep="") links <- c(links, link) } # for (name in ...) subclasses <- paste(links, collapse=", ") txt <- paste(txt, "\\bold{Directly known subclasses:}\\cr\n", sep="") txt <- paste(txt, subclasses, sep="") txt <- paste(txt, "\\cr\n\n", sep="") txt <- paste(txt, getRdDeclaration(clazz), "\n", sep="") line <- txt rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagMethods <- function(bfr) { methods <- getRdMethods(clazz, visibility=visibility) line <- methods rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagAllMethods <- function(bfr) { bfr <- getTagValue(bfr) visibilities <- attr(bfr, "value") # Ad hoc patch for parser /060530. addEnd <- (identical(visibilities, "}")) visibilities <- gsub(" ", "", visibilities) visibilities <- unlist(strsplit(visibilities, split="|", fixed=TRUE)) methods <- getRdMethods(clazz, visibilities=visibilities) line <- paste(methods, "\n\n", sep="") methods <- Rdoc$methodsInheritedFrom(clazz, visibility, showDeprecated=showDeprecated, sort=sort) line <- paste(line, methods, sep="") if (addEnd) line <- paste(line, "}", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagTitle <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") title <<- as.character(value) # Check the title for correctness according to https://developer.r-project.org/Rds.html firstLetter <- substring(title, 1,1) if (firstLetter != toupper(firstLetter)) throw(RdocException("Titles shoule be capitalized: ", title, source=sourcefile)) if (regexpr("[.]$", title) != -1) throw(RdocException("Titles should not end with a period: ", title, source=sourcefile)) if (regexpr("[^\\][\\][:letter:]", title) != -1) throw(RdocException("Titles should not contain markup: ", title, source=sourcefile)) if (isDeprecated) title <<- paste("Deprecated: ", title, sep="") line <- paste("\\title{", title, "}", sep="") rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagEval <- function(bfr) { bfr <- getTagValue(bfr) value <- attr(bfr, "value") expr <- as.character(value) result <- eval(parse(text=expr)) line <- result rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tagInheritedmethods <- function(bfr) { methods <- Rdoc$methodsInheritedFrom(clazz, visibility, sort=sort) line <- methods rd <<- paste(rd, line, sep="") bfr } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tags <- list( "RdocClass" = tagRdocClass, "RdocGeneric" = tagRdocGeneric, "RdocFunction" = tagRdocFunction, "RdocDefault" = tagRdocDefault, "RdocMethod" = tagRdocMethod, "RdocObject" = tagRdocObject, "RdocData" = tagRdocData, "RdocDocumentation" = tagRdocDocumentation, "RdocAbout" = tagRdocAbout, "RdocPackage" = tagRdocPackage, # "classhierarchy" = tagClasshierarchy, # must be *before* "class". "synopsis" = tagSynopsis, "usage" = tagUsage, "keyword" = tagKeyword, # "Class" = tagRdocClass, "methodname" = tagRdocMethod, "name" = tagName, # "aliasmethod" = tagAliasMethod, # must be *before* "alias". # "aliasundocumented" = tagAliasUndocumented, # not useful. "alias" = tagAlias, "title" = tagTitle, # "class" = tagClass, "include" = tagInclude, "inheritedmethods" = "tagInheritedmethods", "examples" = tagExamples, "visibility" = tagVisibility, "get" = tagGet, "set" = tagSet, "author" = tagAuthor, "howtocite" = tagHowToCite, "seeclass" = tagSeeclass, "seemethod" = tagSeemethod, "seeothermethods" = tagSeeOtherMethods, "see" = tagSee, "methods" = tagMethods, "allmethods" = tagAllMethods, "eval" = tagEval ) names <- names(tags) attr(tags, "beginsWith") <- paste("^@", names, sep="") # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # SETUP # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Set the locale Sys.setlocale(locale=locale) # Make a best guess what the package is that is created by querying # the DESCRIPTION file, which should be in the parent directory of # the getManPath() directory. pkgPath <- dirname(getManPath(this)) pathname <- file.path(pkgPath, "DESCRIPTION") if (!file.exists(pathname)) { stop("Cannot infer package name. File not found: ", pathname) } pi <- read.dcf(file=pathname) package <- pi[,"Package", drop=TRUE] if (length(package) == 0L) { throw("Failed to infer package name. No 'Package' was listed in ", sQuote(pathname), ".") } if (length(package) > 1L) { throw("Failed to infer package name. More than one 'Package' were listed in ", sQuote(pathname), ": ", paste(sQuote(package), collapse=", ")) } Rdoc$package <- package class <- NULL clazz <- NULL Rdoc$source <- sourcefile <<- NULL rds <- list() for (rdoc in rdocs) { # Remember the name of the source file in case of an error... Rdoc$source <- sourcefile <<- attr(rdoc, "sourcefile") title <- NULL objectName <- NULL isDeprecated <- FALSE method <- NULL name <- NULL usage <- NULL visibility <- NULL # ============================================================== # 1. Replace all shorttags # # This can be vectorized since all shorttags are read only # and does not rely on any state of Rdoc etc. # This should speed up the process. # ============================================================== for (kk in seq_along(shorttags)) { replace <- attr(shorttags, "replace")[kk] # (a) Replace all occurances at the beginning of the lines. pattern <- attr(shorttags, "beginsWith")[kk] rdoc <- gsub(pattern, replace, rdoc) # (b) Replace all other occurances. ready <- FALSE while (!ready) { pattern <- attr(shorttags, "contains")[kk] pos <- regexpr(pattern, rdoc) idx <- (pos != -1L) if (any(idx)) { len <- attr(pos, "match.length")[idx] pos <- pos[idx] prefix <- substring(rdoc[idx], first=1L, last=pos) suffix <- substring(rdoc[idx], first=pos+len) rdoc[idx] <- paste(prefix, replace, suffix, sep="") } else { ready <- TRUE } } } # for (kk ...) # ============================================================== # 2. Compile the remaining lines # # This can *not* be vectorized since some tags may change the # state of the Rdoc compiler or set a local variable, which # will affect following tags. # ============================================================== # (a) Make on big string of the whole Rdoc comment. # This will simplify handling of line breaks within a tag # argument, e.g. when @title "Bla bla\nbla" exists. rdoc <- paste(rdoc, collapse="\n") # (b) Get the first occurance of a tag. # A tag begins with a '@', but can not have a letter, a # number or a '.' in front since then it could be a code # fragment refering to a S4 slot. patternL <- "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" pattern <- sprintf("[^%s0-9.]@", patternL) pattern2 <- sprintf("[^%s0-9]@", patternL) rd <- "" while (TRUE) { # (i) It can be that the tag start at position 1... pos <- regexpr("^@", rdoc) # (ii) ...otherwise... if (pos == -1L) { pos <- regexpr(pattern, rdoc) if (pos == -1L) break; # No more tags. Done! # Save everything before the tag... rd <- paste(rd, substring(rdoc, first=1L, last=pos), sep="") # ...and make the tag be at the first position. rdoc <- substring(rdoc, first=pos+1L) } if (debug) str(rdoc) # (iii) Identify the tag tagName <- NULL tagFunction <- NULL for (kk in seq_along(tags)) { patternKK <- attr(tags, "beginsWith")[kk] pos <- regexpr(patternKK, rdoc) if (pos != -1L) { len <- attr(pos, "match.length") tagIdx <- kk tagName <- names(tags)[kk] if (debug) cat(paste("Found tag: ", tagName, "\n", sep="")) tagFunction <- tags[[kk]] break } } # for (kk ...) if (!is.null(tagFunction)) { # Shift the Rdoc buffer rdoc <- substring(rdoc, first=len+1L) if (is.function(tagFunction)) { # Evaluate the tag function in the current environment # so all variables can be shared between tags. # All tag functions must return the resulting buffer! expr <- substitute(tagFunction(rdoc), list(tagFunction=tagFunction, rdoc=rdoc)) rdoc <- eval(expr) } } else { pos <- regexpr(pattern2, substring(rdoc, first=2L)) tagName <- substring(rdoc, first=1L, last=pos) msg <- sprintf("Unknown tag not processed in '%s': '%s'", sourcefile, tagName) warning(msg) rd <- paste(rd, substring(rdoc, first=1L, last=1L), sep="") rdoc <- substring(rdoc, first=2L) } if (isDeprecated && !showDeprecated) break } # while(TRUE), i.e. get first tag... if (showDeprecated || !isDeprecated) { # Do not forget to add the rest! rd <- paste(rd, rdoc, sep="") rdoc <- NULL # Append all keywords at the end rd <- paste(rd, getRdKeywords(), sep="\n") # Remove all empty lines rd <- gsub("[ \t]\n", "\n", rd) rd <- gsub("[ \t]\r", "\r", rd) if (is.null(name)) { # @RdocClass, @RdocDefault and/or @RdocMethod was not given. Search for classical \name{...} search <- regexpr("\\name\\{[^\\}]*\\}", rd) if (search == -1L) { throw(RdocException("The resulting Rd text does not have a \\name{} tag: ", substring(rd, first=1L, last=40L), source=sourcefile)) } name <- substring(rd, first=search+5L, last=search+attr(search, "match.length")-2) search <- regexpr("\\name\\{[^\\}]*\\}", substring(rd, first=search+1L)) if (search != -1L) throw(RdocException("The resulting Rd text has more than one \\name{} tag.", source=sourcefile)) } visibility <- "public" if (is.null(visibility)) { if (is.null(objectName)) { } else if (!exists(objectName)) { # If no object was found, assume that it is a Rdoc comment for # a non-object, i.e. a concept or similar. } else { object <- get(objectName) modifiers <- attr(object, "modifiers") if (is.element("private", modifiers)) { visibility <- "private" } else if (is.element("protected", modifiers)) { visibility <- "protected" } } } attr(rd, "visibility") <- as.character(visibility) attr(rd, "isDeprecated") <- isDeprecated attr(rd, "name") <- as.character(name) attr(rd, "sourcefile") <- sourcefile # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Check Rd code? # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if (check) { if (compareVersion(as.character(getRversion()), "2.10.0") >= 0) { # R v2.10.0 and newer tryCatch({ con <- textConnection(rd) rdParse <- tools::parse_Rd(file=con) }, warning = function(w) { filename <- sprintf("%s.Rd.ERROR", attr(rd, "name")) cat(rd, sep="\n", file=filename) throw(RdocException(sprintf("Syntax error in generated Rd code (see '%s') for Rdoc comment '%s' (in '%s') was detected by tools:parse_Rd(): %s", filename, attr(rd, "name"), attr(rd, "sourcefile"), as.character(w)))) }, finally = { close(con) con <- NULL }) } else { # R v2.9.2 and before tryCatch({ ns <- getNamespace("tools") tools_Rd_parse <- get("Rd_parse", mode="function", envir=ns) rdParse <- tools_Rd_parse(text=rd) if (length(rdParse$rest) > 0) { throw(RdocException("Unknown top-level text in generated Rd code for Rdoc comment '", attr(rd, "name"), "' (in '", attr(rd, "sourcefile"), "') (typically due to too many or a missing bracket): ", paste(rdParse$rest, collapse=", ", sep=""))) } }, error = function(e) { throw(RdocException("Syntax error in generated Rd code for Rdoc comment '", attr(rd, "name"), "' (in '", attr(rd, "sourcefile"), "') was detected by tools:Rd_parse(): ", as.character(e))) }) } } # if (check) rds <- c(rds, list(rd)) } else { warning(paste("No Rd file for '", objectName, "' was generated since it was declared deprecated.", sep="")) } # if (!isDeprecated) } # for (rdoc in rdocs) rds } # compileRdoc() # A local version of the sourceTo() in R.io. sourceTo <- function(..., local=TRUE, envir=parent.frame()) { # Wrap up the arguments to source args <- list(...) if (!is.element("file", names(args))) names(args)[1] <- "file" # Override any 'local' argument args$local <- local # Create a call expression to source(..., local=local) expr <- substitute({ do.call(source, args) }, list(args=args)) # Call source() eval(expr, envir=envir) } # sourceTo() # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Assert that the manPath exists. createManPath(this) filename <- as.character(filename) if (length(filename) == 1L && !file.exists(filename)) { if (regexpr("\\*", filename) != -1L || regexpr("\\?", filename) != -1L) { # Filename pattern pattern <- filename # List all files filename <- list.files() # Match to filename pattern filename <- grep(paste(pattern, "$", sep=""), filename, value=TRUE) # Keep only files filename <- filename[file_test("-f", filename)] # Keep only newer files? } } # Load the source code in case it contains new stuff. if (source) { lapply(filename, FUN=source) } for (file in filename) { if (verbose) cat("Generating Rd files from source file ", file, "...", sep="") rdocs <- extractRdocs(file, verbose=verbose, debug=debug) rd <- compileRdoc(rdocs, showDeprecated=showDeprecated, verbose=verbose, debug=debug) writeRd(rd, path=destPath, addTimestamp=addTimestamp, verbose=verbose, debug=debug) if (verbose) cat("\n") } if (check) { check(this, manPath=destPath, verbose=verbose) } }, static=TRUE) # compile() ###########################################################################/** # @RdocMethod hierarchy # # @title "Gets the class hierarchy" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("hierarchy", "Rdoc", function(this, class, ...) { package <- getPackage(class) s <- paste("Package: ", package, "\\cr\n") what <- if (inherits(class, "Class")) "Class" else "Interface" s <- paste(s, "\\bold{", what, " ", getName(class), "}\\cr\n\n", sep="") indent <- "" for (extend in rev(getSuperclasses(class))) { link <- sapply(extend, FUN=function(name) { # isAbstract <- FALSE link <- name if (exists(name, mode="function")) { cls <- get(name, mode="function") if (inherits(cls, "Class")) { pkg <- getPackage(cls) if (is.null(pkg)) link <- paste("\\link{", link ,"}", sep="") else link <- paste("\\link[", pkg, "]{", link ,"}", sep="") # if (isAbstract(cls)) { # link <- paste("\\emph{", link, "}", sep="") # isAbstract <- TRUE # } } } paste("\\code{", link ,"}", sep="") }) if (indent == "") { s <- paste(s, link, "\\cr\n", sep="") indent <- "~~" } else { s <- paste(s, "\\code{", indent, "+--}", link, "\\cr\n", sep="") indent <- paste(indent, "~~~~~", sep="") } s <- paste(s, "\\code{", indent, "|}\\cr\n", sep="") } link <- paste("\\code{", getName(class), "}", sep="") if (isAbstract(class)) link <- paste("\\emph{", link, "}", sep="") s <- paste(s, "\\code{", indent, "+--}", link, "\\cr\n\n", sep="") s }, private=TRUE, static=TRUE) ###########################################################################/** # @RdocMethod declaration # # @title "Gets the class declaration" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("declaration", "Rdoc", function(this, class, ...) { s <- "public"; # visibility(class) if (isAbstract(class)) s <- paste(s, "abstract") if (isStatic(class)) s <- paste(s, "static") if (inherits(class, "Class")) s <- paste(s, "class") else throw(getName(class), " is neither a class nor an interface.") s <- paste(s, " \\bold{", getName(class), "}\\cr\n", sep="") links <- getSuperclasses(class) if (length(links) > 0) { name <- links[1] link <- name if (exists(name, mode="function")) { cls <- get(name, mode="function") if (inherits(cls, "Class")) { pkg <- getPackage(cls) if (is.null(pkg)) link <- paste("\\link{", link ,"}", sep="") else link <- paste("\\link[", pkg, "]{", link ,"}", sep="") if (isAbstract(cls)) link <- paste("\\emph{", link, "}", sep="") } } paste("\\code{", link ,"}", sep="") s <- paste(s, "extends ", link, "\\cr\n", sep="") } s }, private=TRUE, static=TRUE) ###########################################################################/** # @RdocMethod methodsInheritedFrom # # @title "Gets all methods inherited from a class in Rd format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("methodsInheritedFrom", "Rdoc", function(this, class, visibility=c("public", "protected", "private"), showDeprecated=FALSE, inheritedFrom=NULL, sort=TRUE, trial=FALSE, ...) { s <- "" private <- is.element("private", visibility) # Classes for (extend in getSuperclasses(class)) { # Try to find a Class object with this name. clazz <- NULL tryCatch({ clazz <- Class$forName(extend) }, error = function(ex) {}) if (is.null(clazz)) { # Use methods() to find methods methods <- methods(class=extend) pattern <- paste("[.]", extend, "$", sep="") methods <- gsub(pattern, "", methods) } else { # Get all methods of this Class methods <- getMethods(clazz, private=private, deprecated=showDeprecated) methods <- methods[[extend]] methods <- names(methods) } if (length(methods) > 0) { methods <- paste(methods, collapse=", ") s <- paste(s, sprintf("\\bold{Methods inherited from %s}:\\cr\n", extend)) s <- paste(s, methods, "\n\n", sep="") } } s }, private=TRUE, static=TRUE) setMethodS3("getObject", "Rdoc", function(static, name, mode="any", package=static$package, ...) { # Search for object in: # (i) the package names iff found, then # (ii) then the search path. # Try to infer the package's namespace. ns <- NULL if (is.character(package)) { tryCatch({ ns <- getNamespace(package) }, error = function(ex) {}) } if (is.environment(ns) && exists(name, mode=mode, envir=ns)) { obj <- get(name, mode=mode, envir=ns) } else if (exists(name, mode=mode)) { obj <- get(name, mode=mode) } else { throw("Failed to locate object of mode \"", mode, "\": ", name) } obj }, private=TRUE, static=TRUE) ###########################################################################/** # @RdocMethod getUsage # # @title "Gets the usage of a method" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{method}{A method name (@character string).} # \item{class}{An optional class name (@character string).} # \item{wrap}{An @integer specifying the maximum number of characters per line. Longer lines will be wrapped with newlines.} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getUsage", "Rdoc", function(static, method, class=NULL, wrap=90L, indent=2L, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - buildUsage <- function(method, class=NULL, args, valueArg=NULL, wrap=90L, head=NULL, ...) { # Argument 'args': stopifnot(is.list(args)) indentStr <- paste(rep(" ", times=indent), collapse="") correction <- 0L if (length(head) == 0L) { if (is.null(class)) { head <- method # Escape '%*%' to '\%*\%' head <- gsub("%", "\\%", head, fixed=TRUE) # Quote any method name containing '%' if (regexpr("%", head, fixed=TRUE) != -1L) head <- sprintf("`%s`", head) } else { # The effective length of this in the help manual is nchar(method). head <- sprintf("\\method{%s}{%s}", method, class) correction <- nchar(head) - nchar(method) } } correction0 <- correction lines <- NULL line <- paste(head, "(", sep="") if (length(args) == 0L) { line <- paste(line, ") ", sep="") } while (length(args) > 0L) { subargs <- args[[1L]] nsubargs <-length(subargs) # Try to keep = together if (nsubargs >= 3L) { # If = fit on a line, then keep the together... if (sum(nchar(subargs[1:3L])) <= wrap) { subargs[3L] <- paste(subargs[1:3], collapse="") subargs <- subargs[-(1:2)] } else if (sum(nchar(subargs[1:2L])) <= wrap) { # ...otherwise, at least keep = together, iff possible. subargs[2L] <- paste(subargs[1:2], collapse="") subargs <- subargs[-1L] } nsubargs <-length(subargs) } # Remaining arguments args <- args[-1L] nargs <- length(args) suffix <- if (nargs > 0L) ", " else ") " # For each subargument for (kk in seq_len(nsubargs)) { subarg <- subargs[kk] ## str(list(kk=kk, subarg=subarg)) if (kk == nsubargs) { subarg <- paste(subarg, suffix, sep="") } else { subarg <- paste(subarg, " ", sep="") } len <- nchar(subarg) # Does argument fit on the same line? if (nchar(line) - correction + len <= wrap) { line <- paste(line, subarg, sep="") } else { lines <- c(lines, line) line <- paste(indentStr, subarg, sep="") correction <- 0L } } # for (kk ...) } # while (length(args) > 0L) # Append a value assignment, i.e. "... <- value"? if (!is.null(valueArg)) { arg <- paste("<- ", valueArg, sep="") # Does it fit on the same line? if (nchar(line) - correction + nchar(arg) <= wrap) { line <- paste(line, arg, sep="") } else { lines <- c(lines, line) line <- paste(indentStr, arg, sep="") } } lines <- c(lines, line) lines <- gsub("[ ]$", "", lines); # Trim trailing space # Sanity check lens <- nchar(lines) lens[1L] <- lens[1L] - correction0 stopifnot(all(lens <= wrap)) ## print(lines) lines } # buildUsage() if (!is.null(class)) { fcnName <- paste(method, class, sep=".") } else { fcnName <- method } fcn <- NULL tryCatch({ fcn <- getObject(static, name=fcnName, mode="function") }, error = function(ex) { cat("Failed...\n") print(ex) cat("Failed...done\n") }) if (!is.function(fcn)) { throw(RdocException("Could not get usage. Function was not found: ", fcnName, "()", source=Rdoc$source)) } isStatic <- is.element("static", attr(fcn, "modifiers")) isConstructor <- inherits(fcn, "Class") args <- Rdoc$argsToString(fcn, escapeRd=TRUE, collapse=FALSE) # Replacement methods are special isReplacement <- (regexpr("<-$", method) != -1L) if (isReplacement) { method <- gsub("<-$", "", method) nargs <- length(args) valueArg <- args[nargs] args <- args[-nargs] } else { valueArg <- NULL } if (isConstructor) { usage <- buildUsage(method, args=args, valueArg=valueArg, wrap=wrap) } else if (isStatic) { # (a) The S3 method call lines <- buildUsage(method, class=class, args=args, valueArg=valueArg, wrap=wrap) usageM <- paste(lines, collapse="\n") # (b) The "static" method call, e.g. Class$forName(...) # Adjust line width ('wrap') to fit prefix '## ' as well. lines <- buildUsage(method, class=class, args=args[-1L], valueArg=valueArg, head=paste(class, method, sep="$"), wrap=wrap - 3L) lines <- paste("## ", lines, sep="") usageS <- paste(lines, collapse="\n") # (c) Combine usage <- c("## Static method (use this):", usageS, "", "## Don't use the below:", usageM) } else if (!is.null(class)) { usage <- buildUsage(method, class=class, args=args, valueArg=valueArg, wrap=wrap) } else { usage <- buildUsage(method, args=args, valueArg=valueArg, wrap=wrap) } usage }, private=TRUE, static=TRUE) # getUsage() ###########################################################################/** # @RdocMethod getClassS4Usage # # @title "Gets the usage of a S4 class" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{class}{A class name (@character string).} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getClassS4Usage", "Rdoc", function(static, class, ...) { if (!inherits(class, "classRepresentation")) throw(InternalErrorException("Wrong usage.")) name <- class@className usage <- paste("new(", name, ")", sep="") hasConstructor <- exists(name, mode="function") if (hasConstructor) { constructor <- get(name, mode="function") args <- Rdoc$argsToString(constructor, collapse=TRUE) args <- paste(args, collapse=", ") constructorUsage <- paste(name, "(", args, ")", sep="") usage <- paste(usage, "\n", constructorUsage, sep="") } usage }, private=TRUE, static=TRUE) ###########################################################################/** # @RdocMethod argsToString # # @title "Gets the arguments signature of a function" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{fcn}{A @function.} # \item{escapeRd}{If @TRUE, certain Rd markup symbols are escaped.} # \item{collapse}{If @TRUE, each argument is returned as a single string, # otherwise split up into a vector of strings as far as possible.} # \item{...}{Not used.} # } # # \value{ # Returns a @list of @character strings. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("argsToString", "Rdoc", function(static, fcn, escapeRd=FALSE, collapse=TRUE, ...) { a <- args(fcn) # Nothing to do? if (is.null(a)) { return("[primitive function]") } # Sanity check if (typeof(a) != "closure") { throw("Expected closure but found something else: ", typeof(a)) } args <- formals(a) argsNames <- names(args) res <- list() for (kk in seq_along(args)) { arg <- args[kk] argName <- argsNames[kk] s <- argName argDefault <- arg[[1L]] if (!missing(argDefault)) { argDefault <- deparse(argDefault, width.cutoff=20L) argDefault <- trim(argDefault) # Escape '%' (which is a comment in Rd format)? if (escapeRd) { argDefault <- gsub("\\%", "\\\\%", argDefault) } if (collapse) { argDefault <- paste(argDefault, collapse=" ") s <- paste(s, "=", argDefault, sep="", collapse="") } else { s <- c(s, "=", argDefault) } } res <- c(res, list(s)) } res }, private=TRUE, static=TRUE) # argsToString() ###########################################################################/** # @RdocMethod getRdTitle # # @title "Extracts the title string of a Rd file" # # \description{ # @get "title" corresponding the the specified method of the specified class. # } # # @synopsis # # \arguments{ # \item{method}{The method to be search for.} # \item{class}{The class the method belongs to.} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getRdTitle", "Rdoc", function(this, class, method, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - tools_fetchRdDB <- get("fetchRdDB", mode="function", envir=getNamespace("tools"), inherits=FALSE) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # e s c a p e N a m e ( ) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - escapeName <- function(name) { name <- gsub("\\#", "POUND", name) name <- gsub("\\$", "DOLLAR", name) name <- gsub("\\%", "PERCENT", name) name <- gsub("\\&", "AND", name) name <- gsub("\\~", "TILDE", name) name <- gsub("\\_", "UNDERSCORE", name) name <- gsub("\\^", "POWER", name) name <- gsub("\\\\", "BACKSLASH", name) name <- gsub("\\{", "LCURLY", name) name <- gsub("\\}", "RCURLY", name) name <- gsub("<-", "< -", name) name } # escapeName() title <- NULL # Search for the file ..Rd in the man/ directory name <- createName.Rdoc(NULL, getName(class), method, escape=FALSE) name <- escapeName(name) rdName <- Rdoc$escapeRdFilename(name) rdFile <- paste(rdName, "Rd", sep=".") url <- file.path(getManPath(this), rdFile) if (file.exists(url)) { src <- paste(readLines(url, warn=FALSE), collapse="\n") # Search for \title{...} in the Rd source titlePos <- regexpr("\\title\\{[^\\}]*}", src) if (titlePos == -1) { warning(paste("Could not find a \\title{} definition in the Rd file for ", method, " in ", getName(class), ". Will search in loaded packages.", sep="")) "" } else { title <- trim(substring(src, first=titlePos+6, last=titlePos+attr(titlePos, "match.length")-2)) } } else { warning(paste("The Rd file for ", method, " in ", getName(class), " could not be found. Will search in loaded packages.", sep="")) } if (is.null(title)) { methodName <- paste(method, ".", getName(class), sep="") packageName <- Rdoc$getPackageNameOf(methodName, mode="function") if (length(packageName) == 1) { if (compareVersion(as.character(getRversion()), "2.10.0") >= 0) { # R v2.10.0 and newer path <- system.file("help", package=packageName) filebase <- file.path(path, packageName) tryCatch({ entry <- tools_fetchRdDB(filebase, key=methodName) tags <- lapply(entry, FUN=attr, "Rd_tag") idx <- which(tags == "\\title") if (length(idx) > 1) { idx <- idx[1] } if (length(idx) == 1) { entry <- entry[[idx]] entry <- entry[[1]] title <- entry[1] } }, error = function(ex) { warning(as.character(ex)) }) } else { package <- Package(packageName) tryCatch({ contents <- getContents(package) pos <- which(contents[,"Entry"] == name) if (length(pos) == 0) { warning(paste("Reverted to the CONTENTS file of package '", packageName, "', but found not matching entry: ", name, sep="")) } else if (length(pos) > 2) { warning(paste("Found more than one matching entry in the CONTENTS file of package '", packageName, "'. Using the first one only: ", name, sep="")) pos <- pos[1] } if (length(pos) != 0) { title <- as.character(contents[pos, "Description"]) attr(title, "package") <- packageName } }, error=function(ex) { warning(as.character(ex)) }) } } } title }, private=TRUE, static=TRUE) ###########################################################################/** # @RdocMethod getPackageNameOf # # @title "Gets the package of a method or an object" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{objectName}{An method or object name (@character string).} # \item{mode}{Mode of object (@character string).} # \item{unique}{If @TRUE, only the first matching package is returned if # more than one is found.} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("getPackageNameOf", "Rdoc", function(static, objectName, mode="any", unique=TRUE, ...) { # Search all namespaces that are *attached* pkgs <- grep("^package:", search(), value=TRUE) pkgs <- gsub("^package:", "", pkgs) found <- sapply(pkgs, FUN=function(pkg) { exists(objectName, mode=mode, envir=asNamespace(pkg)) }) package <- names(found)[found] if (length(package) == 1L) return(package) if (length(package) > 1L && unique) { warning("Found more than one occurance of '", objectName, "' among the attached namespaces. Will only return the first one: ", paste(sQuote(package), collapse=", ")) return(package[1L]) } # If not found, then search any other namespace *loaded* pkgs <- setdiff(loadedNamespaces(), pkgs) found <- sapply(pkgs, FUN=function(pkg) { exists(objectName, mode=mode, envir=asNamespace(pkg)) }) package <- names(found)[found] if (length(package) == 1L) return(package) if (length(package) > 1L && unique) { warning("Found more than one occurance of '", objectName, "' among the loaded namespaces. Will only return the first one: ", paste(sQuote(package), collapse=", ")) return(package[1L]) } character(0L) }, private=TRUE, static=TRUE) ###########################################################################/** # @RdocMethod check # # @title "Checks the compiled Rd files" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{manPath}{The path to the Rd files (@character string).} # \item{verbose}{If @TRUE, extra information is outputted.} # \item{...}{Not used.} # } # # \value{ # Returns a printable object, which, if non-empty will show the errors. # } # # \details{ # Internally the \code{tools} package is used. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("check", "Rdoc", function(this, manPath=getManPath(this), verbose=FALSE, ...) { # file paths with trailing '/' are not recognized! /HB 2004-10-13 manPath <- gsub("/$", "", manPath) if (verbose) cat("Checking Rd files in '", manPath, "'...\n", sep="") if (compareVersion(as.character(getRversion()), "2.10.0") >= 0) { # For R (>= 2.10.0) pathnames <- list.files(pattern="[.]Rd$", path=manPath, full.names=TRUE) res <- NULL for (kk in seq_along(pathnames)) { pathname <- pathnames[kk] res <- tools::checkRd(pathname) } } else { # For R (< 2.10.0) tools_check_Rd_files_in_man_dir <- get("check_Rd_files_in_man_dir", mode="function", envir=getNamespace("tools"), inherits=FALSE) res <- tools_check_Rd_files_in_man_dir(manPath) if (length(res$files_with_surely_bad_Rd) > 0) { throw("Syntax error in Rd file(s): ", paste(res$files_with_surely_bad_Rd, collapse=", ")) } if (length(res$files_with_likely_bad_Rd) > 0) { print(res$files_with_likely_bad_Rd) throw("Syntax error in Rd file(s): ", paste(res$files_with_surely_bad_Rd, collapse=", ")) } } if (verbose) cat("Checking Rd files in '", manPath, "'...done\n", sep="") res }) ###########################################################################/** # @RdocMethod isVisible # # @title "Checks if a member is visible given its modifiers" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{modifiers}{A @character string of modifiers.} # \item{visibilities}{A @character string of visibility flags.} # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the modifiers are equal or higher than the visibility # flags, otherwise @FALSE. # } # # @author # # \seealso{ # @seeclass # } # # @keyword documentation #*/########################################################################### setMethodS3("isVisible", "Rdoc", function(static, modifiers, visibilities, ...) { if (is.element("deprecated", modifiers) && !is.element("deprecated", visibilities)) return(FALSE) if (is.element("trial", modifiers) && !is.element("trial", visibilities)) return(FALSE) levels <- c("private", "protected", "public") modifiers <- intersect(modifiers, levels) if (length(modifiers) == 0) return(TRUE) visibilities <- intersect(visibilities, levels) if (length(visibilities) == 0) return(TRUE) modifiers <- factor(modifiers, levels=levels) visibilities <- factor(visibilities, levels=levels) any(as.integer(visibilities) <= as.integer(modifiers)) }, static=TRUE, protected=TRUE) # isVisible() R.oo/R/999.NonDocumentedObjects.R0000644000176200001440000000705214554071363016034 0ustar liggesusers###########################################################################/** # @RdocDocumentation "Non-documented objects" # # % The BasicObject class # @alias getInstanciationTime.default # @alias isReferable # # % The Class class # @alias forName # @alias getDetails # @alias getKnownSubclasses # @alias getMethods # @alias getMethods.default # @alias getName # @alias getPackage # @alias getStaticInstance # @alias getSuperclasses # @alias isAbstract # @alias isBeingCreated # @alias isDeprecated # @alias isPrivate # @alias isProtected # @alias isPublic # @alias isStatic # @alias newInstance # # % The Exception class # @alias getCalls # @alias getCall # @alias getLastException # @alias getMessage # @alias getStackTrace # @alias getStackTraceString # @alias getWhen # @alias printStackTrace # # % The Object class # @alias attach # @alias attach.default # @alias attachLocally # @alias clone # @alias clearLookupCache # @alias clearCache # @alias detach # @alias detach.default # @alias finalize # @alias getFields # @alias getInstanciationTime # @alias getInstanciationTime.default # @alias getInstantiationTime # @alias getInternalAddress # @alias getFieldModifier # @alias getFieldModifiers # @alias hasField # @alias load # @alias load.default # @alias novirtual # @alias registerFinalizer # @alias save # @alias save.default # @alias staticCode # # % The Package class # @alias getAuthor # @alias getBundle # @alias getBundlePackages # @alias getChangeLog # @alias getClasses # @alias getClasses.default # @alias getContribUrl # @alias getContents # @alias getDataPath # @alias getDate # @alias getDescription # @alias getDescriptionFile # @alias getDevelUrl # @alias getDocPath # @alias getEnvironment # @alias getExamplePath # @alias getHistory # @alias getHowToCite # @alias getLicense # @alias getMaintainer # @alias getManPath # @alias getNews # @alias getPath # @alias getPosition # @alias getTitle # @alias getUrl # @alias getVersion # @alias isLoaded # @alias isOlderThan # @alias showChangeLog # @alias showContents # @alias showDescriptionFile # @alias showHistory # @alias showHowToCite # @alias showNews # @alias startupMessage # @alias unload # # % The RccViolationException class # @alias getRccUrl # # % The Rdoc class # @alias argsToString # @alias check # @alias compile # @alias createManPath # @alias createName # @alias declaration # @alias escapeRdFilename # @alias getClassS4Usage # @alias getKeywords # @alias getNameFormat # @alias getObject # @alias getObject.Rdoc # @alias getPackageNameOf # @alias getRdDeclaration # @alias getRdHierarchy # @alias getRdMethods # @alias getRdTitle # @alias getUsage # @alias hierarchy # @alias isKeyword # @alias isVisible # @alias methodsInheritedFrom # @alias setManPath # @alias setNameFormat # # % The RdocException class # @alias getSource # # % Trial functions # @alias callSuperMethodS3 # @alias callSuperMethodS3.default # # % Deprecated functions # @alias setClassS3 # @alias setClassS3.default # @alias getClass.BasicObject # @alias getClass.default # # \description{ # This page contains aliases for all "non-documented" objects that # \code{R CMD check} detects in this package. # # Almost all of them are \emph{generic} functions that have specific # document for the corresponding method coupled to a specific class. # Other functions are re-defined by \code{setMethodS3()} to # \emph{default} methods. Neither of these two classes are non-documented # in reality. # The rest are deprecated methods. # } # # @author # # @keyword internal #*/########################################################################### R.oo/R/Interface.R0000644000176200001440000001075414554071363013332 0ustar liggesusers###########################################################################/** # @RdocClass Interface # # @title "The Interface class" # # \description{ # @classhierarchy # # This class represents a special set of classes whose purpose is to # provide methods (but not fields) shared by multiple different classes. # } # # @synopsis # # \arguments{ # \item{core}{The core value.} # \item{...}{Not used.} # } # # \section{Methods}{ # @allmethods "public" # } # # @author # @keyword internal #*/########################################################################### setConstructorS3("Interface", function(core=NA, ...) { this <- core class(this) <- "Interface" this }, private=TRUE) ###########################################################################/** # @RdocMethod extend # # @title "Extends another Interface class" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...className}{The name of new interface.} # \item{...}{Named values representing the fields of the new instance.} # } # # \value{ # Returns an Interface of class \code{className}. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("extend", "Interface", function(this, ...className, ...) { class(this) <- unique(c(...className, class(this))) this }) ###########################################################################/** # @RdocMethod uses # @alias uses # @alias uses.character # # @title "Specifies that an object uses this Interface" # # \description{ # @get "title". # } # # @synopsis # # \value{ # Returns a @character @vector of class names of Interface:s. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("uses", "Interface", function(this, ...) { res <- setdiff(class(this), "Interface") if (length(list(...)) > 0) { res <- c(list(res), list(uses(...))) # Order interfaces/classes names <- sort(unique(unlist(res, use.names=FALSE))) idxs <- integer(length(names)) names(idxs) <- names for (kk in seq_along(res)) { for (name in res[[kk]]) { idxs[name] <- kk } } for (kk in seq_along(res)) { keep <- (idxs[res[[kk]]] == kk) res[[kk]] <- res[[kk]][keep] } res <- unlist(res, use.names=FALSE) } res }) setMethodS3("uses", "character", function(className, ...) { clazz <- Class$forName(className) obj <- newInstance(clazz) uses(obj, ...) }) ###########################################################################/** # @RdocMethod as.character # # @title "Gets a character string representing the Interface" # # \description{ # @get "title". # } # # @synopsis # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("as.character", "Interface", function(x, ...) { # To please R CMD check this <- x # Check if there are class "after" this one pos <- which("Interface" == class(this)) isLast <- (pos == length(class(this))) if (isLast) { s <- paste(class(this), collapse=", ") } else { s <- NextMethod() } s }, private=TRUE) ###########################################################################/** # @RdocMethod print # # @title "Prints an Interface" # # \description{ # For all objects of class @see "Interface", this method will print the # value of \code{as.character()} of the object. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("print", "Interface", function(x, ...) { # To please R CMD check this <- x print(as.character(this), ...) }) ###########################################################################/** # @RdocMethod getFields # # @title "Returns NULL" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Ignored.} # } # # \value{ # Always returns @NULL. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} #*/########################################################################### setMethodS3("getFields", "Interface", function(...) { NULL }, private=TRUE) R.oo/R/classRepresentation.misc.R0000644000176200001440000001124114554071363016404 0ustar liggesusers###########################################################################/** # @set "class=classRepresentation" # # @RdocMethod getKnownSubclasses # @keyword internal # # @title "Gets the known subclasses" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # @keyword documentation #*/########################################################################### setMethodS3("getKnownSubclasses", "classRepresentation", function(this, ...) { this@subclasses$signature }) ###########################################################################/** # @RdocMethod getSuperclasses # @keyword internal # # @title "Gets the superclasses" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # @keyword documentation #*/########################################################################### setMethodS3("getSuperclasses", "classRepresentation", function(this, ...) { superClasses <- NULL for (contain in attr(this, "contains")$vector) { superClasses <- c(superClasses, contain@superClass) } superClasses }) ###########################################################################/** # @RdocMethod getRdHierarchy # @keyword internal # # @title "Gets the class hierarchy in Rd format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # @keyword documentation #*/########################################################################### setMethodS3("getRdHierarchy", "classRepresentation", function(this, ...) { package <- "???" name <- this@className superClasses <- getSuperclasses(this) s <- paste("Package: ", package, "\\cr\n") s <- paste(s, "\\bold{Class ", name, "}\\cr\n\n", sep="") indent <- "" for (extend in rev(superClasses)) { link <- sapply(extend, FUN=function(name) { link <- name if (isClass(name)) { cls <- getClass(name) link <- paste("\\link{", link ,"}", sep="") } paste("\\code{", link ,"}", sep="") }) if (indent == "") { s <- paste(s, link, "\\cr\n", sep="") indent <- "~~" } else { s <- paste(s, "\\code{", indent, "+--}", link, "\\cr\n", sep="") indent <- paste(indent, "~~~~~", sep="") } s <- paste(s, "\\code{", indent, "|}\\cr\n", sep="") } link <- paste("\\code{", name, "}", sep="") s <- paste(s, "\\code{", indent, "+--}", link, "\\cr\n\n", sep="") s }, private=TRUE) ###########################################################################/** # @RdocMethod getRdDeclaration # @keyword internal # # @title "Gets the class declaration in Rd format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # @keyword documentation #*/########################################################################### setMethodS3("getRdDeclaration", "classRepresentation", function(this, ...) { name <- this$className s <- "public"; # visibility(this) s <- paste(s, "class") s <- paste(s, " \\bold{", name, "}\\cr\n", sep="") links <- getSuperclasses(this) if (length(links) > 0) { name <- links[1] link <- name # TO DO/FIX ME: This part only works when packages are attached. # /HB 2013-10-08 if (exists(name, mode="function")) { cls <- get(name, mode="function") if (inherits(cls, "Class")) { pkg <- getPackage(cls) if (is.null(pkg)) link <- paste("\\link{", link ,"}", sep="") else link <- paste("\\link[", pkg, "]{", link ,"}", sep="") if (isAbstract(cls)) link <- paste("\\emph{", link, "}", sep="") } } paste("\\code{", link ,"}", sep="") s <- paste(s, "extends ", link, "\\cr\n", sep="") } s }, private=TRUE) ###########################################################################/** # @RdocMethod getRdMethods # @keyword internal # # @title "Gets the methods in Rd format" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{visibility}{-} # \item{trial}{-} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # @keyword documentation #*/########################################################################### setMethodS3("getRdMethods", "classRepresentation", function(class, visibility=c("public", "protected", "private"), trial=FALSE, ...) { src <- NULL src <- paste(src, "\\emph{No methods defined}.\n", sep="") src }, private=TRUE) R.oo/R/006.fixVarArgs.R0000644000176200001440000000241214711062254013774 0ustar liggesusers# Added '...' to some base functions. These will later be # turned into default functions by setMethodS3(). # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Methods in 'base' # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # USED TO DO: attach <- appendVarArgs(attach) attach <- function(...) UseMethod("attach") setMethodS3("attach", "default", function(...) { base::attach(...) }) # USED TO DO: detach <- appendVarArgs(attach) detach <- function(...) UseMethod("detach") setMethodS3("detach", "default", function(...) { base::detach(...) }) # USED TO DO: load <- appendVarArgs(load) load <- function(...) UseMethod("load") setMethodS3("load", "default", function(..., envir=parent.frame()) { base::load(..., envir=envir) }) # USED TO DO: save <- appendVarArgs(load) save <- function(...) UseMethod("save") setMethodS3("save", "default", function(..., envir=parent.frame()) { base::save(..., envir=envir) }) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Methods in 'methods' # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - getClasses <- appendVarArgs(getClasses) ## Defunct in R (>= 4.5.0) if (getRversion() < "4.5.0") { getMethods <- appendVarArgs(getMethods) } R.oo/R/RdocException.R0000644000176200001440000000430714554071363014175 0ustar liggesusers###########################################################################/** # @RdocClass RdocException # # @title "RdocException are thrown by the Rdoc compiler" # # \description{ # @classhierarchy # # @get "title" when it fails to generate a Rd file from an Rdoc comment. # } # # @synopsis # # \arguments{ # \item{...}{Any arguments accepted by @Exception}. # \item{source}{Object specifying the source where the Rdoc error occurred. # This is commonly a filename @character string.}. # } # # \section{Fields and Methods}{ # @allmethods # } # # @author # # \seealso{ # For detailed information about exceptions see @Exception. # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setConstructorS3("RdocException", function(..., source=NULL) { extend(Exception(...), "RdocException", .source = source ) }) ###########################################################################/** # @RdocMethod as.character # # \title{Gets a character string representing of the RdocException} # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("as.character", "RdocException", function(x, ...) { # To please R CMD check this <- x paste("[", getWhen(this), "] ", class(this)[1L], " in ", getSource(this), ": ", getMessage(this), sep = "") }) ###########################################################################/** # @RdocMethod getSource # # \title{Gets the source of the exception} # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns the source. # } # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getSource", "RdocException", function(x, ...) { x$.source }) R.oo/R/ll.default.R0000644000176200001440000002152514554071363013462 0ustar liggesusers###########################################################################/** # @RdocDefault ll # # @title "Generates a list of informative properties of all members of an environment" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{pattern}{Regular expression pattern specifying which members to # return. If \code{".*"}, all names are matched.} # \item{...}{A named @vector of format \code{functionName=value}, where # \code{functionName()} will be called on each member found. If the # result matches the \code{value}, the member is returned, otherwise # not.} # \item{private}{If @TRUE, also private members, i.e. members with # a name starting with a @. (period), will be listed, otherwise not.} # \item{properties}{Names of properties to be returned. There must exist # a @function with the same name, because it will be called. This way # one can extract any type of property by defining new methods.} # \item{sortBy}{Name or index of column (property) to be sorted by. # If @NULL, the objects are listed in the order they are found.} # \item{decreasing}{A @logical indicating whether the sorting should # be done in increasing or decreasing order.} # \item{envir}{An @environment, a search path index or a name of a package # to be scanned.} # } # # \value{ # Returns a @data.frame containing information about all the members. # } # # \section{Default properties returned}{ # It is possible to set the default value of argument \code{properties} # by setting option \code{"R.oo::ll/properties"}, e.g. # \code{options("R.oo::ll/properties"=c("data.class", "dimension"))}. # If this option is not set when the package is loaded, it is set to # \code{c("data.class", "dimension", "objectSize")}. # } # # \examples{ # \dontrun{ # To list all objects in .GlobalEnv: # > ll() # member data.class dimension objectSize # 1 *tmp* Person 1 428 # 2 as.character.Person function NULL 1208 # 3 country character 1 44 # 4 equals.Person function NULL 2324 # 5 filename character 1 84 # 6 getAge function NULL 372 # 7 getAge.Person function NULL 612 # 8 getName.Person function NULL 628 # 9 hashCode.Person function NULL 1196 # 10 last.warning list 1 192 # 11 obj Person 1 428 # 12 Person Class NULL 2292 # 13 setAge function NULL 372 # 14 setAge.Person function NULL 2088 # 15 setName function NULL 372 # 16 setName.Person function NULL 760 # 17 staticCode.Person function NULL 2372 # # To list all functions in the methods package: # ll(mode="function", envir="methods") # # To list all numeric and character object in the base package: # ll(mode=c("numeric", "character"), envir="base") # # To list all objects in the base package greater than 40kb: # subset(ll(envir="base"), objectSize > 40000) # } # } # # @author # # \seealso{ # @see "utils::ls.str" and @see "ll.Object". # } # # \keyword{utilities} #*/########################################################################### setMethodS3("ll", "default", function(pattern=".*", ..., private=FALSE, properties=getOption("R.oo::ll/properties", c("data.class", "dimension", "objectSize")), sortBy=NULL, decreasing=FALSE, envir=parent.frame()) { # AD HOC: Workaround to make sure property functions can be found. # This is because they are currently search for via the global # environment. /HB 2013-07-11 require("R.oo") || throw("Package not loaded: R.oo") # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Validate arguments # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Argument 'envir': if (is.numeric(envir)) { envir <- as.environment(envir) } else if (is.character(envir)) { search <- gsub("^package:", "", search()) pos <- which(search == envir) envir <- as.environment(pos) } members <- ls(envir=envir, all.names=private) # Any members at all? if (length(members) == 0L) return(data.frame()) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Keep members whose names match the pattern # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if (!is.null(pattern)) { matches <- regexpr(pattern, members) members <- members[matches != -1L] if (length(members) == 0L) return(data.frame()) } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Filter out members that to not match the search criteria according to "...". # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - args <- list(...) if (length(args) > 0L) { # Precreate a function to filter out members to be returned names <- names(args) expr <- NULL for (kk in seq_along(args)) { value <- args[[kk]] if (is.null(value)) { e <- substitute(is.null(fcn(..object)), list(fcn=as.name(names[kk]))) } else { e <- substitute(is.element(fcn(..object), value), list(fcn=as.name(names[kk]), value=value)) } if (is.null(expr)) { expr <- e } else { expr <- substitute(expr && e, list(expr=expr, e=e)) } } # for (kk ...) # expr <- substitute(filter <- function(name) { # eval(substitute(expr, list(..object=as.name(name))), envir=envir) # }, list(expr=expr, envir=envir)) # Now, create the filter() function # eval(expr) # Replaces the above construct. filter <- eval(substitute({ function(name) { ..object <- get(name, envir=envir) eval(expr, envir=envir) } }, list(expr=expr))) # Filter out members keep <- c() for (member in members) { # Keep the member or not? if (filter(member)) keep <- c(keep, member) } if (length(keep) == 0L) return(data.frame()) members <- keep } if (length(properties) == 0L || identical(properties, "")) return(data.frame(member=members)) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Generate a data frame row by row where each row contains the name of the # member and the properties as character strings. # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Precreate a function returning a row in the resulting data frame expr <- expression() for (property in properties) { e <- substitute({ ..exp <- substitute(propertyFcn(object), list(propertyFcn=as.name(property), object=..object)) ..value <- eval(..exp, envir=globalenv()) if (is.null(..value)) { ..value <- "NULL" } else if (is.vector(..value) && length(..value) > 1L) { ..value <- sprintf("c(%s)", paste(..value, collapse=",")) } else if (is.list(..value)) { ..value <- unlist(..value) } if (length(..value) > 0L) { ..value <- ..value[1L] } }, list(property=property)) expr <- substitute({expr; e; ..row <- cbind(..row, ..value);}, list(expr=expr,e=e)) } df <- NULL for (member in members) { if (is.element(member, c("..."))) { dfRow <- c(member, rep(NA_character_, times=length(properties))) dfRow <- as.list(dfRow) } else { rowExpr <- substitute({ ..row <- list(name) ..object <- get(name, envir=envir) expr }, list(name=member, member=as.name(member), expr=expr)) dfRow <- eval(rowExpr) } if (is.null(df)) { df <- dfRow } else { for (kk in seq_along(df)) { df[[kk]] <- c(df[[kk]], dfRow[[kk]]) } } } attributes(df) <- NULL names(df) <- c("member", properties) df <- as.data.frame(df) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Sort data frame? # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if (!is.null(sortBy)) { if (is.numeric(sortBy)) pos <- sortBy else pos <- pmatch(sortBy, colnames(df)) if (is.na(pos) || pos > ncol(df)) throw("The column to sort by does not exist: ", sortBy) by <- df[,pos] # We know that the first column always contains character strings... if (pos > 1L) { sortBy <- colnames(df)[pos] # Figure out the data type of the sort column dummy <- eval(substitute(property(2), list(property=as.name(sortBy)))) mode(by) <- mode(dummy) } # Finally, sort the result table df <- df[order(by, decreasing=decreasing),] } as.data.frame(df) }) # ll.default() R.oo/R/RccViolationException.R0000644000176200001440000000667314554071363015712 0ustar liggesusers###########################################################################/** # @RdocClass RccViolationException # # @title "An RccViolationException indicates a violation of the R Coding Conventions (RCC)" # # \description{ # @classhierarchy # # @get "title". # It is generated by \code{setConstructorS3()} and \code{setMethodS3()}. # It is \emph{not} meant to be caught, but instead the source code that # violates the RCC should be fixed. For more information about RCC, see # references below. # } # # @synopsis # # \arguments{ # \item{...}{Any arguments accepted by the constructor of Exception, i.e. # one or several @character strings, which will be concatenated and # contain informative message about why the RCC was violated.} # } # # \section{Fields and Methods}{ # @allmethods # } # # \details{ # Since it is not possible to assert that the RCC is followed during the # parsing of the source code, but first only when the source code is # actually executed. # } # # \examples{ # \dontrun{ # setConstructorS3("myClass", function() { extends(Object(), .value=0) }) # setMethodS3("MyMethod", "myClass", function(this) { "Hullo!" }) # } # } # # @author # # \seealso{ # See also @see "base::try" and \code{\link[base:conditions]{tryCatch}()}. # For detailed information about exceptions see @see "Exception". # The R Coding Conventions (RCC) can be found at # \url{@eval "RccViolationException$getRccUrl()"}. # } # # @keyword programming # @keyword methods # @keyword error # @keyword internal #*/########################################################################### setConstructorS3("RccViolationException", function(...) { extend(Exception(...), c("RccViolationException") ) }) ###########################################################################/** # @RdocMethod as.character # # @title "Gets a string representing of the RCC violation" # # \description{ # @get "title" of format "[\{POSIX date string\}] \{class name\}: \{msg\}, cf. @eval "RccViolationException$getRccUrl()"". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("as.character", "RccViolationException", function(x, ...) { # To please R CMD check this <- x paste("[", getWhen(this), "] ", class(this)[1L], ": ", getMessage(this), ", cf. ", getRccUrl(this), sep="") }) ###########################################################################/** # @RdocMethod getRccUrl # # @title "Static method to get a URL where the RCC can be found" # # \description{ # Static method to get a URL where one can find details about the # R Code Convention (RCC). # Currently the URL is \url{@eval "RccViolationException$getRccUrl()"}. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{\dontrun{For a complete example see help(RccViolationException).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getRccUrl", "RccViolationException", function(this, ...) { "https://aroma-project.org/developers/RCC/" }, static=TRUE) R.oo/R/equals.default.R0000644000176200001440000000255014554071363014342 0ustar liggesusers###########################################################################/** # @RdocDefault equals # # @title "Compares an object with another" # # \description{ # @get "title" and returns @TRUE if they are equal. # The equal property must be # # 1) \emph{reflexive}, i.e. \code{equals(o1,o1)} should be @TRUE. # # 2) \emph{symmetric}, i.e. \code{equals(o1,o2)} is @TRUE if and only # if \code{equals(o2,o1)} is @TRUE. # # 3) \emph{transitive}, i.e. \code{equals(o1,o2)} is @TRUE and # \code{equals(o2,o3)} is @TRUE, then \code{equals(o1,o3)} should # be @TRUE. # # 5) \emph{consistent}, i.e. \code{equals(o1,o2)} should return the same # result on multiple invocations as long as nothing has changed. # # 6) \code{equals(o1,}@NULL\code{)} should return @FALSE, unless # \code{o1} is also @NULL. # # By default @see "base::identical" is used. # } # # @synopsis # # \arguments{ # \item{object, other}{Objects to be compared.} # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the objects are equal, otherwise @FALSE. # } # # @author # # \seealso{ # @see "base::identical". # } # # @keyword attribute # @keyword utilities # @keyword internal #*/########################################################################### setMethodS3("equals", "default", function(object, other, ...) { (is.null(object) && is.null(other)) || identical(object, other) }) R.oo/R/objectSize.default.R0000644000176200001440000000140414554071363015146 0ustar liggesusers###########################################################################/** # @RdocDefault objectSize # # @title "Gets the size of the object in bytes" # # \description{ # @get "title". # This method is just a wrapper for @see "utils::object.size". # } # # @synopsis # # \arguments{ # \item{...}{Arguments passed to @see "utils::object.size".} # } # # \value{ # Returns an @integer. # } # # @author # # \seealso{ # Internally @see "utils::object.size". # } # # \keyword{attribute} # \keyword{utilities} #*/########################################################################### setMethodS3("objectSize", "default", function(...) { args <- list(...) args$.scannedEnvs <- NULL ## Used by objectSize() for environment do.call(object.size, args=args) }) R.oo/R/Package.R0000644000176200001440000010370314554071363012762 0ustar liggesusers##########################################################################/** # @RdocClass Package # # @title "The Package class provides methods for accessing package information" # # \description{ # @classhierarchy # # Creates a Package that can be thrown and caught. The \code{Package} # class is the root class of all other \code{Package} classes. # } # # @synopsis # # \arguments{ # \item{name}{Name of the package.} # } # # \section{Fields and Methods}{ # @allmethods # } # # \examples{\dontrun{@include "../incl/Package.Rex"}} # # @author # # \keyword{programming} # \keyword{methods} #*/########################################################################### setConstructorS3("Package", function(name=NULL) { libPath <- NULL version <- NULL if (!is.null(name)) { tryCatch({ package <- packageDescription(name) version <- as.character(package$Version) libPath <- dirname(system.file(package=name)) }, warning = function(warn) { # installed.packages() may be slow()! packages <- as.data.frame(installed.packages()) idxs <- (packages$Package == name) if(!any(idxs)) { throw("Package is not installed: ", name) } packages <- packages[idxs,,drop=FALSE] libPath <<- as.character(packages$LibPath) if (length(libPath) > 1) { warning(paste("Multiple installations of package '", name, "' was found. Using the first. Paths to all installations: ", paste(libPath, collapse=", "), sep="")) libPath <<- libPath[1] } libPath <<- gsub("/$", "", libPath) version <<- as.character(packages$Version[1]) }) } extend(Object(), "Package", .name = name, .version = version, .libPath = libPath, .inBundle = NULL, .bundlePackages = NULL ) }) #########################################################################/** # @RdocMethod as.character # # @title "Gets a string representation of this package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{print(R.oo)} # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("as.character", "Package", function(x, ...) { # To please R CMD check this <- x s <- paste(class(this)[1L], ": ", getName(this), " v", getVersion(this), sep="") date <- getDate(this) if (!is.na(date)) s <- paste(s, " (", getDate(this), ")", sep="") pos <- getPosition(this) if (pos != -1) s <- paste(s, " is loaded (pos=", pos, ").", sep="") else s <- paste(s, ".") s <- paste(s, " Title: ", getTitle(this), ".", sep="") # Do not call getBundle() here; it can be very slow! # bundle <- getBundle(this) # if (!is.null(bundle)) # s <- paste(s, " It is part of bundle ", bundle, " (", paste(getBundlePackages(this), collapse=", "), ").", sep="") url <- getUrl(this) if (!is.null(url)) s <- paste(s, " The official webpage is ", url, " and the", sep="") else s <- paste(s, " The", sep="") s <- paste(s, " maintainer is ", getMaintainer(this), ".", sep="") s <- paste(s, " The package is installed in ", getPath(this), ".", sep="") license <- getLicense(this) if (!is.null(license)) s <- paste(s, " License: ", license, ".", sep="") s <- paste(s, " Description: ", getDescription(this), sep="") s <- paste(s, " Type showNews(", getName(this), ") for package history, and ?", getName(this), " for help.", sep="") s }) #########################################################################/** # @RdocMethod getName # # @title "Gets the name of this package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getName", "Package", function(this, ...) { this$.name }) #########################################################################/** # @RdocMethod getContents # # @title "Gets the contents of this package" # # \description{ # @get "title", i.e. the parsed \code{CONTENTS} file. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @data.frame. # } # # @author # # \seealso{ # @see "base::dcf". # @seeclass # } #*/######################################################################### setMethodS3("getContents", "Package", function(this, fields=NULL, ...) { pathname <- system.file("CONTENTS", package=this$.name) if (!file.exists(pathname)) throw("CONTENTS file missing for package '", this$.name, "': ", pathname) # DCF format == Debian Control File format contents <- read.dcf(file=pathname, fields=fields) contents <- as.data.frame(contents) contents }, protected=TRUE) #########################################################################/** # @RdocMethod showContents # # @title "Show the CONTENTS file of this package" # # \description{ # @get "title". # If the \code{CONTENTS} file does not exist, an exception is thrown. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("showContents", "Package", function(this, ...) { path <- getPath(this) files <- list.files(path=path) file <- files[tolower(files) == "contents"] if (length(file) == 0) throw("CONTENTS file for package ", getName(this), " does not exist.") pathname <- file.path(path, file) file.show(pathname, ...) }, protected=TRUE) #########################################################################/** # @RdocMethod getDescriptionFile # # @title "Gets the description file of this package" # # \description{ # @get "title", i.e. the parsed \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{fields}{A @vector of @character strings of fields to be returned. # If @NULL, all available fields are returned.} # \item{...}{Not used.} # } # # \value{ # Returns named @vector of @character strings. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getDescriptionFile", "Package", function(this, fields=NULL, ...) { unlist(packageDescription(this$.name, fields=fields)) }, protected=TRUE) #########################################################################/** # @RdocMethod showDescriptionFile # # @title "Show the DESCRIPTION file of this package" # # \description{ # @get "title". # If the \code{DESCRIPTION} file does not exist, an exception is thrown. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("showDescriptionFile", "Package", function(this, ...) { path <- getPath(this) files <- list.files(path=path) file <- files[tolower(files) == "description"] if (length(file) == 0) throw("DESCRIPTION file for package ", getName(this), " does not exist.") pathname <- file.path(path, file) file.show(pathname, ...) }) #########################################################################/** # @RdocMethod getPath # # @title "Gets the library (system) path to this package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getPath", "Package", function(this, ...) { file.path(this$.libPath, getName(this), "") }) #########################################################################/** # @RdocMethod getVersion # # @title "Gets the version of this package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # @seemethod "isOlderThan". # } #*/######################################################################### setMethodS3("getVersion", "Package", function(this, ...) { this$.version }) #########################################################################/** # @RdocMethod isOlderThan # # @title "Checks if the package is older than a given version" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{version}{A @character string specifying a version to compare with.} # \item{...}{Not used.} # } # # \value{ # Returns @TRUE if the version of the package is less than the # specified version. # } # # @author # # \seealso{ # @seeclass # @seemethod "getVersion". # } #*/######################################################################### setMethodS3("isOlderThan", "Package", function(this, version, ...) { res <- compareVersion(getVersion(this), version) (res < 0) }) #########################################################################/** # @RdocMethod getDataPath # # @title "Gets the path to the data (data/) directory of this package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getDataPath", "Package", function(this, ...) { file.path(this$.libPath, getName(this), "data", "") }) #########################################################################/** # @RdocMethod getDocPath # # @title "Gets the path to the accompanying documentation (doc/) directory of this package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # print(list.files(getDocPath(R.oo))) # explicit call, or # print(list.files(R.oo$docPath)) # as a virtual field # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getDocPath", "Package", function(this, ...) { file.path(this$.libPath, getName(this), "doc", "") }) #########################################################################/** # @RdocMethod getExamplePath # # @title "Gets the path to the example (R-ex/) directory of this package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getExamplePath", "Package", function(this, ...) { file.path(this$.libPath, getName(this), "R-ex", "") }) #########################################################################/** # @RdocMethod getDate # # @title "Gets the date when package was build" # # \description{ # Checks if the package is loaded onto the search path or not. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # @TRUE if the packages has been loaded, otherwise @FALSE. # } # # \examples{ # pkg <- Package("base") # print(isLoaded(pkg)) # TRUE # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getDate", "Package", function(this, ...) { date <- getDescriptionFile(this, fields=c("Date", "Date/Publication")) date <- unname(unlist(date, use.names=FALSE)) date <- date[!is.na(date)] date[1] }) #########################################################################/** # @RdocMethod getDescription # # @title "Gets the description of the package" # # \description{ # @get "title". Not to be mixed up with @seemethod "getDescriptionFile". # } # # @synopsis # # \arguments{ # \item{replaceNewlines}{If a @character string, all newline characters # are replaced with this string. Otherwise not.} # \item{...}{Not used.} # } # # \value{ # A @character string. # } # # \examples{ # pkg <- Package("base") # print(getDescription(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getDescription", "Package", function(this, replaceNewlines=" ", ...) { value <- getDescriptionFile(this, fields="Description") if (is.character(replaceNewlines)) value <- gsub("[\r\n]", replaceNewlines, value) value }) #########################################################################/** # @RdocMethod getPosition # # @title "Gets the search path position of the package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # An @integer. # } # # \examples{ # pkg <- Package("base") # print(getPosition(pkg)) # } # # @author # # \seealso{ # @seemethod "getEnvironment". # @see "base::search". # @seeclass # } #*/######################################################################### setMethodS3("getPosition", "Package", function(this, ...) { queries <- paste(sep="", "^package:", getName(this), "$") res <- c() for (query in queries) { pos <- which(regexpr(query, search()) != -1) if (length(pos) == 0) pos <- -1 res <- c(res, pos) } res }) #########################################################################/** # @RdocMethod getEnvironment # # @title "Gets the environment of a loaded package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @environment, or @NULL if the package was not loaded. # } # # @author # # \seealso{ # @seemethod "getPosition". # @seeclass # } #*/######################################################################### setMethodS3("getEnvironment", "Package", function(this, ...) { pos.to.env(getPosition(this)) }) #########################################################################/** # @RdocMethod isLoaded # # @title "Checks if the package is installed on the search path or not" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # @TRUE if the packages has been loaded, otherwise @FALSE. # } # # \examples{ # pkg <- Package("base") # print(isLoaded(pkg)) # TRUE # } # # @author # # \seealso{ # @seemethod "load". # @see "base::search". # @seeclass # } #*/######################################################################### setMethodS3("isLoaded", "Package", function(this, ...) { (getPosition(this) != -1) }) #########################################################################/** # @RdocMethod load # # @title "Loads a package" # # \description{ # @get "title". This is an alternative way to use \code{library()} to # load a package. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # @TRUE if the packages is loaded, otherwise @FALSE. # } # # \examples{ # pkg <- Package("base") # print(load(pkg)) # } # # @author # # \seealso{ # @seemethod "unload". # @seemethod "isLoaded". # @see "base::search". # @seeclass # } #*/######################################################################### setMethodS3("load", "Package", function(this, ...) { .library <- library # To please R CMD check .library(package=getName(this), character.only=TRUE) isLoaded(this) }) #########################################################################/** # @RdocMethod unload # # @title "Unloads a package" # # \description{ # @get "title". This is an alternative way to use \code{detach()} to # unload a package. # If the package is not loaded, it will quietly return. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # \examples{\dontrun{ # @include "../incl/Package.unload.Rex" # }} # # @author # # \seealso{ # @seemethod "load". # @seemethod "isLoaded". # @see "base::search". # @seeclass # } #*/######################################################################### setMethodS3("unload", "Package", function(this, ...) { name <- paste("package:", getName(this), sep="") pos <- which(name == search()) if (length(pos) == 1L) detach(pos=pos) }) #########################################################################/** # @RdocMethod ll # # @title "Generates a list of informative properties of all members of the package" # # \description{ # @get "title". # # If the package is not loaded, it will be loaded, the members will be # retrieved and then the package will be unloaded again. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @data.frame. # } # # \details{ # Note the difference from the default definition of \code{ll()} as # inherited from the @Object class. Here \code{ll()} has been # redefined to list the members of the package, i.e. the members in # the environment on search path that belongs to the package, whereas # the original usage was to list the members of the Object. However, # since the internal members of Package object is not of interest we # decided on this definition instead. # } # # \examples{ # \dontrun{ll(R.oo)} # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("ll", "Package", function(this, envir=pos.to.env(getPosition(this)), ...) { isLoaded <- isLoaded(this) if (!isLoaded) load(this) ll <- ll(..., envir=envir) if (!isLoaded) unload(this) ll }) #########################################################################/** # @RdocMethod getClasses # # @title "Gets all classes of a package" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character @vector of class names. # } # # \examples{ # pkg <- Package("R.oo") # print(getClasses(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getClasses", "Package", function(this, ...) { pkgname <- getName(this) ns <- getNamespace(pkgname) names <- ls(envir=ns, all.names=FALSE) classes <- c() for (name in names) { object <- .getFunctionByName(name, where=c("ns", "search"), envir=ns, class="Class", mustExist=FALSE) if (inherits(object, "Class")) classes <- c(classes, name) } classes }, protected=TRUE, dontWarn="base") #########################################################################/** # @RdocMethod getUrl # # @title "Gets the URL of this package" # # \description{ # @get "title" as specified by the \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # pkg <- Package("R.oo") # print(getUrl(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getUrl", "Package", function(this, ...) { getDescriptionFile(this, fields="URL") }) #########################################################################/** # @RdocMethod getContribUrl # # @title "Gets the URL(s) from where this package can be installed" # # \description{ # @get "title" by first looking for comma or semicolon separated URLs # at the optional \code{ContribURL} line in the \code{DESCRIPTION} file # of the package. If no such line exists, \code{getUrl()} is used. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a vector of @character strings. # } # # \examples{ # pkg <- Package("R.oo") # print(getContribUrl(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getContribUrl", "Package", function(this, ...) { urls <- getDescriptionFile(this, fields="ContribURL") if (is.null(urls) || is.na(urls)) { urls <- getDescriptionFile(this, fields="URL") if (is.null(urls) || is.na(urls)) { return(NA_character_) } } urls <- strsplit(urls, "[,;]")[[1]] urls <- gsub("^[ \t]*", "", urls) urls <- gsub("[ \t]*$", "", urls) urls }, private=TRUE) #########################################################################/** # @RdocMethod getDevelUrl # # @title "Gets the URL(s) from where the developers version of this package can be installed" # # \description{ # @get "title" by looking for comma or semicolon separated URLs # at the optional \code{DevelURL} line in the \code{DESCRIPTION} file # of the package. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a vector of @character strings. # } # # \examples{ # pkg <- Package("R.oo") # print(getDevelUrl(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getDevelUrl", "Package", function(this, ...) { urls <- getDescriptionFile(this, fields="DevelURL") if (is.null(urls) || is.na(urls)) { return(NA_character_) } urls <- strsplit(urls, "[,;]")[[1]] urls <- gsub("^[ \t]*", "", urls) urls <- gsub("[ \t]*$", "", urls) urls }, private=TRUE) #########################################################################/** # @RdocMethod getMaintainer # # @title "Gets the Maintainer of this package" # # \description{ # @get "title" as specified by the \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{as}{A @character string specifying the return format.} # \item{include}{A @character @vector specifying which person fields # to include if returning a @character string.} # \item{...}{Optional arguments passed to @see "utils::format.person".} # } # # \value{ # Returns a @character string or a @see "utils::person" object. # } # # \examples{ # pkg <- Package("R.oo") # print(getMaintainer(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getMaintainer", "Package", function(this, as=c("character", "person"), include=c("given", "family"), ...) { # Argument 'as': as <- match.arg(as) persons <- getDescriptionFile(this, fields=c("Authors@R", "Maintainer")) persons <- persons[!is.na(persons)] if (length(persons) == 0L) { return(NA_character_) } persons <- persons[1L] key <- names(persons)[1L] # Parse? if (key == "Authors@R") { personsP <- eval(parse(text=persons)) # Find creators isCreator <- sapply(personsP, FUN=function(p) is.element("cre", p$role)) if (any(isCreator)) { personsP <- personsP[isCreator] } persons <- format(personsP, include=include, ...) } else { personsP <- NULL } if (as == "character") { return(persons) } if (is.null(personsP)) { personsP <- as.person(persons) } personsP }) #########################################################################/** # @RdocMethod getAuthor # # @title "Gets the Author of this package" # # \description{ # @get "title" as specified by the \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{as}{A @character string specifying the return format.} # \item{include}{A @character @vector specifying which person fields # to include if returning a @character string.} # \item{...}{Optional arguments passed to @see "utils::format.person".} # } # # \value{ # Returns a @character string or a @see "utils::person" object. # } # # \examples{ # pkg <- Package("R.oo") # print(getAuthor(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getAuthor", "Package", function(this, as=c("character", "person"), include=c("given", "family"), ...) { # Argument 'as': as <- match.arg(as) persons <- getDescriptionFile(this, fields=c("Authors@R", "Author")) persons <- persons[!is.na(persons)] if (length(persons) == 0L) { return(NA_character_) } persons <- persons[1L] key <- names(persons)[1L] # Parse? if (key == "Authors@R") { personsP <- eval(parse(text=persons)) persons <- format(personsP, include=include, ...) } else { personsP <- NULL } if (as == "character") { return(persons) } if (is.null(personsP)) { personsP <- as.person(persons) } personsP }) #########################################################################/** # @RdocMethod getTitle # # @title "Gets the Title of this package" # # \description{ # @get "title" as specified by the \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # pkg <- Package("R.oo") # print(getTitle(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getTitle", "Package", function(this, ...) { getDescriptionFile(this, fields="Title") }) #########################################################################/** # @RdocMethod getLicense # # @title "Gets the License of this package" # # \description{ # @get "title" as specified by the \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{ # pkg <- Package("R.oo") # print(getLicense(pkg)) # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getLicense", "Package", function(this, ...) { getDescriptionFile(this, fields="License") }) #########################################################################/** # @RdocMethod getBundle # # @title "Gets the Bundle that this package might belong to" # # \description{ # @get "title" as specified by the \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # If the package is part of a bundle, the name of the bundle is returned. # Otherwise, @NULL is returned. # } # # \details{ # The first call to this method is normally slow because all installed # packages are scanned. The result of this first call is cached and # used as the return value for all subsequent calls, which are then much # faster. # } # # \examples{\donttest{ # pkg <- Package("R.oo") # print(getBundle(pkg)) # }} # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getBundle", "Package", function(this, ...) { if (is.null(this$.inBundle)) { # installed.packages() may be slow()! pkgs <- installed.packages() if (is.element("Bundle", colnames(pkgs))) { names <- pkgs[,"Package"] bundle <- pkgs[names == getName(this), "Bundle"] } else { bundle <- NA } this$.inBundle <- bundle } if (is.na(this$.inBundle)) { NULL } else { this$.inBundle } }, protected=TRUE) #########################################################################/** # @RdocMethod getBundlePackages # # @title "Gets the names of the other packages that is in the same bundle as this package" # # \description{ # @get "title" as specified by the \code{DESCRIPTION} file. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character @vector of package names or @NULL. # } # # \details{ # The first call to this method is normally slow because all installed # packages are scanned. The result of this first call is cached and # used as the return value for all subsequent calls, which are then much # faster. # } # # \examples{\donttest{ # pkg <- Package("R.oo") # print(getBundle(pkg)) # }} # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getBundlePackages", "Package", function(this, ...) { bundle <- getBundle(this) if (is.null(bundle)) return(NULL) if (is.null(this$.bundlePackages)) { pkgs <- installed.packages() bundles <- pkgs[,"Bundle"] incl <- !is.na(bundles) & (bundles == bundle) this$.bundlePackages <- pkgs[incl, "Package"] } this$.bundlePackages }, protected=TRUE) #########################################################################/** # @RdocMethod getChangeLog # @aliasmethod getNews # @aliasmethod getHistory # # @title "Gets the change log of this package" # # \description{ # @get "title", that is, (by default) the \code{NEWS} (then the # \code{HISTORY} and \code{ChangeLog}) file, which should is expected to # be located in the root directory of the package, # i.e. @seemethod "getPath". # } # # @synopsis # # \arguments{ # \item{filenames}{A @character @vector of (non-case sensitive) filenames # to be searched for.} # \item{newline}{The @character string to collapse lines in the file.} # \item{...}{Not used.} # } # # \value{ # Returns the complete contents of the change log file as a # @character string. If not found, @NULL is returned. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getChangeLog", "Package", function(this, filenames=c("NEWS", "HISTORY", "ChangeLog"), newline="\n", ...) { # Argument 'filenames': filenames <- as.character(filenames) filenames <- tolower(filenames) path <- getPath(this) files <- list.files(path=path) # Find change log files idx <- match(filenames, tolower(files)) idx <- idx[!is.na(idx)] files <- files[idx] if (length(files) == 0) return(NULL) # First file file <- files[1] pathname <- file.path(path, file) lines <- readLines(pathname) lines <- paste(lines, collapse=newline) lines }) setMethodS3("getHistory", "Package", function(this, ...) { getChangeLog(this, ...) }) setMethodS3("getNews", "Package", function(this, ...) { getChangeLog(this, ...) }) #########################################################################/** # @RdocMethod showChangeLog # @aliasmethod showHistory # @aliasmethod showNews # # @title "Show the change log of this package" # # \description{ # @get "title". # If the change log file does not exist, an exception is thrown. # } # # @synopsis # # \arguments{ # \item{filenames}{A @character @vector of (non-case sensitive) filenames # to be searched for.} # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seemethod "getChangeLog". # @seeclass # } #*/######################################################################### setMethodS3("showChangeLog", "Package", function(this, filenames=c("NEWS", "NEWS.md", "HISTORY", "ChangeLog"), ...) { # Argument 'filenames': filenames <- as.character(filenames) filenames <- tolower(filenames) path <- getPath(this) files <- list.files(path=path) # Find change log files idx <- match(filenames, tolower(files)) idx <- idx[!is.na(idx)] files <- files[idx] if (length(files) == 0) return(NULL) # First file file <- files[1] if (length(file) == 0) throw("NEWS/NEWS.md/HISTORY/ChangeLog file for package ", getName(this), " does not exist.") pathname <- file.path(path, file) file.show(pathname, ...) }) setMethodS3("showHistory", "Package", function(this, ...) { showChangeLog(this, ...) }) setMethodS3("showNews", "Package", function(this, ...) { showChangeLog(this, ...) }) #########################################################################/** # @RdocMethod getHowToCite # # @title "Gets the citation of this package" # # \description{ # @get "title". # If text file \code{HOWTOCITE} exists in package root directory, # then its contents is retrieved, otherwise @see "utils::citation" # for the package is retrieved. # } # # @synopsis # # \arguments{ # \item{newline}{The @character string to collapse lines in the file.} # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("getHowToCite", "Package", function(this, newline="\n", ...) { if (file.exists(pathname <- file.path(getPath(this), "HOWTOCITE"))) { lines <- readLines(pathname) } else { db <- citation(package=getName(this)) lines <- format(db, style="textVersion") } lines <- paste(lines, collapse=newline) lines }, protected=TRUE) #########################################################################/** # @RdocMethod showHowToCite # # @title "Show the HOWTOCITE file of this package" # # \description{ # @get "title". See also @seemethod "getHowToCite". # If the \code{HOWTOCITE} file does not exist, an exception is thrown. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("showHowToCite", "Package", function(this, ...) { path <- getPath(this) files <- list.files(path=path) file <- files[tolower(files) == "howtocite"] if (length(file) == 0) throw("HOWTOCITE file for package ", getName(this), " does not exist.") pathname <- file.path(path, file) file.show(pathname) }, protected=TRUE) #########################################################################/** # @RdocMethod startupMessage # # @title "Generates a 'package successfully loaded' package startup message" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Additional arguments passed to # @see "R.methodsS3::pkgStartupMessage".} # } # # \value{ # Returns nothing. # } # # @author # # \seealso{ # @seeclass # } #*/######################################################################### setMethodS3("startupMessage", "Package", function(this, ...) { date <- getDate(this) if (is.na(date)) { msg <- sprintf("%s v%s successfully loaded. See ?%s for help.", getName(this), getVersion(this), getName(this)) } else { msg <- sprintf("%s v%s (%s) successfully loaded. See ?%s for help.", getName(this), getVersion(this), date, getName(this)) } pkgStartupMessage(msg, ...) }, protected=TRUE) R.oo/R/Exception.R0000644000176200001440000003532714554071363013373 0ustar liggesusers###########################################################################/** # @RdocClass Exception # # \title{The Exception class to be thrown and caught} # # \description{ # @classhierarchy # # Creates an Exception that can be thrown and caught. The \code{Exception} # class is the root class of all other \code{Exception} classes. # } # # @synopsis # # \arguments{ # \item{...}{One or several strings, which will be concatenated and contain # informative message about the exception.} # \item{sep}{The string to used for concatenating several strings.} # \item{collapse}{The string to used collapse vectors together.} # } # # \section{Fields and Methods}{ # @allmethods # } # # @examples "../incl/Exception.Rex" # # @author # # \seealso{ # See also \code{\link[base:conditions]{tryCatch}()} (and @see "base::try"). # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setConstructorS3("Exception", function(..., sep="", collapse=", ") { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Local functions # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - sys.functions <- function(parents) { functions <- list() for (kk in seq_along(parents)) { parent <- parents[kk] functions[[kk]] <- sys.function(which=kk) } functions } # sys.functions() fcnPathname <- function(call) { res <- attr(call, "srcref") if (is.null(res)) return("") res <- attr(res, "srcfile") res$filename } # fcnPathname() fcnName <- function(call) { code <- deparse(call[1]) # code <- grep("^function\\(", code, value=TRUE) if (length(code) == 0) return("") code <- code[1] code <- gsub("\\(.*", "", code) code } # fcnName() fcnBody <- function(fcn) { paste(deparse(fcn), collapse="\n") } # fcnBody() # "Each [...] function evaluation has a tuple, # (call, function definition, evaluation environment), # coupled to it, which can be retrieved via sys.{call,function,frame}()." # Source: help("sys.parent", package="base") calls <- sys.calls() parents <- sys.parents() functions <- sys.functions(parents) stackTrace <- list() for (kk in seq_along(calls)) { call <- calls[[kk]] fcn <- functions[[kk]] name <- fcnName(call) body <- fcnBody(fcn) envir <- environment(fcn) envirName <- environmentName(envir) pathname <- fcnPathname(call) trace <- list( call=call, name=name, body=body, envir=envirName, pathname=pathname ) stackTrace[[kk]] <- trace } # for (kk ...) rm(list=c("calls", "parents", "functions")) # The new class is Exception, but for convenience it should also # derive from 'try-error', which is used by try() etc. extend(Object(), c("Exception", "simpleError", "error", "condition", "try-error"), .msg = paste(..., sep=sep, collapse=collapse), .when = Sys.time(), .stackTrace = stackTrace ) }) ###########################################################################/** # @RdocMethod as.character # # \title{Gets a character string representing of the Exception} # # \description{ # @get "title". # By default the format is: "[\{POSIX date string\}] \{class name\}: \{msg\}". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("as.character", "Exception", function(x, ...) { # To please R CMD check this <- x paste("[", getWhen(this), "] ", class(this)[1], ": ", getMessage(this), sep="") }) ###########################################################################/** # @RdocMethod print # # \title{Prints the Exception} # # \description{ # @get "title". By default the \code{as.character()} representation plus # the stack trace is printed. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{Returns nothing.} # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seemethod "as.character". # @seemethod "getStackTrace". # @seemethod "printStackTrace". # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("print", "Exception", function(x, ...) { cat(getStackTraceString(x, ...)) }) ###########################################################################/** # @RdocMethod getWhen # # \title{Gets the time when the Exception was created} # # \description{ # Gets the time, as a POSIX object, when the Exception was created. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a POSIX time object. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getWhen", "Exception", function(this, ...) { this$.when }) ###########################################################################/** # @RdocMethod getMessage # # @title "Gets the message of the Exception" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getMessage", "Exception", function(this, ...) { this$.msg }) ###########################################################################/** # @RdocMethod throw # # \title{Throws an Exception that can be caught} # # \description{ # Throws an Exception that can be caught by \code{tryCatch()}. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # See also \code{\link[base:conditions]{tryCatch}()}. # This method overrides (and is fully backward compatible with) the one # defined in the \pkg{R.methodsS3} package. # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("throw", "Exception", function(this, ...) { # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Record this Exception # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Exception$.lastException <- this # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Signal the exception as a condition # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - signalCondition(this) # Question: Are there ways to catch the above signals, and then via # some revoking mechanism continue below?!? /HB 2012-03-05 # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # If not caught by any handlers, output message containing the stack trace # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Output an error message containing the stacktrace msg <- getStackTraceString(this, ...) cat(msg, file=stderr()) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # ...and *abort* # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Alt 1: Abort the current evaluation, but unfortunately abort() # is not guaranteed to not be "caught", cf. help("abort"). # abort() # Alt 2: An alternative is to call stop() again, which will resignal # a condition and then abort. The resignaled condition should not # really be caught by anything, because if so, it would have been # caught by the above signaling. This is based on the assumption # that it is not possible to continue after the above signal, # iff it is caught. /HB 2012-03-05 cond <- simpleCondition(getMessage(this)) class(cond) <- "condition" stop(cond) }, overwrite=TRUE, conflict="quiet") ###########################################################################/** # @RdocMethod getLastException # # \title{Static method to get the last Exception thrown} # # \description{ # Static method to get the last Exception created. # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an @see "Exception" object. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # \seealso{ # @seeclass # See also \code{\link[base:conditions]{tryCatch}()}. # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getLastException", "Exception", function(this, ...) { Exception$.lastException }, static=TRUE) ###########################################################################/** # @RdocMethod getStackTrace # # \title{Gets the stack trace saved when the exception was created} # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @list containing the stack trace. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # \seealso{ # @seemethod "printStackTrace". # \code{\link[utils:debugger]{dump.frames}()}. # \code{\link[base:conditions]{tryCatch}()}. # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getStackTrace", "Exception", function(this, cleanup=getOption("R.oo::Exception/getStackTrace/args/cleanup", TRUE), ...) { stackTrace <- this$.stackTrace names(stackTrace) <- seq_along(stackTrace) # Remove "uninformative" steps, e.g. tryCatch() if (cleanup) { # (a) Drop anything before doTryCatch() names <- sapply(stackTrace, FUN=function(x) x$name) idxs <- which(is.element(names, c("doTryCatch"))) if (length(idxs) > 0) { idx <- idxs[length(idxs)] keep <- seq(from=idx+1L, to=length(stackTrace)) stackTrace <- stackTrace[keep] } # (b) Drop anything after throw() names <- sapply(stackTrace, FUN=function(x) x$name) idxs <- which(is.element(names, "throw")) if (length(idxs) > 0) { idx <- idxs[1L] keep <- seq_len(idx-1L) stackTrace <- stackTrace[keep] } } stackTrace <- rev(stackTrace) stackTrace }) ###########################################################################/** # @RdocMethod getCalls # @aliasmethod getCall # # \title{Gets the active calls saved when the exception was created} # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns an unnamed @list with @language elements. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # \seealso{ # @seemethod "getStackTrace". # \code{\link[utils:debugger]{sys.calls}()}. # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getCalls", "Exception", function(this, ...) { stackTrace <- getStackTrace(this, ...) calls <- lapply(stackTrace, FUN=function(x) x$call) calls }) setMethodS3("getCall", "Exception", function(x, which=1L, ...) { # To please R CMD check (R >= 2.14.0) this <- x calls <- getCalls(this, ...) if (length(calls) == 0) { return(NULL) } calls[[which]] }) ###########################################################################/** # @RdocMethod getStackTraceString # # \title{Gets the stack trace as a string} # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns a @character string. # } # # \seealso{ # @seemethod "getStackTrace". # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getStackTraceString", "Exception", function(this, ..., details=TRUE) { head <- sprintf("%s\n", as.character(this)) stackTrace <- getStackTrace(this, ...) if (length(stackTrace) == 0) { return(head) } calls <- sapply(stackTrace, FUN=function(trace) trace$call) res <- character(length=length(calls)) for (kk in seq_along(calls)) { call <- calls[[kk]] rows <- deparse(call) if (details) { prefix1 <- sprintf(" at #%02d. ", as.integer(names(calls)[kk])) } else { prefix1 <- " at " } prefixT <- paste(rep(" ", times=nchar(prefix1)), collapse="") prefix <- rep(prefixT, times=length(rows)) prefix[1] <- prefix1 rows <- sprintf("%s%s", prefix, rows) res[kk] <- paste(rows, collapse="\n") } # for (kk ...) if (details) { locs <- sapply(stackTrace, FUN=function(trace) { name <- trace$name envir <- trace$envir s <- sprintf("%s()", name) if (envir == "") { s <- sprintf("%s is local of the calling function", s) } else { s <- sprintf("%s is in environment '%s'", s, envir) } s }) res <- sprintf("%s\n - %s", res, locs) pathnames <- sapply(stackTrace, FUN=function(trace) { trace$pathname }) pathnamesT <- sprintf("\n - originating from '%s'", pathnames) pathnamesT[nchar(pathnames) == 0] <- "" res <- sprintf("%s%s", res, pathnamesT) res <- sprintf("%s\n", res) } # if (details) res <- paste(res, collapse="\n") if (details) { res <- sprintf("%s\n%s\n", head, res) } else { res <- sprintf("%s%s\n", head, res) } res }, private=TRUE) ###########################################################################/** # @RdocMethod printStackTrace # # \title{Prints the stack trace saved when the exception was created} # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{...}{Not used.} # } # # \value{ # Returns nothing. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # \seealso{ # @seemethod "getStackTrace". # \code{\link[base:conditions]{tryCatch}()}. # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("printStackTrace", "Exception", function(this, ...) { cat(getStackTraceString(this, ...)) }) R.oo/R/zzz.avoid_Object_clashes.R0000644000176200001440000000326614554071363016360 0ustar liggesusers## - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ## WORKAROUND for clashes between R.oo Object:s and Object:s ## unrelated to R.oo created by other packages. ## ## Package 'rJava': ## Some R.oo S3 methods for Object and Exception override ## the intended ones for rJava objects with class attributes ## containing these classes as well. ## See https://github.com/s-u/rJava/issues/60 ## ## Package 'arrow': ## `$<-.Object` causes problem for arrow:::as_arrow(). ## See https://github.com/HenrikBengtsson/R.oo/issues/21 ## - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - .fixMethodS3 <- function(generic, class, expr=NULL, envir=parent.frame()) { method <- sprintf("%s.%s", generic, class) expr <- substitute(expr) f <- get(method, mode="function", envir=getNamespace("R.oo"), inherits=TRUE) if (is.null(expr)) { x <- as.symbol(names(formals(f)[1])) expr <- substitute( if(!.isRoo(x)) return(NextMethod()) , list(x=x)) } body(f) <- substitute({ a b }, list(a=expr, b=body(f))) attr(f, "S3class") <- class assign(method, f, envir=envir, inherits=TRUE) invisible(f) } ## .fixMethodS3() .isRoo <- function(x) is.environment(attr(x, ".env")) ## rJava .fixMethodS3("names", "Object") .fixMethodS3("$", "Object") .fixMethodS3("[[", "Object") .fixMethodS3("print", "Object") .fixMethodS3("print", "Exception") ## arrow .fixMethodS3("$<-", "Object") ## Some other, just in case .fixMethodS3("[[<-", "Object") .fixMethodS3("as.character", "Object") .fixMethodS3("clone", "Object") .fixMethodS3("extend", "Object") .fixMethodS3("ll", "Object") .fixMethodS3("names", "Object") .fixMethodS3("objectSize", "Object") .fixMethodS3("print", "Object") R.oo/R/trim.R0000644000176200001440000000124514554071363012400 0ustar liggesusers###########################################################################/** # @RdocDefault trim # # @title "Converts to a string and removes leading and trailing whitespace" # # \description{ # @get "title". # } # # @synopsis # # \arguments{ # \item{object}{A @vector of \R objects to be trimmed.} # \item{...}{Not used.} # } # # \value{ # Returns a @vector of @character strings. # } # # @author # # @keyword character # @keyword internal #*/########################################################################### setMethodS3("trim", "default", function(object, ...) { s <- sub("^[\t\n\f\r ]*", "", as.character(object)) s <- sub("[\t\n\f\r ]*$", "", s) s }) R.oo/NAMESPACE0000644000176200001440000002125614711064175012322 0ustar liggesusers# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # IMPORTS # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - importFrom("R.methodsS3", "setMethodS3") importFrom("R.methodsS3", "setGenericS3") importFrom("R.methodsS3", "isGenericS3") importFrom("R.methodsS3", "pkgStartupMessage") importFrom("R.methodsS3", "appendVarArgs") importFrom("methods", "getClasses") if (getRversion() < "4.5.0") { importFrom("methods", "getMethods") } importFrom("methods", "getClass") importFrom("methods", "isClass") importFrom("utils", "as.person") importFrom("utils", "capture.output") importFrom("utils", "citation") importFrom("utils", "compareVersion") importFrom("utils", "file_test") importFrom("utils", "install.packages") importFrom("utils", "installed.packages") importFrom("utils", "object.size") importFrom("utils", "old.packages") importFrom("utils", "packageDescription") importFrom("utils", "sessionInfo") importFrom("utils", "str") importFrom("utils", "update.packages") importFrom("utils", ".DollarNames") if (getRversion() >= "2.14.0") { importFrom("stats", "getCall") } if (getRversion() >= "3.3.0" && "getSource" %in% getNamespaceExports("utils")) { importFrom("utils", "getSource") } # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # EXPORTS # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Export all public methods, that is, those without a preceeding dot # in their names. exportPattern("^[^\\.]") # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # DECLARATIONS # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # BasicObject S3method(".subset2Internal", "BasicObject") S3method("$", "BasicObject") S3method("$<-", "BasicObject") S3method("[[", "BasicObject") S3method("[[<-", "BasicObject") S3method("as.character", "BasicObject") S3method("attach", "BasicObject") S3method("detach", "BasicObject") S3method("equals", "BasicObject") S3method("extend", "BasicObject") S3method("getFields", "BasicObject") S3method("getInstantiationTime", "BasicObject") S3method("hasField", "BasicObject") S3method("hashCode", "BasicObject") S3method("isReferable", "BasicObject") S3method("newInstance", "BasicObject") S3method("objectSize", "BasicObject") S3method("print", "BasicObject") S3method(".DollarNames", "BasicObject") # character S3method("uses", "character") # Class S3method(".subset2Internal", "Class") S3method("$", "Class") S3method("$<-", "Class") S3method("[[", "Class") S3method("[[<-", "Class") S3method("argsToString", "Class") S3method("as.character", "Class") S3method("forName", "Class") S3method("getDetails", "Class") S3method("getFields", "Class") S3method("getKnownSubclasses", "Class") S3method("getMethods", "Class") S3method("getName", "Class") S3method("getPackage", "Class") S3method("getRdDeclaration", "Class") S3method("getRdHierarchy", "Class") S3method("getRdMethods", "Class") S3method("getStaticInstance", "Class") S3method("getSuperclasses", "Class") S3method("isAbstract", "Class") S3method("isBeingCreated", "Class") S3method("isDeprecated", "Class") S3method("isPrivate", "Class") S3method("isProtected", "Class") S3method("isPublic", "Class") S3method("isStatic", "Class") S3method("newInstance", "Class") S3method("print", "Class") S3method(".DollarNames", "Class") # classRepresentation S3method("getKnownSubclasses", "classRepresentation") S3method("getRdDeclaration", "classRepresentation") S3method("getRdHierarchy", "classRepresentation") S3method("getRdMethods", "classRepresentation") S3method("getSuperclasses", "classRepresentation") # condition S3method("abort", "condition") # default S3method("abort", "default") S3method("attach", "default") S3method("callSuperMethodS3", "default") S3method("charToInt", "default") S3method("detach", "default") S3method("dimension", "default") S3method("equals", "default") S3method("extend", "default") S3method("getConstructorS3", "default") S3method("hashCode", "default") S3method("intToChar", "default") S3method("ll", "default") S3method("load", "default") S3method("objectSize", "default") S3method("save", "default") S3method("setConstructorS3", "default") S3method("throw", "default") S3method("trim", "default") S3method("typeOfClass", "default") # environment S3method("getName", "environment") S3method("objectSize", "environment") # error S3method("throw", "error") # Exception S3method("as.character", "Exception") if (getRversion() >= "2.14.0") { S3method("getCall", "Exception") } S3method("getCalls", "Exception") S3method("getLastException", "Exception") S3method("getMessage", "Exception") S3method("getStackTrace", "Exception") S3method("getStackTraceString", "Exception") S3method("getWhen", "Exception") S3method("print", "Exception") S3method("printStackTrace", "Exception") S3method("throw", "Exception") # Interface S3method("as.character", "Interface") S3method("extend", "Interface") S3method("getFields", "Interface") S3method("print", "Interface") S3method("uses", "Interface") # InternalErrorException S3method("getMessage", "InternalErrorException") S3method("getPackage", "InternalErrorException") # Object S3method(".subset2Internal", "Object") S3method("$", "Object") S3method("$<-", "Object") S3method("[[", "Object") S3method("[[<-", "Object") S3method("as.character", "Object") S3method("attach", "Object") S3method("attachLocally", "Object") S3method("clearCache", "Object") S3method("clearLookupCache", "Object") S3method("clone", "Object") S3method("detach", "Object") S3method("equals", "Object") S3method("extend", "Object") S3method("finalize", "Object") S3method("getEnvironment", "Object") S3method("getFieldModifier", "Object") S3method("getFieldModifiers", "Object") S3method("getFields", "Object") S3method("getInstantiationTime", "Object") S3method("getInternalAddress", "Object") S3method("getStaticInstance", "Object") S3method("hasField", "Object") S3method("hashCode", "Object") S3method("isReferable", "Object") S3method("ll", "Object") S3method("load", "Object") S3method("names", "Object") S3method("newInstance", "Object") S3method("novirtual", "Object") S3method("objectSize", "Object") S3method("print", "Object") S3method("save", "Object") S3method("staticCode", "Object") S3method(".DollarNames", "Object") # Package S3method("as.character", "Package") S3method("getAuthor", "Package") S3method("getBundle", "Package") S3method("getBundlePackages", "Package") S3method("getChangeLog", "Package") S3method("getClasses", "Package") S3method("getContents", "Package") S3method("getContribUrl", "Package") S3method("getDataPath", "Package") S3method("getDate", "Package") S3method("getDescription", "Package") S3method("getDescriptionFile", "Package") S3method("getDevelUrl", "Package") S3method("getDocPath", "Package") S3method("getEnvironment", "Package") S3method("getExamplePath", "Package") S3method("getHistory", "Package") S3method("getHowToCite", "Package") S3method("getLicense", "Package") S3method("getMaintainer", "Package") S3method("getName", "Package") S3method("getNews", "Package") S3method("getPath", "Package") S3method("getPosition", "Package") S3method("getTitle", "Package") S3method("getUrl", "Package") S3method("getVersion", "Package") S3method("isLoaded", "Package") S3method("isOlderThan", "Package") S3method("ll", "Package") S3method("load", "Package") S3method("showChangeLog", "Package") S3method("showContents", "Package") S3method("showDescriptionFile", "Package") S3method("showHistory", "Package") S3method("showHowToCite", "Package") S3method("showNews", "Package") S3method("startupMessage", "Package") S3method("unload", "Package") # RccViolationException S3method("as.character", "RccViolationException") S3method("getRccUrl", "RccViolationException") # Rdoc S3method("argsToString", "Rdoc") S3method("check", "Rdoc") S3method("compile", "Rdoc") S3method("createManPath", "Rdoc") S3method("createName", "Rdoc") S3method("declaration", "Rdoc") S3method("escapeRdFilename", "Rdoc") S3method("getClassS4Usage", "Rdoc") S3method("getKeywords", "Rdoc") S3method("getManPath", "Rdoc") S3method("getNameFormat", "Rdoc") S3method("getObject", "Rdoc") S3method("getPackageNameOf", "Rdoc") S3method("getRdTitle", "Rdoc") S3method("getUsage", "Rdoc") S3method("hierarchy", "Rdoc") S3method("isKeyword", "Rdoc") S3method("isVisible", "Rdoc") S3method("methodsInheritedFrom", "Rdoc") S3method("setManPath", "Rdoc") S3method("setNameFormat", "Rdoc") # RdocException S3method("as.character", "RdocException") S3method("getSource", "RdocException") # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ## Should be renamed/removed from API # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # default S3method("getClasses", "default") if (getRversion() < "4.5.0") { S3method("getMethods", "default") } R.oo/NEWS.md0000644000176200001440000021407514711170612012176 0ustar liggesusers# Version 1.27.0 [2024-11-01] ## Significant Changes * `getMethods()` is an **R.oo** generic in R (>= 4.5.0), whereas in versions before that it is n **methods** generic. This is because `methods::getMethods()` is being deprecated in base R. # Version 1.26.0 [2024-01-23] ## Significant Changes * The `hashCode(s)` implementation for strings was rewritten to avoid integer overflow (see below bug fix). As a consequence, the computed hash is no longer the same for some strings. ## Documentation * Fixed a few small mistakes in the help pages. ## Bug Fixes * `hashCode(s)` could return NA, due to integer overflow, for strings with more than 13-15 symbols, e.g. `hashCode("abcdefghijklmno")` resulted in a missing value and a warning. # Version 1.25.0 [2022-06-11] ## New Features * Now `showNews()` for `Package` recognizes 'NEWS.md' files too. ## Bug Fixes * Rdoc no longer injects a dummy `\emph{}` at the end of `@howtocite` sections, because it now triggers an `R CMD check --as-cran` NOTE. The workaround was used to workaround an `R CMD check` false positive way back in 2004, which has since been fixed. # Version 1.24.0 [2020-08-24] ## New Features * Added `$<-` and `[[<-` for `Object` to the list of S3 methods that tries to ignore objects of class `Object` that are of the kind that **R.oo** creates. This fixes conflicts with `Object` objects that the **arrow** package produces, which are non-**R.oo** objects. Other S3 `Object` methods already do this since **R.oo** 1.20.0 to workaround similar issues with the **rJava** package. ## Bug Fixes * `getDate()` for `Package` returned NA because it was looking for DESCRIPTION field `Date`, which has been renamed to `Date/Publication`. # Version 1.23.0 [2019-11-02] ## Significant Changes * Exporting generic `throw()`, which previously was a re-export of ditto from **R.methodsS3**. This change prevents the message "Registered S3 method overwritten by 'R.oo': ... throw.default R.methodsS3" from appearing when the **R.oo** package is loaded (directly or indirectly). ## Deprecated and Defunct * Removed defunct method `gc()` for `Object`. Use `clearCache(..., gc = TRUE)`. ## CRAN Policy * Don't test `example(getBundle.Package)` because they may take more than 5 seconds when run on CRAN where `installed.packages()` will take a long time due to many thousands of packages. # Version 1.22.0 [2018-04-21] ## New Features * Now generic function `clone()` is always created. This avoids the recurring issues where the creation of generic `R.oo::clone()` was skipped if another `clone()` generic already existed during package installation from source. This would in turn cause for instance the **R.utils** package to fail during loading (**R.utils** Issue #29). Thanks to Matt Dowle for reporting on this and insisting on a fix. ## Deprecated and Defunct * Removed previously defunct `update()` for `Package`; use `update.packages()`. * Removed previously defunct ``registerFinalizer()`` for `Object`. * Previous deprecated `gc()` for `Object` is now defunct; use `clearCache(..., gc = TRUE)` instead. ## Bug Fixes * Method dispatching of `[[<-` for `Object` and `BasicObject` failed when running `R CMD check` in R-devel (>= 3.6.0) with environment variables `_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV` and `_R_S3_METHOD_LOOKUP_USE_TOPENV_AS_DEFENV` both set to TRUE. # Version 1.21.0 [2016-10-30] ## New Features * Now TAB-completion works on elements of `Object`, `BasicObject`, and `Class`. * Now `getElement()` works also for `Object`, `Class`, and `BasicObject`. * `[[()` for `Object`, `Class` and `BasicObject` gained argument `exact`, but `exact = FALSE` is currently ignored and treated as `exact = TRUE`. # Version 1.20.0 [2016-02-17] ## Significant Changes * Package requires R (>= 2.13.0) (April 2011), because **R.methodsS3** effectively requires that version. ## New Features * Some S3 methods for **R.oo** classes `Object` and `Exception` would interfere with ditto for **rJava** objects that had class attributes containing `"Object"` and `"Exception"`. Although these classes have the same name, and therefore are in conflict, they represent completely different classes. For methods where conflicts have been identified, the **R.oo** implementations will try to detect the conflict and call the next method instead. * Now `print()` and `startupMessage()` for `Package` report on package date only if date exists. ## Software Quality * CLEANUP: Explicit namespace imports also from **utils** package. * CLEANUP: Drop unused code. ## Bug Fixes * `clazz[[method]]()` for `Class` object `clazz` did not call the intended static method, as `clazz$()` would do. * `getClasses()` for `Package` would return NULL. # Version 1.19.0 [2015-02-27] ## Software Quality * Now explicitly declare "default" S3 methods for `getClasses()` and `getMethods()`. * Dropped non-ASCII characters from R source comments. ## Bug Fixes * Now `charToInt()` returns integers as documented (was numerics). * `objectSize()` for environment could result in infinite recursive calls if there circular dependencies between environments. Added package test for `objectSize()` including this case. * `getKnownSubclasses()` for `Class` could throw an error if one of the objects "scanned" for being a function and of class `Class` would thrown an error from just looking at it. See R-devel thread 'Inspect a "delayed" assigned whose value throws an error?' on 2015-01-26 for details. * Forgot to explicitly import `getClasses()` and `getMethods()` from the **methods** package. Interestingly, this one has never given an error. * `getStaticInstance()` for `Object` now searches the parent/calling environment as well. This covers the case when constructors and objects are created in a local environment (contrary to package namespaces and the global environment). # Version 1.18.5 [2015-01-05] ## Deprecated and Defunct * Now `update()` for `Package` is defunct; use `update.packages()`. # Version 1.18.4 [2014-12-29] ## New Features * Added argument `decreasing` to `ll()`, e.g. `ll(sortBy = "objectSize", decreasing = TRUE)`. # Version 1.18.3 [2014-10-18] ## Bug Fixes * `Rdoc$compile()` and Rdoc tag `@allmethods` failed to provide links and titles on non-exported S3 methods. # Version 1.18.2 [2014-04-26] ## Bug Fixes * Now `Rdoc$getRdUsage()` escapes `%*%` to `\%*\%` in the Rd output. # Version 1.18.1 [2014-03-30] ## Bug Fixes * Now `getRdDeclaration()`, `getRdHierarchy()`, and `getRdMethods()` for `Class` handles also non-exported methods and classes. # Version 1.18.0 [2014-02-22] ## Significant Changes * A registered finalizer function for `Object`:s no longer calls `finalize()` on the `Object` itself unless the **R.oo** package is loaded, whereas previously it would have tried to temporarily reattach the **R.oo** package. On the other hand, it is now sufficient to have **R.oo** loaded for `finalize()` to be called, whereas in the passed it also had to be attached. ## Deprecated and Defunct * Deprecated `gc()` for `Object`. Use `clearCache(..., gc = TRUE)` instead. # Version 1.17.1 [2014-02-05] ## Significant Changes * Argument `properties` of `ll()` defaults to an options, which if not set in turn defaults to a given value. The `ll()` method is no longer trying to set that option if missing. The option is also no longer set when the package is attached. # Version 1.17.0 [2014-01-05] ## New Features * Now `Class$forName()` searches all loaded namespaces as a last resort. # Version 1.16.2 [2014-01-05] ## New Features * Now static method `Class$forName()` accepts optional `envir` argument for specifying from where to search for the `Class` object. * Added argument 'gc = FALSE' to `clearCache()`. It is recommended to start using `clearCache(obj, gc = TRUE)` instead of `gc(obj)`. ## Deprecated and Defunct * Defunct ``registerFinalizer()`` for `Object`. ## Bug Fixes * The temporary `finalizer()` registered for `Object` while loading the **R.oo** package itself would cause cyclic loading of **R.oo**. The reason was that it checked whether **R.oo** was available or not, by only looking at attached namespaces but not loaded ones. This bug was introduced in **R.oo** 1.16.0. # Version 1.16.1 [2014-01-04] ## Software Quality * Added several missing `importFrom()` and `S3method()` statements to the NAMESPACE file. # Version 1.16.0 [2013-10-13] ## New Features * Added argument 'finalize' to `Object()` to specify whether a finalizer should be registered or not. If so, then generic function `finalize()` is called on the `Object`. Furthermore, `extend()` for `Object` gained argument `...finalize`, which, regardless of argument `finalize` of `Object`, force the registration of a finalizer (`...finalize = TRUE`) or the removal of one (`...finalize = FALSE`). If `...finalize = NA` (default), then the finalizer is enabled/disabled according to argument `finalize` of `Object`. For backward compatibility reasons, the default behavior is still to register a finalizer for `Object`:s, but this may change in a future release. ## Software Quality * Now the package's system tests assume that it's only the **base** package that is attached. ## Bug Fixes * Now `Object` finalizers will no longer try to re-attach the **R.oo** package if `library()` is in the process of trying to attach another package, because otherwise a cyclic loading of namespaces may occur. This was observed for a package that allocated a temporary `Object` `.onAttach()` which then was garbage collected and finalized. # Version 1.15.8 [2013-10-10] ## Bug Fixes * It appears that when loading the package it may happen that the **R.oo** namespace is loaded cyclicly, though this has only been observed while running `R CMD INSTALL`. This may be because a `Package` object (`R.oo::R.oo`) is assigned during the loading of the namespace. Since `Package` `extends()` an `Object` object, this may end up loading **R.oo** again. To avoid this, `R.oo::R.oo` is now assigned using delayed assignment. # Version 1.15.7 [2013-10-08] ## Software Quality * Now using `inherits = FALSE` in several internal `exists()`/`get()` calls. # Version 1.15.6 [2013-10-07] ## New Features * Now Rdoc tag `@howToCite` does a better job when there are multiple citations in CITATION. ## Software Quality * Now importing `getCall()` from **stats**, iff R (>= 2.14.0). # Version 1.15.5 [2013-09-28] ## New Features * Now the **R.oo** `Package` object is also available when the package is only loaded (but not attached). # Version 1.15.4 [2013-09-26] ## Deprecated and Defunct * Deprecated `update()` for `Package`. * Deprecated non-used `registerFinalizer()` for `Object`. # Version 1.15.3 [2013-09-23] ## Software Quality * Now properly declaring all S3 methods in the NAMESPACE file. # Version 1.15.2 [2013-09-20] ## Software Quality * ROBUSTNESS: Forgot to import `R.methodsS3::appendVarArgs()`. ## Bug Fixes * The finalizer function registered by `extend()` for `Object`:s assumed that the **utils** is attached while calling `capture.output()`, which under certain conditions could generate 'Error in getObjectInfo(this) : could not find function "capture.output"' while the garbage collector was running. In extreme cases it could also crash R. # Version 1.15.1 [2013-08-29] ## New Features * `library("R.oo", warn.conflicts = FALSE, quietly = TRUE)` will load the package completely silently. * Now `startupMessage()` for `Package` acknowledges `library(..., quietly = TRUE)`. * `setConstructorS3()` no longer requires that **R.oo** is attached ("loaded"). # Version 1.15.0 [2013-08-23] ## New Features * Now `getHowToCite()` for `Package` utilizes `utils::citation()`, if package don't contain a HOWTOCITE file. It is recommended to write packages with CITATION instead of HOWTOCITE. ## Documentation * Hiding non-essential methods from the Rd help index, e.g. `charToInt()`, `intToChar()`, `hashCode()`, `equals()`, `dimension()`, and `trim()`. ## Software Quality * Package no longer utilizes `:::`. ## Deprecated and Defunct * Made `get-` and `showHowToCite()` protected methods. * Dropped deprecated inst/HOWTOSITE replaced by inst/CITATION. # Version 1.14.0 [2013-08-20] ## New Features * Now it's possible to call static methods without attaching ("loading") the package, e.g. `R.oo::Class$forName("Object")`. Added unit tests for this. * Now `getPackage()` for `Class` first searches the namespace of the `Class` object and then the attached ("loaded") packages. * Now `$` and `$<-` for `Object` locates the static instance of the `Class` using `getStaticInstance()` for `Object`. * Updated `getStaticInstance()` for `Object` to search more locations. # Version 1.13.10 [2013-07-11] ## New Features * Now `R.oo::ll()` works without attaching the package. This is done by attaching **R.oo** when called. * Now it is possible to use static methods of a `Class` without attaching the package where the `Class` is defined, e.g. `R.utils::Arguments$getIndex(2)`. To enable this feature, `options("R.oo::Class/searchNamespaces"=TRUE)` must be set. ## Bug Fixes * `ll(private = TRUE)` gave an error if the environment contained the special `...` argument. # Version 1.13.9 [2013-07-01] ## Software Quality * Bumped up package dependencies. # Version 1.13.8 [2013-06-27] ## New Features * Added a trial version of Rdoc tag `@usage`. # Version 1.13.7 [2013-05-30] ## New Features * Now `Rdoc$compile()` infer the package name from the DESCRIPTION file (instead from the package directory name). * Added argument `path` to `compileRdoc()`. # Version 1.13.6 [2013-05-25] ## Performance * Minor speedup by replacing all `rm(x)` with `rm(list = "x")`. # Version 1.13.5 [2013-05-20] ## New Features * Now `Rdoc$getUsage()` inserts line breaks so that any usage line is at most 90 characters long. ## Documentation * CRAN POLICY: Now all Rd `\usage{}` lines are at most 90 characters long. # Version 1.13.4 [2013-04-08] ## New Features * Now the `@RdocData` Rdoc tag also adds an `\docType{data}` Rd tag. # Version 1.13.3 [2013-04-04] ## Bug Fixes * In **R.oo** v1.13.1, a bug was introduced causing the value of Rdoc tag `@allmethods` not to be parsed and instead treated as text. # Version 1.13.2 [2013-04-03] ## New Features * Now `Rdoc$compile()` outputs the same Rd files regardless of system settings. More precisely, it always uses `\n` for line breaks and locale "C" (default) for sorting strings. * Now `Rdoc$compile(..., filename)` handles when argument `filename` is a vector of filenames. # Version 1.13.1 [2013-03-25] ## New Features * Now `Rdoc$compile(..., check = TRUE)` saves the erroneous Rd to file before throwing the exception. This helps troubleshooting. ## Bug Fixes * `Rdoc$compile()` could sometimes drop `}` following Rdoc tags. # Version 1.13.0 [2013-03-08] ## New Features * Added support for Rdoc tag `@author` to have an optional value, e.g. `@author "John Doe"` as well as `@author "JD, FB"` where the initials are inferred from the package's DESCRIPTION file. * Added `compileRdoc()` to make it easier to compile Rdoc comments into Rd help files, e.g. `Rscript -e "R.oo::compileRdoc()"`. * Now `getAuthor()` and `getMaintainer()` for `Package` use the `Authors@R` field of DESCRIPTION and if not found, then the `Author`/`Maintainer` fields. In addition, using argument `as = "person"` will parse and return the results as a `person` list. ## Software Quality * Added an `Authors@R` field to the DESCRIPTION. # Version 1.12.0 [2013-03-04] ## New Features * It is now easier to find help for static method, e.g. `help("Object$load")` and `?"Object$load"`. * For "static" methods (e.g. `Object$load()`), the Rdoc compiler now generates a `\usage{}` section without the deprecated Rd markup `\synopsis{}`, which has been replaced by the static call placed in a comment. It also uses the static method as the name and alias (e.g. `\name{Object$load}`). # Version 1.11.7 [2013-01-08] ## Bug Fixes * ROBUSTNESS: Made the `Object` finalizers reentrant. This was previously not the case on R prior to R v2.15.2 Patched r61487 iff the garbage collection is triggered from within `base::parse()` and the **R.oo** package is not already loaded when the finalizer is called. In such cases, R could crash. Added a package system test for this. Thanks to Duncan Murdoch (R core) for reporting on this and R core for making `base::library()` reentrant in R (>= 2.15.2 Patched r61487). # Version 1.11.6 [2013-01-08] ## New Features * Added argument `format` to `getInternalAddress()` for `Object`. ## Bug Fixes * The hexadecimal string returned by `as.character()` for `Object` would contain the decimal value and not the hexadecimal one. # Version 1.11.5 [2012-12-28] ## Software Quality * Further preparation for supporting **R.oo** and its derived packages to be imported without attaching ("loading") them. * Replaced all `data.class(obj)` with `class(obj)[1L]`. ## Bug Fixes * `getMethods()` for `Class` would give an error if no methods were found for the queried `Class`. * In the rare case where `getStaticInstance()` for `Class` failed to setup a static instance, the temporary state set internally would not be unset. # Version 1.11.4 [2012-12-19] ## New Features * Added `startupMessage()` for `Package`. # Version 1.11.3 [2012-12-18] ## Software Quality * `R CMD check` for R devel no longer gives a NOTE on `attach()`. # Version 1.11.2 [2012-11-29] ## Performance * Made `getKnownSubclasses()` for `Class` a bit faster. # Version 1.11.1 [2012-11-28] ## Significant Changes * LIMITATION: Registered finalizer for pure `Object`:s (i.e. excluding those which are of a subclass of `Object`) will no longer be called if the **R.oo** package has been detached. This should be a very unlikely scenario. ## Bug Fixes * `extend()` for `Object` dropped existing field modifiers. # Version 1.11.0 [2012-11-23] ## New Features * Now `getStaticInstance()` for `Class` sets the environment for the returned `Object` to that of the `Class`. ## Software Quality * Preparing for better support for `Object`/`Class` in import-only namespaces, i.e. without packages being loaded. # Version 1.10.3 [2012-11-18] ## New Features * Updated the URL returned by `RccViolationException$getRccUrl()`. ## Software Quality * ROBUSTNESS: Now nearly all S3 methods are declared properly in the namespace. # Version 1.10.2 [2012-11-07] ## Bug Fixes * `obj$(...)` would throw an error iff the `Object` `obj` was saved or instantiated by **R.oo** (< 1.10.0). Code is now backward compatible with this case. Thanks Roger Day at University of Pittsburgh Cancer Institute and Dan Tenenbaum (BioC core) for reporting on this. # Version 1.10.1 [2012-10-16] ## Bug Fixes * No longer passing `...` to `NextMethod()`, cf. R-devel thread 'Do \*not\* pass ... to NextMethod()' - it'll do it for you; missing documentation, a bug or just me?' on Oct 16, 2012. # Version 1.10.0 [2012-10-14] ## New Features * GENERALIZATION: Now `$(...)` calls the corresponding generic function `(static, ...)`, where `static` is the static object of `Class` ``. This allows for using `NextMethod()` in static functions. Calls to `$(...)` and `$(...)` were adjusted analogously. * Now `throw()` for Exception outputs the error message both above and below the stack trace, which is particularly useful when the stack trace is long. ## Bug Fixes * The stacktrace details collected by `Exception` dropped the names of the functions. # Version 1.9.10 [2012-09-14] ## Bug Fixes * The `Exception` constructor could generate warning `In if (regexpr("^function \\(", code) != -1) return("") : the condition has length > 1 and only the first element will be used` occurring in its local `fcnName()` function. Now code no longer assumes that `code` is of length 1. # Version 1.9.9 [2012-09-11] ## New Features * Now `throw()` for `Exception` aborts (after signalling and outputting the message) by calling `stop()`. Ideally it should utilize `abort()`, but the new version of `abort()` may be "caught" is certain cases. ## Software Quality * ROBUSTNESS/CRAN POLICY: Updated `abort()` for condition to utilize `invokeRestart("abort")`. This avoids having to call `.Internal(.signalCondition(...))`. It also means that the message outputted by `abort()` no longer starts with a "Error in ...:" line. `abort()` imitates how `stop()` works, but without the signalling. ## Bug Fixes * `getContribUrl()` and `getDevelUrl()` would give an error if corresponding fields did not exists in the DESCRIPTION file. Now they return NAs just as `getUrl()`. # Version 1.9.8 [2012-06-22] ## New Features * GENERALIZATION: Added `newInstance()` for `BasicObject`. * ROBUSTNESS: Now constructor `BasicObject()` is guaranteed to return an object with non-duplicated class attribute elements. # Version 1.9.7 [2012-06-20] ## Deprecated and Defunct * Dropped non-used adjusted `getClass()` generic function, which means that now there is one less function masking the **methods** package. ## Bug Fixes * `throw()` for `Exception` would give an error in R (< 2.14.0), where no generic `getCall()` exists. Now it works for all versions of R. # Version 1.9.6 [2012-06-11] ## Bug Fixes * `Rdoc$getKeywords()` now uses system environment variable `R_DOC_DIR` for locating the internal KEYWORDS.db. Thanks Charles Hogg at NIST for suggesting this. # Version 1.9.5 [2012-04-20] ## New Features * Added argument `export` to `setConstructorS3()`. * Now `Rdoc$getUsage()` searches also the package namespace for the function/method definition. This is done, before looking in the global search path. ## Deprecated and Defunct * `setConstructorS3()` no longer sets attribute `formals`. It has been deprecated since April 2003. # Version 1.9.4 [2012-04-05] ## Software Quality * Now package imports and exports `getCall()` from the **stats** package so that generic function `getCall()` is available for `Exception`:s also when **stats** is not loaded, e.g. during executing `.Rprofile`. # Version 1.9.3 [2012-03-18] ## New Features * Now it is possible to set the default value of argument `cleanup` of `getStackTrace()` for `Exception` via an option. # Version 1.9.2 [2012-03-08] ## New Features * Made stack traces of `Exception`:s more informative and cleaner. * Now the default `throw()` of **R.methodsS3** is "quietly" overwritten, i.e. there is no longer a warning about it when **R.oo** is loaded. * Now package no longer warns about renaming existing functions `getMethods()` and `getClasses()` of **base** to default methods during installation, iff **R.methodsS3** (>= 1.2.3). # Version 1.9.1 [2012-03-05] ## New Features * CLEANUP: `throw()` for `error` is now just a wrapper for `stop()`. Previously it had to do what `stop()` now does for `condition` objects. ## Software Quality * CRAN POLICY: Replaced all `appendVarArgs()` for **base** functions that do `.Internal()` calls, because they would then appear as local functions of this package and hence not be accepted by CRAN according to their new policies. Instead we now create "default" functions that are wrappers to the corresponding functions in the **base** package. Extra care has to be taken for functions that have arguments whose values are dependent on the call environment/closure. * CRAN POLICY: Dropped `.Internal()` calls in the default `ll()` method, in `getMethods()` for `Class` objects, and in `throw()` for `Exception`:s. # Version 1.9.0 [2012-02-23] ## Software Quality * Now the package imports **utils** instead of depending on it. This means that all packages that depends on **R.oo** for loading **utils** for them need to explicitly load it themselves. * The **R.oo** package now requires (at least) R v2.4.0 (Oct 2006!) # Version 1.8.3 [2011-11-01] ## Software Quality * CLEANUP/FIX: Dropped `package.description()` from `getDescriptionFile()` for `Package`, which was done for compatibility reasons when it was deprecated in R v1.9.0. It will be dropped completely in R v2.15.0. # Version 1.8.2 [2011-08-25] ## Documentation * Added further clarification to `help(setConstructorS3)` about the requirement that constructors defined by `setConstructorS3()` have to be callable without arguments. # Version 1.8.1 [2011-07-10] ## Software Quality * Changed first argument of `getCall()` to `x`, because that is what the new `getCall()` method of **stats** in R v2.14.0 uses. # Version 1.8.0 [2011-04-03] ## New Features * ROBUSTNESS: Now finalizers for `Object`:s are registered to be called also when the R session is quit, if the `R.oo::Object/finalizeOnExit` option is TRUE. If FALSE (default), as before, the finalizers were only executed when `Object`:s were cleaned up by the garbage collector. * Turned of the default instantiation timestamp for `Object` and `BasicObject`. The main reason is that it makes it very complicated to calculate reproducible checksums. However, for backward compatibility, it is possible to turn on the timestamp by setting option `R.oo::Object/instantiationTime`. For `BasicObject` there is option `R.oo::BasicObject/instantiationTime`. * Added protected `getFieldModifiers()` and `getFieldModifier()`. * Added argument `recursive` to `clearCache()` for recursively traversing all elements are clearing the cache of all detected `Object`:s. * Now `clearCache()` also calls `clearLookupCache()`. * Added protected `clearLookupCache()` for clearing internal objects stored in the `Object` and that are used for faster field lookups. ## Deprecated and Defunct * Dropped deprecated `getInstanciationTime()`. # Version 1.7.5 [2011-02-01] ## Software Quality * Now using `inherits` (not `inherit`) in all calls to `get()` and `exists()`. # Version 1.7.4 [2010-09-22] ## New Features * Now Rdoc lines are allowed to start with double (`##`) or triple (`###`) comment characters in addition to single (`#`) ones. # Version 1.7.3 [2010-06-04] ## Significant Changes * Now argument `addTimestamp` of `Rdoc$compile()` defaults to FALSE. This way the generate Rd file will remain identical unless there are real Rdoc/code changes. Not adding timestamps is better when working with a version control systems. ## Bug Fixes * If there are no Rd files, then `check()` of `Rdoc` would throw the error "object 'res' not found". # Version 1.7.2 [2010-04-13] ## Bug Fixes * `Package(pkg)` would throw "Error in Package(pkgname) : object 'package' not found", if `pkg` is installed in multiple libraries. # Version 1.7.1 [2010-03-17] ## Bug Fixes * Loading the package would generate warnings of several conflicts. Forgot to export `.conflicts.OK` after adding the namespace. # Version 1.7.0 [2010-03-13] ## Software Quality * Added a NAMESPACE. # Version 1.6.7 [2010-01-21] ## Documentation * Added some more "get started" help to `help(R.oo)`. # Version 1.6.6 [2009-11-19] ## New Features * Added `isOlderThan()` for `Package`. # Version 1.6.5 [2009-10-30] ## New Features * ROBUSTIFICATION: Lowered the risk for `save()` of `Object` to leave an incomplete file due to say power failures etc. This is done by first writing to a temporary file, which is then renamed. If the temporary file already exists, an exception is thrown. # Version 1.6.4 [2009-10-27] ## Software Quality * Removed a stray `print()` statement in `attachLocally()` for `Object`:s. # Version 1.6.3 [2009-10-26] ## New Features * Added `objectSize()` for environments. ## Bug Fixes * `Rdoc$compile()` did not work with R v2.10.0 and newer. # Version 1.6.2 [2009-10-16] ## Software Quality * Some cleanup of Rd files to meet the stricter requirements. # Version 1.6.1 [2009-10-09] ## Bug Fixes * `getBundle()` of `Package` gave "Error in getBundle.Package(pkg) : subscript out of bounds" starting with R v2.10.0. # Version 1.6.0 [2009-10-02] ## New Features * Added the `Interface` class, which is in an alpha version. # Version 1.5.0 [2009-09-09] ## Documentation * Fixed broken/missing Rd links. # Version 1.4.9 [2009-07-07] ## New Features * Added protected method `registerFinalizer()` for `Object`. # Version 1.4.8 [2009-05-18] ## Documentation * The titles for `intToChar()` and `charToInt()` where mixed up. Thanks to Jens Philip Hoehmann for reporting this. # Version 1.4.7 [2009-01-10] ## Documentation * There were some Rd warnings with the new R v2.9.0. # Version 1.4.6 [2008-08-11] ## New Features * Added support for more "short tags" in the Rdoc compiler. ## Software Quality * Replaced all `a %in% b` with `is.element(a,b)` due to an old and weird bug that I cannot reproduce, cf. my R-devel post in thread 'Argument "nomatch" matched by multiple actual arguments ... %in% -> match?!?' on March 6, 2008. Thanks Ran Pang for reminding me and for additional troubleshooting. # Version 1.4.5 [2008-05-28] ## New Features * SPELL CORRECTION: Added `getInstantiationTime()`, but keeping misspelled (and now deprecated) `getInstanciationTime()` for backward compatibility. The internal attribute was also renamed, but the above method look for both in case saved objects are loaded. # Version 1.4.4 [2008-05-08] ## New Features * Added `getNews()` and `showNews()` to the `Package` class. NEWS files are now detected (first). * Added `getConstructorS3()`. * The NEWS file does now replace the former HISTORY file of **R.oo**. * If running R v2.7.0 or new, the first element of vector `ASCII` is an empty string. This is because ASCII 0x00 cannot be represented as an R string and in R v2.8.0 it will give a warning. Note though that regardless of this, `charToInt(intToChar(0)) == 0` is still TRUE. # Version 1.4.3 [2008-03-25] ## New Features * Added `getName()` for `environment`:s. ## Bug Fixes * `getInternalAddress()` would return NA. # Version 1.4.2 [2008-03-06] ## New Features * Added paper to `citation("R.oo")`. ## Bug Fixes * Regular expression pattern `a-Z` is illegal on (at least) some locale, e.g. 'C' (where `A-z` works). The only way to specify the ASCII alphabet is to list all characters explicitly, which we now do in all methods of the package. See the r-devel thread "invalid regular expression '[a-Z]'" on 2008-03-05 for details. # Version 1.4.1 [2008-01-10] ## Bug Fixes * Made the registered finalizer calling `finalize()` more error prone. # Version 1.4.0 [2007-09-17] ## Significant Changes * Extracted `setMethodS3()` and related methods from **R.oo** and put them in a standalone **R.methodsS3** package. While doing this, the `enforceRCC` argument used by `setMethodS3()` was renamed to `validators` which now takes an optional list of functions. Any code using argument `enforceRCC = FALSE` must now use `validators = NULL`. ## Deprecated and Defunct * Removed code that patched R v1.8.0 and before. # Version 1.3.0 [2007-08-29] ## New Features * Now the startup message when loading the package is generated with `packageStartupMessage()` so that it can be suppressed. ## Deprecated and Defunct * Removed `showAndWait()` for `simpleError`, which displayed a TclTk dialog for a generic error. Never used. If someone wants the code, please tell me and I'll forward it. * Removed deprecated `trycatch()`; use `tryCatch()` instead. * Removed patched for R v1.8.x and before: `stop()`, `try()`. ## Bug Fixes * If `Object`:s are garbage collected after **R.oo** has been detached, the error 'Error in function (env) : could not find function "finalize"' would be thrown, because the registered finalizer hook tries to call the generic function `finalize()` in **R.oo**. We solve this by trying to reload **R.oo** (and the unload it again). Special care was taken so that `Object`:s allocated by **R.oo** itself won't cause an endless loop. # Version 1.2.8 [2007-06-09] ## Software Quality * Removed (incorrect) argument name `list` from all `substitute()` calls. ## Deprecated and Defunct * Removed already deprecated `getData()` because there might be a name clash with the **nlme** package. ## Bug Fixes * Queried non-existing object `error` instead of `ex` in the exception handling of `update()` of the `Package` class. # Version 1.2.7 [2007-04-07] ## Significant Changes * Removed support for R v2.0.0 and before. ## Deprecated and Defunct * Removed `reportBug()` since it was never completed. # Version 1.2.6 [2007-03-24] ## New Features * Now `ll()` uses `objectSize()` instead of `object.size()`. It also returns the properties in its "minimal" data type, e.g. the `objectSize` column contains integers (not characters as before). This makes it possible to utilize `subset()` on the `ll()` output. * Added a default method for `objectSize()`, which is just a wrapper for `object.size()`. ## Deprecated and Defunct * Made `trycatch()` defunct, i.e. it gives an error suggesting to use `tryCatch()` instead. # Version 1.2.5 [2007-01-05] ## Bug Fixes * `getMethods(..., private = FALSE)` for class `Class` would return private methods, and `private = TRUE` would remove them. It should be the other way around. * `getMethods()` for `Class` would sometimes give error message: "Error in result[[k]] : subscript out of bounds". This in turn would cause Rdoc to fail. # Version 1.2.4 [2006-10-03] ## Bug Fixes * Since `getInternalAddress()` coerced the address to an integer, addresses about 2^32 bytes = 4 GiB got address NA. Now `getInternalAddress()` and the default `hashCode()` return a double. # Version 1.2.3 [2006-09-07] ## Software Quality * Added package **utils** as a package this one depends on. This is required for package without a namespace in the upcoming R v2.4.0 release. ## Deprecated and Defunct * Removed deprecated method `getClass()` for class `Object` but also `BasicObject`. These were deprecated on 2002-12-15. # Version 1.2.2 [2006-08-11] ## New Features * Added support for give modifiers to fields in classes extending the `Object` class. Currently it is only the "cached" modifier that is recognized. To specify that a field, say, `foo` is "cached", list it as `cached:foo`. Fields that are "cached" will be assigned to NULL when `clearCache()` of the object is called. For convenience there is also a `gc()` method for all `Object`:s. See `?gc.Object` for an example. ## Software Quality * Made the package smaller by removing the DSC-2003 logo from the **R.oo** paper, which shrunk from 324 KiB to 220 KiB. The rest of the files in the source distribution is about 80 KiB when gzipped, i.e. still the paper is three times larger than the rest of the package. # Version 1.2.0 [2006-07-14] ## Bug Fixes * `update(R.oo)` would throw an error and the package was detached. # Version 1.1.9 [2006-06-14] ## New Features * Added method `getEnvironment()` to class `Object`, which will return the environment where the `Object`'s members are stored. * Now `ll()` does not assign variables in the lookup environment, which means it will work with sealed environments too. # Version 1.1.8 [2006-05-30] ## New Features * Added `isBeingCreated()` to `Class` in order to check if the constructor was called to create the static instance or just any instance. * Now the Rdoc tag `@allmethods` takes an optional argument specifying if private, protected or public methods should be listed. ## Deprecated and Defunct * Removed `setClassS3()`, which has been deprecated since 2003(!). # Version 1.1.7 [2006-05-22] ## New Features * Added argument `addTimestamp = TRUE` to `Rdoc$compile()`. This makes it possible to turn of the timestamp, because timestamps makes diff, say the one in Subversion, think there is a real different. ## Bug Fixes * `Rdoc$compile()` did not write the name of the source file in the header (anymore). * The code for automatic formatting of replacement methods generated an error. # Version 1.1.6 [2006-04-03] * This version was committed to CRAN. ## New Features * Now the Rdoc compiler recognizes replacement functions and creates the correct Rd `\usage{}` format for these. # Version 1.1.5 [2006-03-28] ## New Features * Now argument `properties` of `ll()` is given by the option `R.oo::ll/properties`. If not set when the package is loaded, it is set to a default value. See `help(ll)` for more details. This was suggested by Tim Beissbarth, German Cancer Research Center. ## Bug Fixes * `showHistory()` for the `Package` class was calling itself. * Compiling Rdoc comments with invalid keyword tags would generate an internal error. Same for invalid visibility tags etc. # Version 1.1.4 [2006-02-18] ## New Features * Now the Rdoc compiler also escapes Rd filenames for `@see` and `@seemethod` tags. # Version 1.1.3 [2006-02-09] ## New Features * Added `getChangeLog()` and `showChangeLog()` to the `Package` class. The `get-` and `showHistory()`, which are to be made deprecated in the future, are now wrappers for these two methods. * Added Rdoc tag `@RdocPackage` to generate `-package.Rd` files. * Now the Rdoc compiler makes sure that the generated Rd files all starts with a letter or a digit. If not, it adds a default prefix (currently `000`). If not, the new R v2.3.0 `R CMD check` may complaint about missing objects. ## Software Quality * Removed all usage of NULL environments since they are now deprecated in R v2.3.0. * Now `...` is added explicitly to `setMethodS3()` in all Rd examples. # Version 1.1.2 [2006-01-06] ## New Features * Added Rd links to classes listed under "Directly known subclasses:". # Version 1.1.1 [2005-11-23] ## New Features * Added validation of arguments in replacement functions. * Added RCC validation of arguments in "picky" methods, e.g. `$()`. ## Bug Fixes * The `$<-` function goes through alternatives where to save the new value, e.g. `set()`, `` field, static `` field etc. When a "match" found and the value was assigned, it did not return (except for the `set()` match), but instead continued search for the rest. One effect of this was that the new value was always assign to the static field too. The fix make the code run faster too. Thanks Edouard Duchesnay at Service Hospitalier Frédéric Joliot, Commissariat à l'Energie Atomique, France for spotting this. # Version 1.1.0 [2005-07-18] ## New Features * Added argument `replaceNewline` to `getDescription()` of `Package`. * Now `as.character()` of `Package` reports the title, the license, and the description, but no longer if the package is part of a bundle. The latter was too slow since it had to scan all installed packages. * Now `print()` of `Class` passes `...` to `getDetails()`, that is, now `print(Class, private = TRUE)` will work too. * Added `attachLocally()` to the `Object` class. * Added `extend.default()`, which can be used to extend any type of object. * Now pure `Object`:s are also finalized. Before only subclasses defined via `extend(, "", ...)` was finalized. This was not a big deal, because the `finalize()`:er of the `Object` class is empty anyway. ## Documentation * Added a section on "Defining static fields" to the help page of `Object`. ## Bug Fixes * `Rdoc$compile()` sometimes generated the error `invalid regular expression '\name{[^\}]*}'` (forgot to escape `{` and `}`). Fixed. Thanks Lorenz Wernisch, School of Crystallography, University of London for reporting this. * `getDetails()` in `Class` would list private and protected methods as public. * Argument `enforceRCC` of `setMethodS3()` was not passed to `setGenericS3()`. # Version 1.0.5 [2005-06-03] ## New Features * Now the static `load()` method in `Object` asserts that the loaded `Object` inherits from the class that the static object, which is used to call `load()`, is of. Thus, `Object$load(...)` will load all `Object`:s, whereas `MyClass$load(...)` will only load objects inheriting from `MyClass`. * Now an `@RdocMethod` tag will not add keyword "internal" if the class starts with a lower case, e.g. `matrix`. * A `@keyword foo` can now be removed with `@keyword -foo`. Order is irrelevant, since `@keyword`:s are added at the very end. # Version 1.0.4 [2005-05-02] ## New Features * Added `getDevelUrl()` to the `Package` class. # Version 1.0.3 [2005-02-28] ## New Features * Argument `appendVarArgs` of `setMethodS3()` is now ignored if a replacement function (named `nnn<-`) is defined. # Version 1.0.2 [2005-02-25] ## Bug Fixes * `setMethodS3(..., abstract = TRUE)` generated warnings of type `using .GlobalEnv instead of package:`. Found a way (ad hoc?) to get rid of them. See source code for details. This should remove similar warnings from packages loading **R.oo**. # Version 1.0.1 [2005-02-20] ## New Features * Package now outputs "See ?R.oo for help" when loaded. * `setMethodS3(..., abstract = TRUE)` now defines abstract methods with `...` as the only argument(s). ## Software Quality * Now using three-digit version numbers, e.g. a.b.c where a,b,c in 0,1,...,9. 'a' is updated for major updates, 'b' for minor updates and 'c' is for minor revisions. * Removed `require(methods)` for R v2.0.0 and above. # Version 1.00 [2005-02-15] ## Significant Changes * Moved to CRAN. # Version 0.70 [2005-02-15] ## New Features * Added `appendVarArgs = TRUE` to `setMethodS3()`, which specifies that `...` should be added, if missing. * Add argument `...` to all methods to make it even more consistent with any generic function. This is also done for a few methods in the R base packages. ## Software Quality * Package now passes `R CMD check` on R v2.1.0 devel without warnings. # Version 0.69 [2005-02-11] ## New Features * Renamed `get-` & `showDescription()` to `get-` & `showDescriptionFile()` and added `getDescription()` to get the `Description` field of DESCRIPTION. ## Documentation * Added an example to `setMethodS3()` that is not using `Object()`. ## Software Quality * Package now passes `R CMD check` on R v2.1.0 devel also. Had to modify a few lines of code to meet the new stricter regular expression patterns. ## Deprecated and Defunct * Moving away from `trycatch()` in favor of `tryCatch()`. `trycatch()` remains for a while, but will be made deprecated in future version and later probably defunct. # Version 0.68 [2005-02-09] ## New Features * By default, now `Rdoc$compile()` runs `Rdoc$check()` at the end. * Rdoc: Added a first simple test for undefined top-level tags in the generated Rd code. Utilizes `tools::Rd_parse()`, which might be renamed etc. according to its help page. * Tag-variables such as `@author` now search for value in `options()` too. # Version 0.67 [2004-10-23] ## Bug Fixes * `getRdMethods()` in `Class` returned empty `\tabular{rll}{}` if no methods exist, but this gives an error in `R CMD Rdconv`. # Version 0.66 [2004-10-21] ## New Features * When using `setMethodS3(..., abstract = TRUE)` in a package that uses lazy loading, which all new packages do by default, warnings like "using .GlobalEnv instead of package:utils" will be generated the first time the abstract method is accessed. This is because `eval()` is used to create the abstract method; we are looking for a way that will not generate these warnings, although they are not serious. Example: `library(R.colors); print(getColorSpace.Color)`. * Added `getEnvironment()` to the `Package` class. ## Documentation * Added help to more methods. ## Software Quality * Made the package compatible with R v2.0.0 too. Had to move example file 'Exception.R' from data/ to inst/misc/ and update the help example for Rdoc. Update the example of `unload()` for the `Package` class to load the **boot** package instead of obsolete **ts**. ## Bug Fixes * Rdoc tags was not be parsed by the Rdoc compiler for deprecated methods. # Version 0.65 [2004-06-27] ## New Features * Substantially improved the loading of all my packages. The `Package()` constructor, which was called when a new package was loaded, was slow unnecessarily slow because of an internal call to `installed.packages()`. * Added known generic function `as.vector()`. ## Documentation * Added documentation to many methods. ## Bug Fixes * `getInternalAddress()` for class `Object` was "too" hard coded making it not work correctly on for instance Suse Linux. Assumed fixed positions of the hexadecimal address of the environment. Now a `gsub()` with a backreference is used. Should be more safe. # Version 0.64 [2004-04-21] ## Bug Fixes * Fixed deprecated warning about `package.description()` that occurred R v1.9.0 such that the code still works for older versions of R. This was needed for the `Package` class. # Version 0.63 [2004-03-03] ## New Features * Updated `trycatch()` (and the `Exception` class) to work with R v1.8.1. If running R v1.8.1, then `tryCatch()` is used internally. For R v1.7.1 and before the old `trycatch()` is used, which will be made deprecated later on. Added a `throw()` for the error class too for rethrowing errors. * Update the Rdoc compiler to generate correct `\name` and `\alias` Rd tags. ## Deprecated and Defunct * To anyone using `setClassS3()`, please use `setConstructorS3()` instead; `setClassS3()` is deprecated and will be phased out soon! ## Bug Fixes * `Package` class - from R v1.8.1 we noted that `R CMD check` made `installed.packages()` return multiple matches of the same package. This might have been a problem before too, but `R CMD check` never complained. # Version 0.62 [2003-12-31] ## New Features * Added `showDescription()`, `getHistory()`, `showHistory()`, `getHowToCite()`, and `showHowToCite()` to the `Package` class. ## Documentation * Added an "about" section in the documentation. ## Bug Fixes * For some Rdoc types the `\keyword{}` statement was placed on the same line as the previous Rd statement. This sometimes generated cluttered Rd index files. # Version 0.61 [2003-12-16] ## New Features * Package: `update()` does now also reload the updated package by default. * Exception: Now the `throw()` method includes the complete stacktrace too when generating a error signal. In other words, the user will automatically see the stacktrace of the error if the error is not caught. Same for `stop()`. * Rdoc: Added the tag `@RdocDocumentation` for general documentation. # Version 0.60 [2003-10-28] ## New Features * Added argument `compress = TRUE` to `Object`'s `save()` to make it more explicit that compression is supported too. Compression is supported by all R systems since R v1.5.0. See `?capabilities`. * Now Rdoc tries to create the 'man/' (`destPath`) directory if missing. ## Bug Fixes * `$<-.Class` was incorrectly returning the static object instead of itself. * The way `$.Object`, `$<-.Object`, `$.Class` and `$<-.Class` were checking if an attribute exists was not done correctly. Now they get the list of names of the attributes and compares to that. * If `Object`'s `save()` was called with a connection it would still interpret it as a filename. # Version 0.59 [2003-09-19] ## New Features * The Rdoc compile does no long list deprecated methods by default. ## Bug Fixes * `getMethods()` was not sensitive to `deprecated = TRUE`. # Version 0.58 [2003-09-03] ## Bug Fixes * `dimension()` would not always be found if `ll()` was called on another package, e.g. `ll(envir = "methods")`. # Version 0.57 [2003-07-18] ## New Features * Added Rdoc comments saying that the constructor function must be able to be called without any arguments! Thanks Nathan Whitehouse at Baylor College of Medicine, Houston for making me aware of the missing documentation. * `Rdoc$compile()` generated an `InternalException` when a class was not found saying "Not a class". Now it throws an `RdocException` and is more specific saying that the class does not exist. Updated the Rdoc comments saying pointing out that the classes and methods have to be loaded before calling `Rdoc$compile()`. Again, thanks Nathan. # Version 0.56 [2003-07-07] ## Bug Fixes * Forgot to escape `%` in `\usage{}` in Rdoc, which lead to unbalanced curly brackets when `R CMD check` ran. # Version 0.55 [2003-05-14] ## Software Quality * Slight improvement in the internal generation of `get` and `set`, which is done by using `substr()<-`. # Version 0.54 [2003-05-03] ## Bug Fixes * Now the Rdoc compiler generates the correct `\synopsis` and `\usage` pairs. Before they were added either or, but that was a mistake by me. `\synopsis` should be *added* whenever the `\usage` statement is not complete. * `update()` of `Package` did not work. Did by mistake add a package argument to `update.packages()` too. That argument is only used in `install.packages()` though. # Version 0.54 [2003-04-29] ## New Features * Added argument `force = FALSE` to `update()` in the `Package` class. # Version 0.53 [2003-04-28] ## New Features * **R.oo**: The Rdoc compiler was further improved and made more flexible. I am aiming to make it possible for the user to define their own simple tags. * All Rd files are now making use of `\link[pkg:name]{label}` for referring to methods not named according to the label. This is for instance the case with all class specific methods. More over, all Rd files for classes has `\keyword{classes}` and the `\usage{}` is used where it works and otherwise `\synopsis{}` is used (as recommended on the R help pages). All this is automatically taken care of by the Rdoc compiler. # Version 0.52 [2003-04-23] ## New Features * Added `getDocPath()`, `update()`, and `unload()` to the `Package` class. With `update()` it is now possible to update a package or its bundle by just typing `update(R.oo)`. * Added `showAndAsk()` to the `Exception`. It will, if **tcltk** is installed, display a dialog box with the error message. If **tcltk** is not installed, the message will be printed on the command line and a prompt requesting the user to press enter will be shown. `showAndAsk()` will give an error if run in a non-interactive mode. ## Documentation * Added almost all missing help pages, i.e. I wrote up *a lot* of Rd files. More help is still though for the Rdoc class, which compiles Rdoc comments in the source files into Rd files. However, if you want to use `Rdoc$compile()` already now, see the source files for plenty of examples and just run `Rdoc$compile()` in the same directory. * Spell correction: "c.f." -> "cf." ## Bug Fixes * `getStaticInstance()` of class `Class` did not recover correctly if static instance was missing. # Version 0.51 [2003-01-17] ## New Features * Added `getUrl()`, `getMaintainer()`, `getAuthor()`, `getTitle()`, `getLicense()`, and `getBundle()`. Made the output from `as.character()` more informative. * Added a caching feature of `$()` to speed up access to members. The first time a member (field, virtual field, static field, method etc) is accessed it is done by looking it up one at the time and taking the first existing one (in a predefined order). The second time the same field is accessed, the name is remembered and `$()` access the right member directly. If this works out, `$<-()` will get a similar cache. # Version 0.50 [2002-12-20] ## New Features * Updated `try()`, which a slight modification to the `base::try()` for improved exception handling, to have its own internal `restart()` function (just like `base::try()`), because `restart()` has been made deprecated from R v1.6.0. This is how the `try()` in the base package does it. # Version 0.49 [2002-12-15] ## New Features * Added the finalizer method `finalize()`, which any subclass can override and that will be called by the garbage collector just before an object is about to be removed from the memory. * Added default function for equals(). * Added argument `overwrite = TRUE` and `conflict = c("error", "warning", "quiet")` to `setMethodS3()`. * Now `extend()` in class `Object` removes duplicated class attributes. * Now it is possible to create methods (also generic) with one (or several) `.` (period) as a prefix of the name. Such a method should be considered private in the same manner as fields with a period are private. * Added argument `path = NULL` to `save()` and `load()` in class `Object`. It will remove the need using `paste()` etc. * For `ll()`, replaced `"getClass"` with `"data.class"` in the `properties` argument. Since `data.class` is almost the same as `mode`, `mode` was also removed. * SPELL CHECK: "...name name..." in one of `setGenericS3()`'s error messages. Thanks Gordon Smyth, WEHI, Melbourne, for the comment. ## Deprecated and Defunct * COMPATIBILITY FIX: Removed default `getClass()`, because it was not would not work with the methods package. * Removed deprecated and obsolete `is.interface()`. ## Bug Fixes * The `Rdoc` class listed too many methods in the "Methods inherited" section. # Version 0.48 [2002-11-23] ## Significant Changes * Renamed `setClassS3()` to `setConstructorS3()`, since this is what it is actually doing. Keeping `setClassS3()` for backward compatibility but made it deprecated. ## New Features * Updated `setGenericS3()` to *always* create generic functions with no arguments except `...` to follow the RCC. * Now `$()` and `$<-()` in class `Object` and `Class` also gets and sets attribute values too, respectively. * Added `getInstanciationTime()`, which returns the time point when the object was created. * Updated `getField()` of class `Class` to call generic method `getField()` and not `getField.Object()`. ## Bug Fixes * `$<-()` of class `Class` did not work for static fields. * `getDetails()` would not add a newline after the class name if the class did not have a superclass, i.e. for root class `Object`. # Version 0.47 [2002-10-23] ## Significant Changes * Package named **Rx.oo** as long as it is a beta package. ## New Features * Decided to declare all Rd files for class methods as `\keyword{internal}` which means that they will not show up in the HTML table of contents. Only classes and stand-alone functions should be there. * The package now contains the public classes `Object`, `Exception`, `RccViolationException`. It also contains the internal classes `Class`, `Package`, and Rdoc. The class `Class` is essential, but `Package` and `Rdoc` are just utility classes containing useful static methods for development purposes etc. * The idea behind the **Rx.oo** package are the same as behind "old" **R.oo**, but internally environments are used for emulating references, whereas in **R.oo** a global so called object space was used. However, API-wise not much have been changed. * FYI: **R.oo** was first published in March 2001 and has undergone several updates, tests and bug fixes. Experience from that project has been brought into this package. # Version 0.46 [2002-10-14] ## New Features * Added trial versions of `extend()` of class `Object` and class `Reference`. Also added trial version of `superMethodS3()` to replace faulty `NextMethod()`. * Added `as.Reference()` to class `Object` and class `Reference` and made the constructor accept `Reference` objects by just returning them again. Before an exception was thrown. * Added argument `showDeprecated = FALSE` to `classinfo()` in class `Class`. This has the effected that when typing a name of a class and pressing enter at the prompt to display class information, deprecated method are *not* shown by default. * Added the class `Class` for dealing with static methods, static fields, accessing methods and fields of classes, generating class information etc. Since the handling of static methods and fields are now dealt by a specific class it means that the access of non-static methods and fields, which is done by the `Object` class, should now be a bit faster due to less overhead. # Version 0.45 [2002-09-23] ## Software Quality * Internal updates: Made `.ObjectSpace.count` an internal variable of the `.ObjectSpace` environment, meaning that it is harder to delete it by mistake. * Added internal function `getPackagePosition()`. ## Bug Fixes * `relibrary(R.oo)` was reloading the `.RObjectSpace` file too, which is not a wanted feature. * `setGenericS3()` would sometimes believe that a non-function object actually was a function and tried to set it as a generic function, which resulted in an error exception. * `createClassS3()` would throw an error exception if there where two *packages loaded* such the name of the first one was the same as the beginning of the name of the second one, e.g. **R.oo** and ***R.oo2**. # Version 0.44 [2002-09-12] ## New Features * Added the functions `Q()` and `Quit()` for quitting with the option to save the `ObjectSpace` also. * Added `isGenericS3()` and `isGenericS4()`. * If trying to use `delete()` to remove a non-existing variable or `Object` now only a warning is given, before an exception was thrown which was quite annoying. `delete()` works as `rm()` plus it also deletes objects in `ObjectSpace`, which means that all calls to `rm()` can be replaced by calls to `delete()`. * Added the static methods `ObjectSpace$save()` and `ObjectSpace$load()` to save and load an image of the `ObjectSpace`. ## Software Quality * Package passes the `R CMD check` with 5 warnings. ## Bug Fixes * `[[` in class `Reference` did not work for numeric indices, e.g. `ref[[5]]`. Strange that I haven't noticed this before. # Version 0.43 [2002-07-09] ## New Features * Now `$` and `[[` also searches for fields in `attributes()`. This is a first step towards making use of `structure()` and friends instead. I've been thinking about this from the very beginning, but newer done it. The plan is to move away from the internal `list()` and accept any R object as the core object. This will also be more consistent with the R.methods/S4 strategy. # Version 0.42 [2002-05-31] ## Software Quality * Removed forgotten debug messages in `setGenericS3()`. # Version 0.41 [2002-05-26] ## New Features * Moved `about()` from **R.base** to this package and removed old `description()`. * Now the package reports its name, version and date if it was successfully loaded. * Minimized the number of warnings when loading packages. * Added argument `dontWarn` to `setGenericS3()`, which by default is set so no warnings are produced for renamed methods in the **base** package. * Copied `packagePaths()` from package **R.base** to package **R.oo**, since it is required in **R.oo** and we do not want **R.oo** to depend on **R.base**. ## Software Quality * Package now passes the `R CMD check` with 5 warnings. # Version 0.40 [2002-05-05] ## New Features * The classes `Throwable` and `Exception` have been transferred to here from the **R.lang** package. With the `trycatch()` they are really useful. * `throw()` and `trycatch()` are now available in both **R.base** and **R.oo**. * Added `createClassS3()` and internal variable `.NewClassesNotCreated`. * `$.Object()` and `$.Reference()` now returns NULL if a field/method etc is not found! Before it an error was thrown. ## Bug Fixes * `trycatch()` didn't work methods created by `setMethodS3()`. This was due to I did (internally): `object <- try(eval(substitute(object, envir=envir)))` instead of: `object <- try(eval(substitute(object), envir=envir))` Hmm, a tricky typo to find since it worked elsewhere. * Tiny bug fix in message of `throw()` clause in `$()`. # Version 0.39 [2002-04-21] ## New Features * Added a trial version of `[.Reference`. Currently, it does not support the `get()` idea as described below. Maybe a `[<-.Reference` will be added later. * Added trial version of a new feature for `Object`/`Reference` fields. Now, if a field does not exist and there is no method with the same name, then, if a method named `get()` exists, the value of `get()` is returned. This way one can have fields that are generated "on the fly" to save memory etc. This new feature required that `[[.Object` was modified (actually created). Example: For an object `obj` one can get its class by either the classical `getClass(obj)` or by the new feature `obj$Class`. If this new feature are successful, I will also look at implementing a corresponding `set()` support. ## Bug Fixes * `setGenericS3()` gave an error if one tried to set a generic function with the same name as an R object that was *not* a function. A simple add of argument `mode = "function"` to the `exists()` check fixed this. # Version 0.38 [2002-04-02] ## Bug Fixes * `clone()` in class `Reference` did not work properly; it gave the wrong internal reference names, which in turn would generate errors such as 'Error in get(x, envir, mode, inherits) : variable "Reference.METHODS" was not found' when one tried `object$foo()` instead of `foo(object)`. Now it works again. # Version 0.37 [2002-03-30] ## New Features * IMPROVEMENT: Since `library(methods)` might be loaded after `library(R.oo)` the function `extends()` breaks down. Worked this out a little bit by detaching and reloading **R.oo** in function `createClass()` if it is detected that extends() has changed. * IMPROVEMENT: Forces `extends <- function(...) UseMethod("extends")`. The reason for doing this is that if we have anything but `...` that argument might be matched by an attribute. Not good! # Version 0.36 [2002-03-06] ## New Features * Added `names()` to the class `Reference`. ## Bug Fixes * When running the OO garbage collector, calling a `finalize()` that used the method `super()` failed with an exception. Internally, the class attributes of the freeable references were lost. * `extends()` and `implements()` in `Rdoc` sometime gave errors. # Version 0.35 [2002-03-03] ## New Features * Added the methods `attach()` and `detach()` which works both on `Object`'s and `Reference`'s. # Version 0.34 [2002-02-27] ## New Features * Renamed the (still) internal class `.Reference` to `Reference`. * Added the `setInterfaceS3()` method. Makes it easier to define interfaces. * Static method `buildClass()` in class `Rdoc` now also creates a list of methods and saves the result in the file `.methods.Rdoc`, which can be included in the Rdoc comments by `@include ".methods.Rdoc"`. Hopefully, this will mean that the list of methods in the help files will be more up to date. ## Documentation * Update the examples in the help files to make use of the new `setClassS3()`, `setInterfaceS3()`, and `setMethodS3()`. ## Deprecated and Defunct * Declared more internal methods as "private". ## Bug Fixes * Internal `scanForMethods()` did not make a difference of functions and non-functions, since it basically only looked at the name. For instance would `CONST.Foo <- 256` be considered a method in previous versions. This was not a big deal, but it is correct now. # Version 0.33 [2002-02-26] ## Bug Fixes * `buildClass()` in class `Rdoc` did not work due to the new package **methods**. Corrected with one line of code. # Version 0.32 [2002-01-29] ## New Features * Added the arguments `trial`, `deprecated`, `static`, `protection`, and `abstract` to `setMethodS3()` (and to some extend also to `setClassS3()`). ## Software Quality * Started to make more use of `setClassS3()` and `setMethodS3()` internally. # Version 0.31 [2002-01-21] ## New Features * Added `createGeneric()` to make life easier for class developers. # Version 0.30 [2002-01-18] ## New Features * Added the (optional) argument `path = NULL` to `loadObject()`. # Version 0.29 [2002-01-13] ## New Features * When `obj$foo` is evaluated first the field `foo` is searched for and secondly the class method `foo()` is searched for. Previously, methods had higher priority than fields. ## Bug Fixes * Bug fix in `gco()`. R v1.4.0 made it crash. # Version 0.28 [2002-01-09] ## New Features * Made **R.oo** compatible with new R v1.4.0 and the new package **methods**. # Version 0.27 [2002-01-02] ## New Features * Internally renamed the methods, e.g. `new()`, `getClass()`, and `extends()`, that conflicted with methods defined in the new R package **methods**. Hopefully, these changes makes **methods** run when **R.classes** is loaded. * Starting to separate `Object` methods and `.Reference` methods. Eventually maybe **R.oo** `Object`'s could work very similar to **methods** object where `.Reference` is just an add-on to make the `Object`'s referensable. # Version 0.26 [2001-12-29] ## New Features * First steps to make **R.classes** work *together* with the new **methods** package. These fixes made **R.classes** work when **methods** was loaded, but **methods** didn't work when **R.classes** was loaded. * This version was never released to the public. # Version 0.25 [2001-08-09] ## New Features * Added `super()`, which provides a simple way to access methods in the super class. # Version 0.24 [2001-08-07] ## New Features * Added support for `this[[field]]` and `this[[field]] <- value` when this is a reference. Another step away from `get-` and `putObject()`. * Introduced the `modifers()` function instead of old `attr(...)`. ## Documentation * Updated many of the out-of-date examples in the help pages. ## Performance * Improved the speed of the garbage collector and it can now also run until no more objects are deleted. # Version 0.23 [2001-08-04] ## Performance * Major break-through in memory and speed efficiency. A lot of expressions are now evaluated directly in the object space environment, which means that no copying between the object space and the current environment is needed. This improvement makes the need for `getObject()` and `setObject()` much less of interest and they will probably be made obsolete or private, which is another step towards a more user friendly oo core. # Version 0.22 [2001-08-03] ## New Features * Improved the error and warning messages for false references. * `delete()` can now remove any number of any kind of objects, i.e. it is now more consistent to `rm()`. * Created this HISTORY file. Everything below is recreated from from this date and is therefore not complete. # Version 0.21 [2001-07-29] * ... # Version 0.20 [2001-07-27] * ... # Version 0.19 [2001-07-06] ## Significant Changes * Renamed the package to **R.oo** (from **com.braju.oo**). # Version 0.15 [2001-05-06] * ... # Version 0.14 [2001-04-30] ## Bug Fixes * Bug fixes in garbage collection algorithm. # Version 0.13 [2001-04-15] ## New Features * Now it is possible to add new fields to an object. Even though this is not true oo-style, it certainly is helpful. Also, fields (not methods) can be assign new values using regular style `foo$value <- bar`, where `foo` is either the object itself or more common the reference to the object. # Version 0.12 [2001-04-13] ## Significant Changes * Now objects "physically" contains only the fields. The methods are looked up in an internal static class. Also, by writing the name of a class, information about the class is listed. # Version 0.11 [2001-04-11] * ... # Version 0.10 [2001-04-04] ## New Features * Support for static classes. Static methods in static classes can be called by `Foo$myStaticMethod()`. For class developers: a static class is created by `new(Foo(), static = TRUE)` which will not return a reference. A static class is only living on object space. # Version 0.9 [2001-04-02] ## New Features * Support for static methods. A static method is declared as `myStatic = METHOD+STATIC` and implemented as `myStatic.myClass <- function(arg1, arg2, ...)`. Note that there is no `this` argument to static classes. # Version 0.8 [2001-04-01] ## Significant Changes * Totally changed the declaration of methods in a class. Previously, one wrote `myFcn = function() NULL` and now one writes `myFcn = METHOD` where `METHOD` is predefined constant. This allows fields in a class to also contain functions, i.e. `myField = sqrt(x)`, which was not possible in previous versions. # Version 0.5 [2001-03-27] ## Significant Changes * This is the first public release. # Version 0.2 [2001-03-16] * ... # Version 0.1 [2001-03-12] * The very first version. # Version 0.0 [2001-03-10] * The very first attempt to create an object-oriented core for R. At this moment I was a beginner in R. R.oo/inst/0000755000176200001440000000000014711166766012063 5ustar liggesusersR.oo/inst/CITATION0000644000176200001440000000230114554121077013203 0ustar liggesusersutils::bibentry( header = "Please cite R.oo/R.methodsS3 as:", # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # BibTeX entry: # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - bibtype = "InProceedings", author = "Henrik Bengtsson", title = "The {R.oo} package - Object-Oriented Programming with References Using Standard {R} Code", booktitle = "Proceedings of the 3rd International Workshop on Distributed Statistical Computing (DSC 2003)", year = "2003", editor = "Kurt Hornik and Friedrich Leisch and Achim Zeileis", address = "Vienna, Austria", month = "March", issn = "1609-395X", url = "https://www.r-project.org/conferences/DSC-2003/Proceedings/Bengtsson.pdf", howpublished = "https://www.r-project.org/conferences/DSC-2003/Proceedings/", textVersion = paste(sep="", "Bengtsson, H. ", "The R.oo package - Object-Oriented Programming with References Using Standard R Code, ", "Proceedings of the 3rd International Workshop on Distributed Statistical Computing (DSC 2003), ", "ISSN 1609-395X, ", "Hornik, K.; Leisch, F. & Zeileis, A. (ed.), ", "2003" ) ) R.oo/inst/misc/0000755000176200001440000000000014445525725013014 5ustar liggesusersR.oo/inst/misc/ASCII.R0000644000176200001440000001432614445525725013775 0ustar liggesusers#########################################################################/** # @RdocObject ASCII # # @alias ASCII.BEL # @alias ASCII.BS # @alias ASCII.HT # @alias ASCII.LF # @alias ASCII.FF # @alias ASCII.CR # @alias ASCII.SO # @alias ASCII.SI # @alias ASCII.DC1 # @alias ASCII.DC3 # @alias ASCII.ESC # # @title "8-bit ASCII table" # # \description{ # ASCII is the 8-bit ASCII table with ASCII characters from 0-255. # } # # \examples{ # ch <- ASCII[65+1]; # ch == "A" # } # # @author # # \seealso{ # @see charToInt # @see intToChar # } # # @keyword character # # @keyword internal #*/######################################################################### ASCII <- c( "\000","\001","\002","\003","\004","\005","\006","\007", # 000-007 "\010","\011","\012","\013","\014","\015","\016","\017", # 010-017 "\020","\021","\022","\023","\024","\025","\026","\027", # 020-027 "\030","\031","\032","\033","\034","\035","\036","\037", # 030-037 "\040","\041","\042","\043","\044","\045","\046","\047", # 040-047 "\050","\051","\052","\053","\054","\055","\056","\057", # 050-057 "\060","\061","\062","\063","\064","\065","\066","\067", # 060-067 "\070","\071","\072","\073","\074","\075","\076","\077", # 070-077 "\100","\101","\102","\103","\104","\105","\106","\107", # 100-107 "\110","\111","\112","\113","\114","\115","\116","\117", # 110-117 "\120","\121","\122","\123","\124","\125","\126","\127", # 120-127 "\130","\131","\132","\133","\134","\135","\136","\137", # 130-137 "\140","\141","\142","\143","\144","\145","\146","\147", # 140-147 "\150","\151","\152","\153","\154","\155","\156","\157", # 150-157 "\160","\161","\162","\163","\164","\165","\166","\167", # 160-167 "\170","\171","\172","\173","\174","\175","\176","\177", # 170-177 "\200","\201","\202","\203","\204","\205","\206","\207", # 200-207 "\210","\211","\212","\213","\214","\215","\216","\217", # 210-217 "\220","\221","\222","\223","\224","\225","\226","\227", # 220-227 "\230","\231","\232","\233","\234","\235","\236","\237", # 230-237 "\240","\241","\242","\243","\244","\245","\246","\247", # 240-247 "\250","\251","\252","\253","\254","\255","\256","\257", # 250-257 "\260","\261","\262","\263","\264","\265","\266","\267", # 260-267 "\270","\271","\272","\273","\274","\275","\276","\277", # 270-277 "\300","\301","\302","\303","\304","\305","\306","\307", # 300-307 "\310","\311","\312","\313","\314","\315","\316","\317", # 310-317 "\320","\321","\322","\323","\324","\325","\326","\327", # 320-327 "\330","\331","\332","\333","\334","\335","\336","\337", # 330-337 "\340","\341","\342","\343","\344","\345","\346","\347", # 340-347 "\350","\351","\352","\353","\354","\355","\356","\357", # 350-357 "\360","\361","\362","\363","\364","\365","\366","\367", # 360-367 "\370","\371","\372","\373","\374","\375","\376","\377" # 370-377 ); # Alternatively one can do like this. Idea by Peter Dalgaard, # Dept. of Biostatistics, University of Copenhagen, Denmark. # ASCII <- c("\000", sapply(1:255, function(i) parse(text=paste("\"\\", # structure(i,class="octmode"), "\"", sep=""))[[1]]) ); # Some special ASCII characters. ASCII.BEL <- "\007"; ASCII.BS <- "\010"; ASCII.HT <- "\011"; ASCII.LF <- "\012"; ASCII.FF <- "\014"; ASCII.CR <- "\015"; ASCII.SO <- "\016"; ASCII.SI <- "\017"; ASCII.DC1 <- "\021"; ASCII.DC3 <- "\023"; ASCII.ESC <- "\033"; #########################################################################/** # @RdocDefault charToInt # # @title "Converts a vector of integers into a vector of ASCII characters" # # \description{ # Converts a @vector of ASCII @characters to a equal length vector of ASCII # @integers. # } # # @synopsis # # \arguments{ # \item{ch}{A @character @vector.} # \item{...}{Not used.} # } # # \value{ # Returns an ASCII @character @vector. # } # # @author # # \examples{ # i <- charToInt(unlist(strsplit("Hello world!", split=NULL))) # # Gives: 72 101 108 108 111 32 119 111 114 108 100 33 # ch <- intToChar(c(72,101,108,108,111,32,119,111,114,108,100,33)) # # Gives: "H" "e" "l" "l" "o" " " "w" "o" "r" "l" "d" "!" # } # # \seealso{ # @see intToChar # } # # @keyword character #*/######################################################################### setMethodS3("charToInt", "default", function(ch, ...) { match(ch, ASCII) - 1; }) #########################################################################/** # @RdocDefault intToChar # # @title "Converts a vector of ASCII characters into a vector of integers" # # \description{ # Converts a vector of ASCII integers to a equal length vector of ASCII # characters. To make sure that all values in the input vector are in # the range [0,255], the input vector is taken modulo 256. # } # # @synopsis # # \arguments{ # \item{i}{An @integer @vector.} # \item{...}{Not used.} # } # # \value{ # Returns a ASCII @integer @vector. # } # # @author # # \examples{ # i <- charToInt(unlist(strsplit("Hello world!", split=NULL))) # # Gives: 72 101 108 108 111 32 119 111 114 108 100 33 # ch <- intToChar(c(72,101,108,108,111,32,119,111,114,108,100,33)) # # Gives: "H" "e" "l" "l" "o" " " "w" "o" "r" "l" "d" "!" # } # # \seealso{ # @see charToInt # } # # @keyword character #*/######################################################################### setMethodS3("intToChar", "default", function(i, ...) { ASCII[i %% 256 + 1]; }) ############################################################################ # HISTORY: # 2005-02-15 # o Added arguments '...' in order to match any generic functions. # 2002-10-20 # o Added keywords to the Rdoc comments. # 2002-05-26 # * Changed the \keyword{}'s to contain valid keyword as in KEYWORDS.db. # 2002-02-04 # * Added alternative idea of creating the ASCII table. # 2002-01-29 # * Rewritten to make use of setMethodS3. # 2001-08-06 # * Moved ASCII back to R.oo from R.base. It is needed by the String class. # By moving it back R.oo is stand-alone again. # 2001-07-28 # * Also defined up the ASCII.BEL constants etc. # * Moved the ASCII stuff from R.oo to R.base. # 2001-07-13 # * Made all methods using UseMethod. # 2001-06-07 # * Added [R] documents to ASCII, charToInt and intToChar. # 2001-04-02 # * Created! ############################################################################ R.oo/inst/misc/Exception.R0000644000176200001440000002357214445525725015106 0ustar liggesusers###########################################################################/** # @RdocClass Exception # # \title{The Exception class to be thrown and caught} # # \description{ # @classhierarchy # # Creates an Exception that can be thrown and caught. The \code{Exception} # class is the root class of all other \code{Exception} classes. # } # # @synopsis # # \arguments{ # \item{...}{One or several strings, which will be concatenated and contain # informative message about the exception.} # \item{sep}{The string to used for concatenating several strings.} # \item{collapse}{The string to used collapse vectors together.} # } # # \section{Fields and Methods}{ # @allmethods # } # # @examples "Exception.Rex" # # @author # # \seealso{ # See also @see "base::tryCatch" (and @see "base::try"). # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setConstructorS3("Exception", function(..., sep="", collapse=", ") { calls <- sys.calls(); last.dump <- sys.frames(); names(last.dump) <- limitedLabels(calls); # last.dump <- last.dump[-length(last.dump)]; attr(last.dump, "error.message") <- geterrmessage(); class(last.dump) <- "dump.frames"; stackTrace <- NULL; if (length(last.dump) > 0) { calls <- names(last.dump); matchStr <- "Exception("; offset <- which(substr(calls, 1, nchar(matchStr)) == matchStr); if (length(offset) == 0 || offset == 1) stackTrace <- list(""=NA) else stackTrace <- last.dump[1:(offset-1)]; } # The new class is Exception, but for convenience it should also # derive from 'try-error', which is used by try() etc. extend(Object(), c("Exception", "simpleError", "error", "condition", "try-error"), .msg = paste(..., sep=sep, collapse=collapse), .when = Sys.time(), .stackTrace = stackTrace ) }) ###########################################################################/** # @RdocMethod as.character # # \title{Gets a character string representing of the Exception} # # @synopsis # # \description{ # @get "title". # By default the format is: "[{POSIX date string}] {class name}: {msg}". # } # # \value{ # Returns a @character string. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("as.character", "Exception", function(this) { paste("[", getWhen(this), "] ", class(this)[1], ": ", getMessage(this), sep=""); }) ###########################################################################/** # @RdocMethod print # # \title{Prints the Exception} # # @synopsis # # \description{ # @get "title". By default the \code{as.character()} representation plus # the stack trace is printed. # } # # \value{Returns nothing.} # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seemethod "as.character". # @seemethod "getStackTrace". # @seemethod "printStackTrace". # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("print", "Exception", function(this) { cat(getStackTraceString(this)); }) ###########################################################################/** # @RdocMethod getWhen # # \title{Gets the time when the Exception was created} # # @synopsis # # \description{ # Gets the time, as a POSIX object, when the Exception was created. # } # # \value{ # Returns a POSIX time object. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getWhen", "Exception", function(this) { this$.when; }) ###########################################################################/** # @RdocMethod getMessage # # @title "Gets the message of the Exception" # # @synopsis # # \description{ # @get "title". # } # # \value{ # Returns a @character string. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getMessage", "Exception", function(this) { this$.msg; }) ###########################################################################/** # @RdocMethod throw # # \title{Throws an Exception that can be caught} # # @synopsis # # \description{ # Throws an Exception that can be caught by \code{tryCatch()}. # } # # \value{ # Returns nothing. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # @author # # \seealso{ # @seeclass # See also @see "base::tryCatch". # } # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("throw", "Exception", function(this) { Exception$.lastException <- this; message <- getStackTraceString(this); # message <- as.character(this); if (R.Version()$major <= 1 && R.Version()$minor < 8.0) { .Internal(stop(as.logical(FALSE), message)); } else { signalCondition(this); .Internal(.dfltStop(paste("\n", getStackTraceString(this), sep=""), getCall(this))); } # if (R.Version()$major <= 1 && R.Version()$minor < 8.0) }) ###########################################################################/** # @RdocMethod getLastException # # \title{Static method to get the last Exception thrown} # # @usage # # \description{ # Static method to get the last Exception instanciated. # } # # \value{ # Returns an @see "Exception" object. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # \seealso{ # @seeclass # See also @see "base::tryCatch". # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getLastException", "Exception", function(this) { Exception$.lastException; }, static=TRUE); ###########################################################################/** # @RdocMethod getStackTrace # @aliasmethod getCall # # \title{Gets the stack trace saved when the exception was created} # # @synopsis # # \description{ # @get "title". # } # # \value{ # Returns a @list containing the stack trace. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # \seealso{ # @seemethod "printStackTrace". # @see "base::dump.frames". # @see "base::tryCatch". # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getStackTrace", "Exception", function(this) { this$.stackTrace; }) setMethodS3("getCall", "Exception", function(this) { getStackTrace(this); }) ###########################################################################/** # @RdocMethod getStackTraceString # # \title{Gets the stack trace as a string} # # @synopsis # # \description{ # @get "title". # } # # \value{ # Returns a @character string. # } # # \seealso{ # @seemethod "getStackTrace". # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("getStackTraceString", "Exception", function(this) { calls <- names(this$.stackTrace); len <- length(calls); width <- floor(log(len, base=10))+1; s <- paste(this, "\n", sep=""); for (k in len:1) s <- paste(sep="", s, " at ", calls[k], "\n"); s; }, private=TRUE) ###########################################################################/** # @RdocMethod printStackTrace # # \title{Prints the stack trace saved when the exception was created} # # @synopsis # # \description{ # @get "title". # } # # \value{ # Returns nothing. # } # # \examples{\dontrun{For a complete example see help(Exception).}} # # \seealso{ # @seemethod "getStackTrace". # @see "base::tryCatch". # @seeclass # } # # @author # # \keyword{programming} # \keyword{methods} # \keyword{error} #*/########################################################################### setMethodS3("printStackTrace", "Exception", function(this) { cat(getStackTraceString(this)); }) ############################################################################ # HISTORY: # 2005-02-10 # o Moved showAndWait() from Exception to simpleError. # 2004-10-18 # o Added more Rdoc comments. # 2004-03-02 # o The Exception class now inherits from the simpleError, error and # condition classes. # o The throw() method of Exception does now make use of the new (R v1.8.0) # signalCondition() method. # 2003-12-16 # o Now throw() includes the complete stacktrace when generating an internal # error signal. # 2003-04-13 # o Wrote Rdoc comments that were missing and updated some others. # 2003-03-23 # o Added showAndAsk(), which will, if tcltk is installed, display a dialog # box with the error message. If tcltk is not installed, The message will # be printed on the command line and a prompt requesting the user to press # enter will be shown. showAndAsk() will give an error if run in a non- # interactive mode. # 2003-01-19 # o Added stacktrace information to *each* Exception object. This is created # when the object is created. # 2003-01-18 # o Replaced all occurences of getClass() with data.class(). Will change # the use of getClass() in the future to return a Class object. # 2002-10-17 # o Made getLastException() a static method of Exception. # o Created from previous ideas in R.oo. ############################################################################ R.oo/inst/doc/0000755000176200001440000000000014711166766012630 5ustar liggesusersR.oo/inst/doc/Bengtsson.pdf0000644000176200001440000065703214711166766015302 0ustar liggesusers%PDF-1.5 %âãÏÓ 164 0 obj<> endobj 180 0 obj<<7cf91b959c184f4bba70f1c6d9bfafb6>]/Length 91/Filter/FlateDecode/DecodeParms<>/W[1 2 1]/Type/XRef/Prev 220285/Info 163 0 R/Index[164 126]>>stream xÚbbd``b`Y$‰¿!@‚ù:ˆ«$8¶ A aö HpOû6 Á¶HðßJ01–W LŒ ¦@ã@\Ï…3F T ÀN endstream endobj 167 0 obj<>stream xÚb```¢? ,@2A€X…£,.Àð9\@PàßG®<Ò’b|3xuyx¸bx~ðžãìNá}ÉÏÀ yåÙFn瘪ž–@} "fÑ>§M´ #^ØæìºÆQ8Eîµo¢FÛ5+ÁÚYk k²ßÌát¹y&ÂKmÿf1…)g7gl˜zF$•ýf.§«›Å¥5ò©StŠ}´¼ø7‡ ‹øÌ^ðËËtÓ¡K]=Fo„:J²yÓZV¬8ÔZ–0;µeQ[£(ÐfÕ4F•°4 Å`š–ÀÀ h"˜T@¢Ê@¬¤S RŒ‚J¦¡@1FãÐ0fÓ !T.¨ÄŒB Ę10ÉLÒÜ@,`Tdàc`ÈôÜcrQÝÿcªë$³wü…©Ak6û”ÌÐôø®Ó¶•G[6gD&É:@B3ïƒ ­ ¬Î@Ú‰ÙSÂgš`c‡ou endstream endobj 165 0 obj<>/Type/Catalog/PageMode/UseOutlines/OpenAction 166 0 R/Names 181 0 R/ViewerPreferences<<>>/Metadata 67 0 R/PTEX.Fullbanner(This is pdfTeX, Version 3.14159-1.10b)>> endobj 166 0 obj<> endobj 168 0 obj<>/ProcSet[/PDF/Text]>>>> endobj 169 0 obj<>stream xÚìYÛrÛ8ý‚ý<îÔV¶ â^5•*_â™LìرÛ›lh ’8¡H…¤&N¾~ºAêBZKžlÕní” £‰K³Ñ8Ý ¹å,bÜÆXðW0'9Ö’qãZi°G# ‹ §1–‰HBãlì*Â1Ž3¡CKŒ‚Á1N0a#Ôá$“Q„Ób’+£™ŒQw†I¥ð¥Î2i5 ŽI‡Í1*U\s8 …˜©Ø‘ ˜2–º$ÓÜ ˜Øãû´ ƒ Øõãp쫺¢Åáª/Ÿ?Ç–·_ç^äÃb”æ8NÇc_ú|è«ü”Ìf ÎÉêÞN=þ=Mf·£nR¸HaN°ûݼJ³"‡‹)6V)œÏü$ñÆ)Œ3°ÂzTÔ™¯°¿~…I™üæ!.jäD·¥Ç–Y2¤‡’ìúQše L|9KòÑmVAâ¡Àß*Kª)¼€sümªÅ|^¢jðwÃ,™ÁçEQ{œS¦“i ùbvëË*äPÕ¾ÌHýÜ—CŸ×ÌPªðÍœfÂI3OVS¼††ÃÃâîóرg±Â\ÉŒ’Cßëdæáìêúøý›Þ¼}É#8É’IÅ$ j?»b<2p”ÌÀcÚj¸ie)%T´ÃL;I™"ÈÏ0gÁË:ÉÒáA>Acžq GÓ¤øúïä¶uìl ˜ýBdÑ€ÿ`…pÂ÷݈ë%ªßï Ç%xþüƒF?F{ÿXä…ˆILñT¨E [H.C­ú%Ú™F®uI“dcìѸ»†”±…¸ÂÄAÂ$<»)BsÄŒ5a²V2ÔpŒ—VŸ‰\Çö`‡ˆ›ÒÊ’˜¦}&»Â*ð9FrRå«ÕÐ8ä‰/H”:nÚ 2ŸÒ´>ÙŒü¸d‚èŠj験ʇž{ÀM˪&¤!Ê1¶W²€Áâ¶&…¤•µ„Ö2×EXœô^§£zZ2ÿæºQ:Ë¿˜î/¦ûß`º¨ÇtJÓ቙ ‡¹0Ú`º—g¯®ŽNBÂÀ Ñç9÷'y.ê°ù«‹þýq¿FoƒÝÓµKÌ>²>Ä6Ø+Vè6'ì8lý#Œb‚SöTZìTzlˆì`‘A,ê°™ Øc1[‹lÀþÑ&°¶X©-¨ÕâÞÒ r‚Õêû”4a]²BïÈJd =‹å3Þ²H&„qm?Ú€lˆûÏä²G’µTS +¯t—¯zð{*[™.[Ù[m…êž›ã_„wDc7ƒâøÕÅÅå;´j0@»îÿ„Þ „ü*,”Ý7,. z&ÚÙa÷L[¹Ìn¸ å?ö˜‹: G©{Óý4b[ÑÍ»›FywzpöÑõÝÅÍ÷Ë" Ù a­½hƒú |%gŠ¸{F³Nl‰ë=¢Z!z4ž!Î µÜ¦S¹8Ô(µ ‘ÒÄ4ace×MîzsµÃˆ® àmq÷çä¶-6½-Ë;Q$to‹¯7ƒãC4겿ÃFv6X¬7Xð½i"붓Ò=ÐEæ,ç«´½wâÿr>Õ ÿS?b1îŸ@DÄv)…÷*Í1á­FÆm>ïÚàB»q ’éöBVÒèfÔ6ø†—âÙN Z´†Ðs0”dTD²mÇ-ûºt‰Ts‰¡z%ÕÔ¸+ˆ;xY'v¾‰áGÓ”îbØlðíaX‹%†ñÆgt7M]¿¹>Ù³b„íI}ÿ,’ºÖz÷xß4ë‰ÝmºŠ>wnq•èQ+Ä›­ÓnÓW§Go.ɨË{ ¨Ý÷øö4ݽõ®]]¶þów¬ö+ÊýûÓúöÔ¿;=rsú÷ßÚ»ÓÓ/G„5…÷uEß°X!veµhù·™c( úo]ÈP¶iÁ>ªiÜ®%nç6ZÚŒ§èû‰e&¦ïqÑK½Âa‚ ÍÛŒI§JÇM3çëð#šõ…ùªÑ‡!nWÑÊÌxõÒ`}N¢#m[‹H¯ÚÃé9n &GG¶ýÔ.è_tF·,ÛȪ©ÝQ´s°wâêÄøȉ—þwщv±-Úe?1¶ÁîèÀ«6cýzp|öú2$ {Ánì÷NŒrçÄسëI™‘þ™Óñ•n|õ»áš½" endstream endobj 170 0 obj<>stream xÚí·e\[߶°‹»»Ü!Á¡Ðwww·àîîîînÅ¥Hq+nE‹k¡8”›ÿÞçìö=ç㽟îï&_òŒ5Ö˜ÏsΕ„ŽJYMÄÜÉÔBÒÉÑ Äˆ)ˆjƒ8 v ˜‹…‰›“£¸‰›… $ ˆ¸[8¯ · 7 @Ì ìíbceí`cú'‰ â`ábcfâP0q³¶p€Ô03±¨9™ÙX¸y³DìíªÿÜá Pµpµpñ°0gGæ6fnS +GŽŒd-|ÿ›»ƒÿû’‡…‹+D À‘d@Íí½æ–(ŠN±, &ÿoHýÏâ’îööŠ&ÿ”ÿW—þ×u{ïÿÊpr»»Y¸œÌ-\ÿgª–Å¿åDìÿ×02n&ö6f"ŽVöà¿C6®’6^æÊ6nfÖK{W‹Å-Íÿ§¤mÿàQÓ“dù¯õü×EeG7uoðÊþ“ý/ýaHw\l¼z@v I„¼ÿû“ÁÿLÂÑÌÉÜƲ!xx&..&Þ(!€/`ãhná°ð‚s°;:¹An@Zâ°trAùg9!Z–6ÿÄþÜü‹¹yÖÞ`k Ç?!^²ŠNæBü §?‡“£Å˜àpóüsak‹¿2þñprwùàúGÌ㯠ˆš+¤)ÿaˆš«…Ç_fpü{Iÿáp8Úü% ¹IäAnýCd±?™“ø‚LHâ?ÄÑ—úCué?ñ–ùCäÿ¤¦â‚ÔTúñCZ¤ü‡ 5Uÿ¤¦Ú‚4BýAf¤ñ‚1“?ÏôAÆ3û³Ò@È€æ!dNá?ëñB ¬þBˆ‚õ_qøk!“¶ý !Nv!DÊþ/„X9üAÄÊñ/„X9ý…+ð_Ñpù ÿÙ!DÃí/„h¸ÿ… ¿¢áù!OW¯¿¢áýBº9ö&®ÿîÁÿ>ý¢¢N^¾l-ÌÆ Ùê —€èÿ'j8Ú8»[ȈCNÈÙaÿDÍÜ]\,Ýþõ¸… ñßliyYXxY˜¡¬¯8™½ ³Íl¨(«g†µêHRlXüˆº– m_1)ç̼ýAû©6ãþˆÒó™Ô5¦×OeFò"Ø9)kùåÈÃø(ǧ‹Tû*GÁûL}z†ÙÓ¾tsέ´°=U¦S6’9zV¬Ì(®þ q“ jPÏ£u07Œ—O[2Ç^#2ü=•*V–suwä–'VZ ÜÖlh€m$R'ËÆO§^wœ§R¤¢Ô#XóMã{¹ÞèûºOIÓ÷8ÍAU1ûîE Ù: õϦz›”y =û«¸Ü%†kV7ýì†>𗆥‚2ÝG%$bî©hY>t›˜îeTPÍIô³[%½ÖƺŠwÓ¥+dÖrR¯mQ>o¾ï¶.b$t÷²Ðh@ôDgŒ¹L´¯²\ráë‰+á¿ë[³)\“š1Žm%Ë£,°¨•i—#Ød¶ÛÖΧÒ×ECGPx…­Ë’œÅ5±.…ö‘%°cìZj$R±!OÖÑ8Y©äÕù+_Þà»öë:™ ^ÒÇ]ÊF †Ûýiot`˜•Ü[z&§·°œ¤ú´ÚZ1ÑßØ@–¥#«ï[j›fEÑ@Z‘ÂEò—t•ÝSàŒ|ò>å içG¢jm׶rvE—ý­³±ð ÷úä$©€9c…ÙÃÖ¥öqÙHipg7<¹«Ô‹ùÊ[F:&)æúü™­rôùð츥)–¯}ÐÄ„>ÓµŠ ]¥l{½ ßv ÃÄk´ÓRÍä­üøWÂüõ+“q1F•î^”z9aŠx¤ó_„b^ghsY °¨}?|À‹.¤mŠ¼mâ©@§y÷Ñ®f1xá_™ë%w¥g5â ¿ú”‰ÿ¶Û'H)ç¬}tð~Yz†üS'!\‹0aÓâyð 5©(ϘŒ«ÅœŽCÕŠ´ã™9)éµoߘ^ÂDû{©ð$3ÌoW°yE´<±\1\¨!ëµ×Ó7ô^H!³·­ ½ä'ÂCjî©+ú™Û·Õ Ûžñ÷*M\¢­-ØȾo>â`6&Ä‘aºÝŠR„S+âtQ'€ãöJBeRÞÍuAaƒ7ÒGqËËmWàn°=Ÿ£9/¿¿Ÿž›|cN ¢Ó‘‚“ˆN-|jb—2Qp¸îÜo£›XFи[ãUÉó×VÂ{/ 3  Q2a³D艰³Åñ3adŸ¢¿â,“S+óAɤÂ2`y‘Ô~Aª'¢³„]Ñú¤M+ýHý™{Ic¨>½\~©}îD: žÓÖf1õƒÔ³ ñålVþ'ÂJn:Æ|Ò˜î’éغ´Q]²l6 EˆI¯„’X¨?˧UþÔnn|ú<Šx»´eà©°Ý•ª«¯:*%õµîå« ùz!b!NXÓ>ãχ’ÛCñÇÇ¥pz¦ØŠ<3S!ygòú§™(\¾Àà‡Új»óßBé¨^†pEO]¥ªM•²’Ëç„(áWX˜‰Ö{ÚjbWGíÔ4ó®¯] ÑW_ÓrÇó. Å-ûÉÄ<Íki÷”™ÍÎæh´Hl]˜6 ÊÀGù¡Áµ8ΩBë{ÔôK®_¶´{6A©é¶ÇŽ‚ÇXb ·šÊ´"àgÔíè|´ºòIû/¢…ÊýÉ~»ÉþŸäœ÷–àÑrõ·XOcÁIM¥¾„·fÂǤšWÆ´³­Sï°Ëey¸0IÕg}½É·¿zàf¨á²¤¢ps;a„29[žøÇ‹+ƒN3»†è&Hrëñî]«h»ØA ´÷A ”ºÝ¬Ô¾R­S8"]ÆÆ°¨¶ bSQŒJ§¸2¨h°æQüyX´%ß”ÆWñ&¼¸Gúj@(ŽN¦u€Ä)8õñѬø3;Âl ü¬)„Ë JoÓü²a{cwbøë^z–·'±§èŸ4›1ÌÓm*„)Š·,ˆ÷‘ÙQ­oùÕ‚d$ªžL5Ï?ã–ñ±Lª·ð«­äÆ´œÁц÷ªî×jRHEõÅ xhqGfl}¨öÚÝzF]‡Š!˜Gxv'Pßðv†"i|²Ã/…(ÃŽÕ¿ycb’ï" tòµWŽÝîÄè9îQA‰Zm×/­ê0óiqï-®DvûÀ%Ž— ­'ÇJtŽ´.3mƒÑžëÔòÓ [¿Æ·¹OzÚæ) ìÏä½üÚhCi—{Ç;:ZO|Ö ¦ÎU£à^so<²í›Ç±‰RÄ'è&^æÌ%sF -NiC±~C7òlÂ9‹ÈFéK‰\y•«m6.\+›‘¯|i1í1\ÖGËz@‡nñ_R/ûD÷…sÍ.Ò¡"&{%3sЂ–5eêÃcƪ0|\Û£X¿(¨LP \Mãäٖμµ—÷ºÉ96= îÌOÝ‘2¢ð|'±ïn˜æ6Ε·sYðËùÙÙ‡ä†Ç¨}°Ø,«pe|´8fÜï¿&„>¬y¦ÿEþ;ëa†P¶ þgZ›ÏË’c…š$:òË(çé_‚PmLW[A?E­Í7‰Æ8ïŠÊñøщâoÈ?AÑ«nìL Þ¬çí¾ø?gå9tm÷bÂÝ/ ®NóëK}šŠ+Î.ÛY»ÙsœþL_sBpwö½lË`ì º˜g¤¶Q.ÊaÈ *«r³}s(:['»oª>=M·ï¡%½sÜݵÌ`‰$Þ[+îÛLÚ)6c™5*ígÕt¤ÃJ,{¶zS65ÅvðÕÛDƒIƒ7fQ{êŸâ¢Ç3´æ¦ß¼CÿÎXM}þ”è¢lp¯éÍ ¡‘â·à¼wþ®ãÞ'âíH CÒÄÃÛ?QlÿU^ˆæ#À()ÙVïç)Š(éäFšÜ¨àlþ£'Aì–âÕÜ+üR/ÕæÖ¸R·o¼êæöúŒ6^£SÑ=¯Ôv_ [=*¬)ÓõCŠ ܘ×réIt.6cë.4s¯p²1âïÁJÑê–U¬Õ@ôy«jäCç½Üñ‡×r‚PBhárC­´›Ëíçó‹¯ÎQä‰ ¨<Ú†®H“Ì£®+ñÄíéÉ2¶ÀJ¡¤¦ó³ Uà°¦{žu¿ßR»á<«€qÒÖóhüMƒ%¯äN>6?6¹eî 6”CpYiŠü®n‹k”k5ç99+º¼MûÂV¥û?¢ªvHhÛN¤L`œ±Þ%’n<ÔG<ª†¶ryîô¤âßZ>ôOÄï’o;c9p™úùdV~W)-b—û߯±ù™,øj]~j™éí§ [Yãq0ØæÜ,¯þ˜\$-o“ñ1®Í„rjk–RdÚ”RËæ^RL¶dI<[> oÚ¿*I4Σ0@춴(a•rf `YÐwé÷ÓÖG‚î®ÁÏE"–3ͦ#sâ†Vé‚æ+“•fè2ÖJϼÈWI.[»¯cUåmÉîLIr6œ]‚§¥"VâÕ4:Ó]'7…õNü6hŠñäý'”|óðÐó¿¾r˜¤ºø7`U¬½³ eØÞ觪U~µ"mVA’Q/î/=U‚qe®ìn^±¢‰\¤úÏ*°cvÛ>eÌÙoüŽ3ÞÄݽ?±Ç°s"­‚µŸÚ¶í}]H°3ø$–Ý·*Okß»‡ÕicêkŠÿ¾ Óe&Ä·Æ)ƒ”à)²n±ûAÿ‚r#™|zeÇ»èÝ—}¾OõÂ*ï¼z×2XÖQzSRZD\z•e“,ä3RŒ]ýÒ—~¿ñ "“X…Õûb­¯ HgØ¡7¤JÂA°ô ™>R=8*"QÇ”,¯«G—ÊÉ­D¹ielröBÕ’9{pæ,…l¼0Ë1›¹wEØIáKO9Ø ¨ð»]÷ºó)]1¿cØ­{ÿ»Z*½0€¼m.ÈŠs€|XP¾ç“u¹j £YÃ{© ‰å7pÁ©D$!3ÍI™8uÇû;”VÊ=F Þuu2c–>\¨E„ªåç)ì1X‚‚ZæˆFŠ%}¯¦S„%…«nmñªj\øPÅÃ~ºò#b6{ýþÚ KÄëåcþ€¤q.½þúSÍ!†‹„öYv~SÃð'•â§ËQÒ‘¯;«uv¤o,>ÀеpÓÿ>¡ÏØ÷3î ‹ÅÑ9ð°V¢ã2óÁwäêìÔ‰©¿÷ìÃ#8…ï_øѨè<ݪWùK’s®!+m"~ªu!î»8ÖÉÇ«Oóšþç%¨Æþù†o b.eÓfD¥QNô~®Œ¡²þŠ’­!¸èåøЂތ¤õ y¢´É³Ëï0æÌ{¨¥©l?>©c´òô|?þãWš®øØÏ7¢äkðF6Ú/è)§×vÚÅ#ßr×øt¢nO<ºã/ Te g“SA§.@¿ï x¦˜)_¬ %ÏÏ)ÙìãŒJS¶W¾¾‹¶RSÎIª½»@|Hª·FòàÈ›6|³¦Þ-µ±Ù3DÔâéöÅ}Ÿ¥7,ËþÒ2t:3]„`ìY 2ïºWØÙDƒ{!TÐñ󺃭–c……%L¥Þ_œB®WiÇÚàe.‰DÖÒ»ÅÐÌ…ŠÂkDä5¼È`—È¿ï—UÏKÛ04V*,‘d¯9¿z×)Ê+ðÃlYì¹qáõ6Zé@ã%º÷è¢Â q¤Ä®lØæ$áÛHn!ìþ €û•%Jª€t’~ÂKãu0=ÂÑi@?¿C}”Áè@EH·°|p K1F•9wQÙ×–DE>awéf†~à±MÔ² Ç8¾°¥r¡§»Ï°yà^“>;aGìz£Ã͆ð8Ë&r“  y 5»8ÅhÈ¿Ëï&.«‘Øó= µf´Ïp\:,7¥Õ=’P9?ý¹òK3½ËâКa BT#­€e‘’Q~ÀYÚïE2=g§ÌA¿‘ò´P¨ '?)5nuj#a绣‰QùªMb}Õ—†1±Óñ厙‡ Žßwþ§Ïû#ÄZ_ÔkE$|5š¢ÞÃc¨™€MêKì²gõj™Š½5Ë à›°â¿²Øilñ*1ºÉÌÚîŽn%ƒOt¼Ù‚%{ŽÃ7Þ,"0[ïº`'‘ß ¿hÜ{ë,ŸC¾Ö¦=4 ­‰•›ømZ”Ýh^ø˜Ä?]D9Ö±Üø(¨£È—x ×K/ð¹*Ÿ#Þjá{°”ävX½éü•½¸nU•éú”Ðcä=BDS“”z~Ý}bŽÎqµëûr%'Ž7Ñ$q19ÛÛsjÔû§qX}ݾ4}¯~e¸=šÍîêl¦!¼ñHCÒ«@Ù¸¢p ’%üä^'Dq•Asç\˜?ÙáL€ùž¬0"x`PÄçˆõ×ñCœ¸ŒJýhÞNj÷@FéhTù½â}Ïgç(^ñq‰À˜–ôÉ’Ï,@–qbË<ŽòT“†€ÀŽËŠZy!òdï·o ×»?ned!ÁH[uÊjµÛGd·D¾á0€*}ÔÀ¾çlM{ÒbÍ ­ñú*a–¾;8-W†Á\¬Ep* í5”¯‰1ƒ‹Uô`Ú-™„Å»øži.¥Ë»'}†IntÏÈ:KjŠ„P†•DOŽcÕâ7Ý#wªà‰{g_$¹ëéàÖ¦à™1ŽßÏ,Ð(@cD§ËÈ?ŸP åÌ@»ó>Ùø š»MOµóO)‹P,¶?x Âê"|m‚][òR¯S«Û£:5ÔÜgý|£OЪœ ¯ …–ÿŇ]в4Òð£â“^º§»wù×:þß6“Öxš¦;v4‹ÂV²å2C䜆sLî‹”•ºgĈ¨Ù‡µÐ±‹ÕUNUY{ã16H¾¸køQVľ;Z&Á ÇTקÆ\‘ˆ÷3À Jpm‚¾1ؽúKCŠ!¡Q9%ƒ_oîØý0ö‰oSäèj®ÀUHÔÑ<³Ÿ%çÕ®?Bê3‘Ê4%“˜wœÙ«:ƒ£?ýUˆ0æuÜN»3ÍƤ¾1å>* ÇÖ{ß¹ÒÁ²Y õ•a9ÁÓPâe3¸d„¿>S<. æzZ‰]4s<玣Ò/?»ì?üt`x¦îq!'ÿ¦-ÜËå=¹³O„"©¦åmþ»6†ž*¢(4›ªGÏÌÒ¾Iky (ÉŠ‘—}u•/òÔr¯ùé†YNÒ®´éŒžŽKZðöL/Ðxà8åQ¡_Hàc—`·ê6ì!:k-nÜD\‘B¬éM|HQ|Ò¥¿¦úÚ®™€Õh“G-ŒMP‘êä‡Å²ü€3fTî,aØ /¬ØÇF pMu^}Úæ̦׶ä'¾ÜOî%;õa¿A:ØßͯØ*öKéIE)®~Ê |ƒÕxß—ž0ê2¬PyÄoF£G³å»ÈYòš<Ÿ}77듦÷m‡­¨)ÎÝ/ g:ßÁÖOÅ.Lˆø*yOMeǃÞ'NÑçÝ÷»°P×.QLô±ÓBŠ„OßÒ²q›i˜$Xä[ü®*æ…É‘{×;×r4m³*Ê.ÉdÁ/­`YŒ[uĆç¦ð*“Ÿ¥zÝDZfÒ«‰Q08~VÞ«îN~Ö-£=&ò÷ë DoÎŶ²WÉáñó\àA‚+‡"a‚7§º¨Øß›ÖÞ®eôçã\5ŽþÖIO7Èõ„è7ýÀ¬>l«s¿õ™ø.olVÎF9B[üui;׿ǩý(ŽSÇIÇ#¾ÞQ˚÷âDäD4ÛSJ[@ÿ8~Þ÷LHå_F‘1a–ÞmOW/R¨‹d~LÄlAüŠÁØôüÓ 5ÖªÌ[>3z³KŠq¾úë¹ µJ*žÛ7v²ÔõÄô•FÞšNú‹à•pþæ¡ã^J¥ðRÕ øtBTi´Ó׫õú=§¥ù½Tû·j²”µ¦%°U”„ÇæP­ÈøÛ‘¸ïñ§MRlÑeý¤Ùc0Qk&ùï´æÈÊIAßÜœåérÿ8k ôݺ[ÿÓz˜¯¡üÖ[taØ-%3 ödáÇwË%b?ÕuzXPŒ\U4:6IÒòl”väš9Žöü"ª;ÛÀÅØZÛ AG†×‚Ç:·›WkÖŒ¬’ uÊ]É£ü³us¥:éTM¤jÝ³p+ä&*Â_ÚÐŽ/Îæ´Ž•Ñ€™ÂoÜJ˜ù®ñÎFxÁ»(<†e ž’>ϯßX×U²U°WmŠ2 lãs±3{u¢˜(=Û#Ö…ˆ;0ƒä­ø-²…õ¶Jð¡Ú·Åå#Üf‡ËZÔZû¸Ñ«÷ZXM7 R’Jw¯»€W(—4ÄǺ:/Yl.<!*mÀ@}† ç}›€Ž Ê šògƒ*~÷@’œÑ=ÆïáQu’8ÌAL‚÷ í]ôè»<§—¤ˆ©Fw ±AŽ?ºÁ ([± ¨¢ÒŒ£ÐÑ‘M†Ç†]Ç*æ5+;k°(«PËæÇD‹“þ±„-°J’wnp2¾ê¼Wt뻉0¾N†ÜO2ªÊRTE;x3©Òx¯dWZ Yˆò¤>ðå4mDSmI#kÑâÇd§³^Ff ´žÀ…—Þz@»„ÍÍÖN½RŒ——bé†s´vÎÒ®8¤ÎÄèR¹tú‚ß=žC B€š‚¬ˆ÷ñÄ/ö¥1¼ktëÊBîÍRï)„["¦ ‘ý¸Žfýùlÿ"Z3ä†L¢ïQ_~ì³kÿx*B"þŽÈùîiê%ª‚ü¨+ó³ 3}Ö„-S²X—ºñŸM#E*ÄÓÓ?&jœ LCaи–“j =–¸ºÜ°ÈkVÈ® —m”¿õù,Uð^׋ƒÃÈe³6Ý[k¥‚8»2Þ—I‹‡R[h%‘àâë¦`~)÷ »ùØ6Ö·m„Ê"ƒáKÝø„}´%-ð¹A6‰¯™yÈf§K/¹ MÞ$QPH$é× ù¢-¬›…˜DŠ|Ò7Ô©ªf„©O+žP¹DV¦µ=J:Åêè@A­ ABµ‡ïÉèÃïÏp]8%0,·Œ;7­<PõP¿ö"óú|¸¸àe]Ê–“èÅ[űlê‹+x©#â?vQ¡Ÿ"=2IO»~¿Éh}M´ŠZ7ûh ¯¤­|wçdZøžÅ­j|îfº…žXy” 9ä<ûIýs{E乩¦Tzþ`ãùLƒ9ú4eʼmû:ORCéÛ©ScÔD`*rB&íw®ò%±øþ‚t˜­+`ˆÑýVXª#ð]µA SÙk óÝýM*ºÆdö;š®y^•™¯ Í&èµéÄNgå÷àgÝ_ËχÍÊ?­rá~!…÷dß›EøåûôzK´ê¥^–ЧÔgîD̼dépK€¦¬²×!_¾“–y÷+qÆFóæNÚ±e âRY̹a©VCdO‘†Nu׆Y-…' v”'Ï]XéaiìK[ò–²\>§ˆpë•p˜€>}”é8ÍS=…¦õü‹lúmÀ[Ñùá°@>¹ø9\g?p"yç:©§Ç: |B·›âËýñú¼Êí­"bwg¶_æ¡ÆX<ƒ}žÈî#v¿vºí¼ákåçq‰Ð0Ù5¿¥ýÐìOQ›ÏÇ|Äds {_Ü#u¹eº”7yåþïBéP‘sVÃé›”h ;˜â¶-«hú˜—!Bù° ~+„«õ(¼"JL&ñÄHȪQ&$ÝìÑä3çÎñÁ`©dB½_ëùÑ|ô·›Ci¹¡áã ÿ'Ç`MûK®•­ à Ypû³Ž%¥DKÅð™ 2Ì{NS1rT)ª5P>;–[v+VÍñož’Ë wgÛ‘³R·_­žà"®ÙqïÈFfŠjÌCw~{Þ‡Ú_пK÷w0ÛvI“ŒÞk>v›0|S`¥U’I «%<ÉËG™µœ»FóÝ·Ñ ®Yˆ˜Ô(ËjÁ-öÖAʇIƒ—@÷‹Ö‰ø[ƒù¹žVúø‘Èf$!U`í;˜³²þ¸Š!¢8'Z' ÌŠ™Ø”JL­©Ñ4×b•ád°­&ÿ¸,õj¶/ª}£º‚{ïH©ð¨ ï¼.\+µVârvÒô]Z6 ’ÎòhˆŽaRðÃ-­¨¢ù<Ä/·Ï,Š[~¿ïåî›]_Ò¯‹D‡ïCbQñÍ_hWª’ jScŸ÷î6x¯¾3YBžÇ÷ð©Õ†¶üè(¼;£ßˆÇ%ÈÁŠv§š î–{b 0×áN¹*ëÂÖ¹ Øgä«ûö6uB}¤‚^\8²¨™!ŠR’UWkê—xÊ ëNŠnI^å6Ê•k¡òÀ²å¨ÞïK¤`éf KF?„ÁpéUx2ïÕtŒ†¿À1Ó?MŒ^¿£{NOgÐÎÓÏVìÚRœFÒë&½÷t?2Ä@÷›‰„(·SÕZû'™6˼õw'Ål­3³ÔªFÞðC¶ºÒ`fÇÁ0*GŒ€¼)…ÝúE~„$´íX&›ybPŽK|ú IÊ4¼4·«$ƒ‡€Šˆ«æC™5>&¸BeÄPeU³µ¹:>yñõRû¥è×ò4o}ß‘%CtÃ3蛜0^Ù¬†ÇÀGŒ9gB$w+v?°‚D¤WŽÇˈRÚ¡¼ÞÅÜw²ý}³RJ‚¯ïÙ¿K‘ÆYO%ó ÛéáŠ[¨"w€€ÿ_(ÿÿO0³·0qqsr0q±Cù?’¿ó endstream endobj 171 0 obj<>stream xÚí·UT\ݶp‹»[ XáîÜÝ5Hp)ÜÝ!¸»k€àîîîî\‚—`·¾½ÏÙÉ=çñÞ§¿ýU/ÕÇsŒ¾¦µV$Jª Â&vF@ ;[gF€¨¼ˆ¦š4 3€…‘‚BÔhèlag+fè ä°ps³„]Ì,\NöOÿû±s÷b`å0°‚ +';h ±ûü¿?ÛZ8¸¥Å@熙™“óß÷±‹#è;ÿ뢵øo6µÝ@ ;ÐauÉΘ7È2µ)¤ÔW¼`¦ šÆ‰ ½8h¢+¸!—ñô/Æ‚có´è=ÝÒ¢-å\¶’ÉÄ”c¯IØ{ØK•)x}‹&/Cö—ñ©ŽÄHîPªMvøÑ*ñ¾}3ݯ5²»-×.èj¹Ÿ,œùxçP¥ËK¯7¾V~“Û«ˆi&d)º¹írÉ@õã­¸ñßg’vv«…#t2î0ßVñú6ç¬6Ó¹#såÁdmØ£TSèä€Ä°ü­]Ïèë´| žl•tœ2D×Ãs2?‹™Ø‹zsÃÙ GØ.º%Ka¦÷ówÌê3Ö 7ŽŽ)-à]Š nãx::m=ï(×™ê}¥†^“/%â%uð~fxŽ… Ûeã'˜ü;ìí}V6tCž¤.iüòÜ]æÁ 9Š½•\*Ø~—ïI—OÊò¬Gbö«ŽÄì:ë !×WYCK¶íÆ„K’–Jñfß³ )Šé Qzg¢è8å´¤‡U›Xð͆§qÒ´“|]–Sø¦7òÑýæTS"†Å¬Aʳ¡I\’ézMÜÓã6¦±âóFál‘Œ•ÌÌ]¼V±$N3ï`/úÒ¾ÁÒYëF‡Ý,……LRÂlòνMü2&WKú)p‚Qö ƒŽ¢V9 6|d˜Bõ=BB4éàÌ©„œkþ;8$nû~$§ëe>pˆíàçǘÄgpZN¶j¥ýª,C àÑÎÏÏpšh7)XþP“ûpgR®s[m)tlñÊ­\+ƒÉW”Äà ŠØ%ºJì÷Áˆ ZåÙÁp@®ØtáÁ0ö´‡-¡/¥‡&c°­\à›`ô)döÏŽ+Oy›%ýôïŸ'—ÝkûŽ»ÌÈüÞÖ®É+àGM•ðptö˜T¥5>ø$U§hÀ³î=È Þy²ã%YO’ hä­<Àqk‰¨ø`¸ÂpÀ“/ã÷Ø¥$„ÕŽŒ±C’¤?0aš?HJžÌ‡Ç}½n¢Álymý¤!”{÷!ºÌ]u) Mx¬Í‚Œi&Ô;j½Ã<-†[ÓT/'ÄY$; Âp†%‡Æ¬-^·Š'zÛ‚úÔ•Á8qøÀ%µ©r¼ë¸hVX[u"nº±¼”;¶Ÿü…Å&w´¬˜_—lts’uŒ_ö Sƒ©òÚ j¿k¾íœ~îùæê@×:&ŠÅÙºiz9uê§ëcø¾¯Þm€ðöfÝM³3o>wÉÜG5ß¡GxrT²°©+°qñÜŠÑ—’ïæÚQƒ5+¶ý–¾b÷³x3Ù^ÄÞ=ˆ²?{§Âq&ïÙÇ2Ä:£}59´û`L<^ñù¶S L‹½ŸOOö`“”.¥t飪ù;! ‘Oë‰:âR¸nz/ØvûeìSEó±•ÑC?`ªßÒ&`[—pËø¾­â£KWiég 'kÓÄ/þ j·&`aü–‰yòVÿųí# u?Åéî\â ­¨ð [r[#ÂΤu~ÂìwS™þJ¿Ú6óO“ßÔ¸{„À¦Ç î™ÁÇ–õ•ïi‡¿Å»Ð™hÓwsfL6NôœpâS%§/ïªr=Ę ÎÉ$TN1Â`¢)™QÊ"!_Æ®:È>& ЗΆÏt¡þı—ì¶Û3ýîëˆ(¥Qû”L&›—¨XB”ÔidOöZ0õ“××ØÚðHé¸ò2êÉ£i‰¾ùä0(ÒèmDÖðÆJ>TH$¢eWBæÎÔŸ:LÕäê úpõž«Ñ)Èï]çpXPÃó'yž9E‡ó¼­!ÆíMõäGeœ×Þ»àÍAT¨© (@]YŠçËSkP,unßì~d…9éダÄ'­yÈZJ®”ž»œd„ûm"% “©9M#P/Xú-æ^ᑾý¨^è2öÓÊd7"мêÆuO%Õš<ƒßFú^IÂÖ#Or03¯hCæÞàL.öºõ«ÕÛÕVÎòçÔq{X‚‹^˜ÊúŽÏÆtHþÛé=_ÞKð¤Cf=¼56°6³¥—é.HV3©Í+—ýI[fªRo2ßÀA†û$Z½s­‰í˜Ø7à=²÷I'€˜V@&ÖÅÎOu4×ÐØÙ4h”ÿÈ4K0äS{"^ã߆B£´6Ÿ‘ƒÿ‰Û]ƒ¾^>¦%ª5£ >û0ïDõ„i¼”Ó„Ðem#/ë´Vý«n~Á“;ðÌu­Z*n_rŸ{ÝäÇwŸHÛ§çx+Ÿ•â]q*–K°€LòpÊòt“KN"ÖèoŽ‚2ý?×€óHùK®Æ×{—ˆùû‹ ø8ÚëÅtlš…8Ú©I|ïe?Š¼Ö»Q-X'pšÓ¡6 7Æth7ãv{©Í1r¬° §—ÇC|¤Y´Þ«è0æù1 º:ËMusÜD,ZÊ¥¸L.–¤3j×ÛÇCžˆ—x„àn«÷QD²ù/*ÔƒnI­ø~—WƒY‰)ÝYgŒF°uKƼMðÝ×rïCÔ¡½‘C}ph.œ%*ìOª“Ú·uïû¦N-üR:OÖ•>„û‡úÞP/‚+Á<)IO¡÷+Rx¨6Æo2.„§(à¨ä$êCå( ³TEQÀ&ó7&ÞË1ÖÄo»0{]y?3>ùøt5ë“È«"ùyü ‰€LÙ™²è;¶bÀÀ^®booW!´kr–0µB)rA¤ÙŠ€»Å!•†ïÊõÏ"²-~7‚§ýE¾òøÆ4t»ØLCwçWD½rÿrÉGÔ‚Gï€õN¤"O ‡-ãCî$àÓÑó« ®!®Ò¤ù3–†x·êhEØÙ½Vº,Ž3ùâƯ Ó t’þofƒ:Cg„™,^èÃ[MÛèùoa=CÙ̘ԾãH¿ÂO#Æ”¹Òíª–ãÖt€ý«R{a”Ó´Êk¤Ã?:™Ž\Å ¥£ŒŽ~íø»n„–Zó[mIÔ'ÛCÛÜïu:Fêô™-¡·K„CM¹³p<Ò4›ßk}0<[3O…d¶_G˜À!Ñ>ãôÖç) CÏ "7|ú0LX½›qwcž õbOzS¼R'¾+õv¸ªnZ5Iαîö#Í?ê*I˜ÂSø‡V÷ž²íõdiÿVÙGgžä"Q_§úGštf¦úÁD¿Ý|!eF‹¸ËþŠŠžÊ¢[eÿÊSí dªWj@:.àIo§Ou'ë2¯Ë›f¶ßþø*Þƒ¬˱Ó)L·°¼“˜¨¼r†'>e{P–ö µíKÍIÿ‡„¾q¢!öN)pl«¢gëúÌdÀY@$g\o+â0{~ó¯fö N±#D‘Tü'÷Õh9GH.XÌïí¬‘KWyÔVds°ß*¸¡nä¸? l½˜ ÿ|’j—´&"¿á¹Ì=©ÈXL¸m|¤ J¬¡Ä’÷Š(7`5¸®Ä±áy¦@2¾Ðùh”˜Eh—ðiòÂ9/&Ê'µúë¹”ÓÙ÷Á^PuC³ïñ2YA¼³ðk÷ý|Ñv‚¦ÿò¦ÞRêE¶žK–~sÎ&¼l,’ÅÛ3J@åÕç iþ¼3¶‡Kµs ¹Ù¯îÞNÇÏY:ºc©ÿ’…& vÅ›/,Tiÿ}§u Yël©˜Ë¢áw|%ìÍ…Z=Gûyó{çF.õ •‰Üå |é±õMðt,Ã=çÌÒeâ #ùT•o!«à|æ*÷&·„O{JÒy–­a‚l;´ýâ3<-V{ $y0_ºÐúˆŠÓƒÃ<ˆÐE%V[Úz:£üÒÞÇ2×p–© ½Õ®S™ß ãD­ñ¦Ä/讥wÕUÔ†#°¦ßÆD®äÞT×I¨Ý3É`- Kék†™©NÚÕªU cÌ\ë”P=Ær]5`z"£™oˆãL5 ¾Å(_×—r}žÆ\×}W‰9“ÒŒPŒËqœm;•…k¦¾eK«÷jœLK]W¯WUPŪ+îÂL»Їk*Úé s¨‘Á(”nC¹ŽéÒ¦Õ½#k߀we)ošÝ»b‹ú~ØvEK›Ø!J@{;_l!ó“ÿ¨ãe=¬¾‰¸¸Ÿq7C©µ:ªâ²u…Ì1œ†ó':-âØw¦ó‰£Æ† ãzö0µ8éàîs8Û7ÙQ•hÕÝ6ƒ+ S,9N_v8ct—€B{/ ; Ûfy"cMÁÙw‰C¾k}#ºyÉï”#˜ý?b*à—¬™",ƒãHr—¥~œ†(v§¼P*6.ê ¢VíÊ~Z¢—Wë…!Z±µ‚gÀ o>¢Yþ+íëÞÇãMÒÚ.3Ó [üŠfw©‹²|îKÕtø}Ü]`0•_¬¡M¼” “'Ö.#õ_Ôu–˜rŽÏ`IåÀcFžÉÀ—…Û‘Wô¼ËZð±|G8ÌÇŒe«¦ô‡{¼&T®/`'Æ';xÍ “ŒšÙjvÅáï¾Å<ëØ “ɭ׫T¬ |γ¼Ás‘3@ØùFÍù‰ù˜ᦟ5_Âh Úvbës§Ô·ïÙ¶QË.ÌþüE/ƒÅüóòò푤”n³ª†Vãeͯ«Ø,6’·Zðƒ|æP9ë¹xÜ ¸¿#á$£w†’x²~@!z‰#…gv¸}æ^)Ýš¦”ÝË{¤ÀZÊW_@æ«Ñ&&ÚàCÊ&9=ݧ´‹û¢?N¡A¾ˆËFÆAáÌ«W¥¬¶:þ%l¾ö‡w>Ñ»H¯ƒ›ÍìÑZÅæ+bôo{¯z½iPùÁEò†š¬óNqCM£JYUàmÍ”}àµä¹œÆO`”kXf‘ü`Ýš5žÅ±v iÊ´ÎÒ-Änsá^-Ì ïãö“|“˜~ŸrýðÂá8³^ÛWíú…7®ü^sZ^¼‹ñü*L¥[àk:ãÍá¦ò9gz“—ÜøÅT_È0!mÆZ^ëÚ³åÊä«hŽl’´íÜp€?˜ žû R åæó§–ª¦¸æÛo‹,\^7Öo\ )í„­%—›»&µ6õø?ß­¢¡ .[‚Ñ8‘´?œÊËmn°ŒŠ3…Z(ú"`G›‘HÁ' Ë>rü¢a/S¬éò}Òe]k¶¶Ù·™Ûs8Ú iãÿìô:ºUY™’¹cj2äPïÐáñ*Kô«ØÊŒÑØ7(÷¥ÅV«9ÝWÿ0Z‘ÒRámˆñ/‡Ž›/ê½Óv`6×ê„™ÂÚ=ùhƒXoõŸ¦ðÝ YuûdM®GwšK¦›…¶$OÞÁŸÁz1èŽXª™Ç8 -êõ舭󹎼¥_t`yˆÖ7rc¾ø›ãõëÉŠH8G’óþ´'/³pôü>w$‚ º²ô}ŠýéWœ§²ê•áŽöË>/ŸH¥¥ïñpÅ"cK#”3ã>ÏüBgc\eù)šÖN¿5 õγ\ή›©VÆ÷®aý »Ø©©H†Ž^õÜ>Nðس6³’ˆ@–ð¡*ˆ×üÔ4gyµiÈ.hŠ¬Œmí«Ô—ÈyÈÂÔƒÛ˜ìn.hQ‘ ,:èàüÙßÛp­Õõ›×’ ¯~ýé®Íj…‚šú>èq*Ž…l;ÒºÚ¾ÛØœV­T„‡ùÐgÅã-ddCa§¿ë7M|"Úu¡L8ê*‰‰®¼^eOía ÖX‹/ÌW‡ßµ1v‚˜oÉøßZàG—ñ±30¿¨%>œOå©4©¶õ¿1Kq<$"à¾Ê2¥ôß/˜§‘cn-I{èYF\UGß2ÔÑÎI*‰ðd9«™sØ%Ñq_Á„èÑßVÔøiq­ÝõºÑÛ†’Éñí¨?Y$ #yˆj¤CÍ©¾kœóÁTÃŒ~K°aÉ! •wÐI]¯,¤YŽ@›©…y±K€¹BG/Qc‚á>kx/“LJñõ‰¦.oEz-ú¡’‘'1¦Jù‘ù‹ãGsÿ cº‡ ×Û†eÑt‚2«SÄßWÕS³µCð2Ç:ÒÈ6áíæ¨Ä• €j¾Õ¯BIŸùŒlùó‘¤;¤Úì5ÁGÒ:†OdÜ3×ã²U]¹]†©²‹n”¨—“šf]pó¾c¡å)À‰S™~AvN•qÔz ÍVƒþ¢†`p;J.µãO„%v™e¥äPªò‰ïa8Gëuʼ¼WKa…KГlì-fÂ|tù7%R 6ʧ°çTœ‰{•ÉŽ±€íÝü²ÎE&®eˆWäðM"!¸BûJ¸Œ» s62ÁO{ÁTóLvz®›*“åñOh[ÏþnDž±þ£®«¨1 Ö9«¡?49³PÒt“í,(E£1n#MCç…‡qÈÁI]ÈmŽ¡Ñ:XïÞ¶KqñFLIŠ\å )•Óv²NXYiJüÄ 2$®ÂÀù:Îfsïbàìßµa·è°Ôz„ä“J3íÔ:r]¾pÓß‘UF{ŽcŒ‹“æ‡ ›@×  ì‘Be«6ZCÑ¢ ˆ ¦Lg¤–×™ÎT*m#æmÀOs7Úî=dÕÆHÞþµ®Ÿ’}ú£ƒSûÔV’D“*çÝCZ˜É`ÜJÉ%:%>(p¢åchÒxò¶«`XD‹_‹2x¼á÷è\Fº“<ºÓ™ð*\õEsZ!gìwŸÓšï7tw±ç'}‹jô±]\îAr ±9Ùûã ’$ ZŽ’ÈgÝw#„éÌ…»[fN##<וÔÀF¹Óó–i¿ýÂà·ö0ü3^¾ô›Mú¼Žë÷I"+X-A”ŽÓäÌAl-s‰9t¹×D=ß7æˤéÅ殲Ƽ\Gxûz©xÛ(Xñ{¥¦úKö¿R¢p®xvýÌgJµ'kœìZ`9\9#+È)‹ô3ÎNtb$Dãyöî%N7 '¤-6OÖˆ~Eƒ4f!ùÚH°qkMΖDÀ(nT!0åÄÂgšFÛ£dݺmÁ.[›«½ÄÛ]ßg²xx pÓ5¸JAeïMÈØ•z0ÄÕÊg ŽÿäwaéÔOb«Û„K™ë˜VÿDýP’k{ð¡¬Ö™…ÌAKš/÷a"‘–ŽÎ]Ž÷ZûS•NÈÐÈšq¶ØÂ(AšÒÆ{åüéZÕÖ[Ufjßè}}=~yYsÔe‰êð5'yÿÇ£Ôà)ZÑŠ*0«áä¢ouþÆâþ{ f3¬o/1Yˆƒ M€‘”û+áÓ•‰á²!¤£òRâ ÛÞxdbè•$ÛŸ.âá~<—Ý1±Ìa˜@ybÌVêHxŽ÷‚W°cYÅòŠe«cÛܽ< ï4Ñè´«‘lBŸî¡¢E´dæFª‚m‘-Ôæ‚ VS‰ Š¯Ö9Â^Uø±;žŠóÊ2¶J6¸k1T’/³vקã¼Ç{&i­±‡¿Ê(wã µ¼¿3TšAbö½nrKNmù”7kr¦ôÄÅÅ\(œŒ«íì=²¢•Ê²C‰N$œ­Çu¬3(!õ«B –))kŸñ[í8ã£2UÞ©x†­M¥µ‹~^ð¹$B ‚®¸5±4 y²Ëai··/øÔÐ6G¢”¡îHd0j'¯³EbðWNÑL‰Ù‹\=˜!©­ÁG–»4«F²bœ‹™¢H™,ÞK¿ùS| ÀæeŸIóÊig ЗtƒŸE ?.By1 úÍ`ì) ”¢“»…+ U’¸ €w­’صw ölN¦ZˆÅI¹¨„1êÑQ›#|E+ :i›tå\U¸Sl8+´bŠmÆÈR´ä!ɬRå„N`ûaEH'õ=ºr§½›6è´yA¾Ú¼Kᬰ¿>ú ’èmûX á3óŽê.Åä,¯–¡ÁZÖ~ÐóRaNû Œñ- ¬å³ægžÒ{ÌÏ׋Y{ŽõH{h¿Ýo’sLŽ,{zÔ]£Î·…‰÷ì61Àð«NnKåa\¦Úèãh‚Smòäó‡*çÓ¯‘Ò¿Ì·nÊ.•u…”ýWw×9¡c¨boó•Ù¨µ Í|-¸ÇQþìŒnøÖá‚WÍ*òdþQÅÃIÀ¹ÓÏg0ðŸLjQò\X…áQxí?ëâTz1â«}$ÛpânXžlxô/ûBçK„Ô·òpâg×U4n]Ó5Lg_&v¡Òƒo¹í¾”µß—¤2.$Ï–¬­]žð-1áçÁUØü-á2Õ"NÇÂ{ùš¿lÚÁ³gúŒºŽ\¢¯}S<²µã{|Hq”¤cTA’NÓcCsCþ ¦§Ê7x‘Ý bˆdÌ´åz¼¬<00ü˜º¡»É¹ueõâ'’XÚ4ÏMϤ/rZƒ•µ„(¯ §áÞµê7¿›æ© „Ž 3ÃΘ0½ª¬ z„ÃqeMÐ#ºp¸ÜyFÛQœ9µo-0Ðâ/+6꧇!µ 7$¶Š·wé·!î=˜É[?8o\FNˆo†‹#Ï~ú Ñ0ÆÐÜ®Ê3 oIrÏjW¶æ£ãĸo¼A¶ÏíRʧ\÷B:ƒ¿—6»«[BûbíÛîNt)hªœuu#I2ÿ‚H¼ ƒQn »"ݼÃ÷›òû£–Ù’ËÕ”0”jBV…‘¿Q…6G‚e1æš(xªm\ƒ…Ù&ÏkOB?¶¡H¦žmý^·5‰ÎIµCÍÒ ç|­‡ÇN‘wåŽ*‰î*dM!iÔt+¤AZèÖ§M¨%9œ,¶ø!ëKŽ Ý1Ôk)ðåUIêoÇwz{{Xc |µ?Z‡ÊIuŸÂûp*ãd,éHÚB¦¾Þ_ãYq’Pߪ‘"ߦiÇçQéÒµ§GªëeHîü•ʇhå~êR|Öni`ÂÓ‰Èc¬™;\MÉq‘écƒÅO·ÅÓµ{`ïÂÇ:~ ßõ¾ºýt 5¤<ÛHÞHå¿÷YŽ Œx}åé€NBs<|v`Œ7Ù,çäÂ*é^Ê ŒåãxÕ­ƒ¥e±u]Íú>'® “îø ™Lä›e}LÆ#~òQ¤þRpD¥ëp”“óÆ[dÿ8b@1²Oè6˜{/ÒïÛn{íy&Œ­ßª-Õö¯Êëï£&2¾&\*n1@Äóen:Nd‡}Η­ßsÖ!´šMúM-kÙËåOê@’oÃÀç°œèãÑ-,†¿cv6qrš«˜.çnª´{Q}™Å[­eE\›önIØÀ:B0/mnµõÂ%C x"RúU÷ Å߇ÛekCp˜ˆ •YÂ<»û^ìû¥xšÏ¹ïÇŸÎ\‰:"}´æsFTÁ¿Â;ŠÊaÛžÎf”U—¬CiÔÞ³ª‘ò€AUQê‰)ŒùY{d>½uz„äB»(¬ t†wkà0…”sþP¤ÝíªtîU •¾Ë[ ZáH!¦9º…I.Íqð¿H™ç."è!ÎE +Ô÷ÈD¦lº­.ºNø™B%iˆŸ¹‹‰Ñˆðï`Ï­*€róÄëo¸,ÒCÈåIpÔðÊXÁ9qcÉŠê3Fý‘á2˜‹¥ °ôìW·)À¹.Ùtì¨Õ¸oüŠáÉ„OJ?©„¹G}}KI¿ ›$DYEŠ]P¥”žëýÞFǘ´×I³X^muÌâžaN(À§^ý»B÷×Ɔþ³÷XkÈtTOjØU…»©·Rt;}]o] >%¢Nµ÷>Ñ‚ mʇv[A9Œ¬ÈBþWã:΂4…_w4­žÈËÀ†Òü‰„Z¯ŠÜÔ=í|ªudG¯žïb6åèÏÚèEHóUMÂ{YLŒÇfÆã”ÑSƒ*¹<ÒpT|Ps©ršõ׺ÉüÐÜà©ÆVa£ˆDriÒY¼È\½â"C…¸G’6rµtÓ“o€¡—È# ’éŒ65¡!àèÈüKÎðRÚ`juÏ—¨£TÂܬ‹"*ššÈ*Q_ IaqøíoZD›ÖÕFØ ÝVˆÄ¥ dÇËëwµ ¸ t¤þh^¶*ú‰>gÔ£‡~¨ÁÙ8~J²•™R!^$“0h€†¼iÏœñò‰ @Ç[¥¨i ndHSӜ´>Úƒó’Â$¼Ëû£# A0*¬á\a`ö-B‡µÊ¨«aBLKù£HðUI÷oYÄ«ˆì._p´Ý!²Ó RG~P‘pAeŒEWbÕñtµÐ›uΖ3ÒÚv(x|ê¬N£k„W5äý¬t&6¿Ü™ýÛ¼yéŽVéþn8,lì§%ôFy¥ˆ»9Mˆ™áå»+j…õ6*~R1¢yÉ$ê(l—YëÚƒL­äÛ^‡²ý äææcÓ¯¨ââ¹PÒÖiB_¶>$Ö¾‘t íY‰@6½Zl|zDC oõ ¡DõtDv1ÆýÉvüAeiµtN”ñ ¦Oöòw@“Êiöl p?ÎI}àÉÎê4ïpcÓ:xí“`¥–D‹»klãÈîN¾ñ,£'¸—b÷=¯»ñé›!kBù®{UÖ†G¿ñOÚ ‹ß¾r ¯Ç6'ä¨ûíW¼ñïЛ5Z¼¦w¬'ê€]Rê^éÕ dsÞ´lwÌžIä™i䜄ͫ£µ 餗Fd;5j‰Û¶.0Ô>Þö Q*WÑQX`OΆµœƒþöˆ01·ööº~ ´^a<•"ý”DP¬KÔ.¼ÿa‚¶vÅ,mí…@¥wP*]•þh‡ˆ|1¢‘[àWص†`dT¢M Õ¾D¾é è?RƒÆû0i(Xæ É-bC{¢P#‹ióôvx–p Ÿ÷YÞ€£¦9ù%]„õÐà½Ö—P‚\ÃÊGázüIJ©Å™¬_É£‘pxØQ…¼Dô¼4zè–@ý¶ŸÞ‹>÷ˆ3º„~ÜNóA±ÏJ~ZÖ¡+\8)0#ômÃÌ4‚¾Î/ÎNð2²cƒ6‘& T9¤Ã‡ÊD©;ÌìâÉ!œ~ºÐ™!L9á¼è}º4ººg j*–bÊìuÀ˜ú¦›ôVþ•:Ì…4¤‹Un@ÅOEâŸ.,H mâÞ3 _˵¶ù˜o3ªâIð”P/ð1ìâì‘ÅÓñfBlTÖBiZ¯^î|—Ú{ãíNŒvé«ùCÂyQD¨¥É5cäxçw|öU%2"úÙÔ¸Æîó|,îŒ2:·Ë6¥ ¹ÂÃoèi[!q oÚÏÄè?‡¬¾ù›c"¬?^ŶÚöÂ]+œ7ôCSãn|êl·¹§O®`ŸÍõþ^¿l=ºd—p¼D‡TÔ±+™žÌé. #œ:>"O´‘9¨"´Á!E,íøÞ.i”ƒiÙŸŽ‹€¡¬‡ÿd]"$+X˜i‰«÷CÈ·3«°ð¬ÉŒÏϹ9tœ±.Æçkͯ>eL%Æ©ŠþjWüÂS¥îýÖº»¾üÅ}žcFV^…ÃŒRêNÅò0oó I?!jÕž”ª¼šîçVv°eÒ£L¶Ô :Ó’R?¸•Z[D/ :‰‰O?ßì'èà8oQC©¤`‹ÕZ”)Ž6æ™3ÚdÇ J˜è½P¢€ïÏÇ-ùöYE†t¥Ç„Ф3~¥T…Aîn]ü v´â2$2 ;þÝxüÝ0ø —ÇDk™S¯æ ÏÅ4Î&Ñ÷Kž’.ì1ý·¥¦ÜhT+>÷UŒg›}¬Œû´ØHî”@¦Ì*´ï¹ÃJ3°ýšÝ<ƒ~‹friÇ,)5h¶DSÜAÌ8ù1®­MññЮRé¤Üm›æRór(_Dr•ÞãsIÿvìïGtúLu NBähQÝè>É—¬qšBû]c³ìñ7Ò;Èßòz—È°_J‡˜ÕØêêø-Ú}¿0‰è^«´+Y -óv/”¹›IºD!¾¶nvêã>ävg'+LÈõ³ÓWÓϨÖ5ÓÏ5 ­ d–õë 3'ÿÑ>LôP7Løa—üÛMU{ø:~£cÉ 4Äj£o”T‘y‚bœàÍâ§>!1™óc¸û<²Èøé+À±!Î]¢¢È<1fÔP; OóåõU’¢¹ûœÜ½Ç„ž(ìMƯñ!OØÇ5JÊò¥ÇAñÈÕWW´WÄ;O]ª3™†˜”ìÎÛߤ¤ØZ¥g®m+>Bk¤²ß«±÷7°“b·î«ˆ»»ë_ÉãÔÁK2q2Ö›âÐ8œ…²²¢{ª…„¿éÀdàŒÆOÌxéDá·ùüä½Å¾„øàåUî3…‘¨è£&Ûõõ'ú ·ždºµ&ÊCUb^ÛA-W´ð±¢=äÃAÿÖóŸ«gäh÷¬.XëO|dÁVV/m¼Áeeü¡ýñ¨šà\wöóÒ;Ÿ×fõ!À錓Qï‡Ô˜ñä"<èÕ%¬ JtËPÖ´Ÿîc™ë,‘sJ“5wâe;²aŒ{Á W´/ø± ĪKq–ñ g°¬¹ 8Íõ#‘SDãñÝ$ Wc0ÞüÇx«cîìn×dÀ–_=ï"u‡ ‡®ºkRô(³ Í+—ØŸŸ+â2 Iú›ï'‘»îÈK´l¤ý'½9t$P{<«Æ%Ý…T°¾9ŽÊ¹GÛgÜŠ"ô¡üôÙùÅ–šÃ×é|@ßóFukÃPÞ×ä9|¯Áêpªñû %l±Æ‘Q¶µZ6vü—d“Ë{¬ÊL«¥ÿ.„ƒš“FÅÎ6Ýôö~ž~ ádû’:B ûžNiÑ=þww§L…f‚#|13Ò©+ÓN&]ŽB¹ ˆÝƒµ8–›´¯jÜ­ú°ˆÐ_[eóÍ(æCÇ°ð§úõ ¾êÆ}ËŽ\6Sž> Ó¿ ¥¿¼þ%DÑxù¯#¯1€[Ò=…¶zÐ:·WôªT«;ç6JÏk̨έü¹E_» ''ˆF:¾•4EÄ[MBŠåfSöwP`¡"|†‘‰‚wö Ë>ÓQ‹-œÔÎ;¤|ä¯*’r 蓪)…ó¿¡~]_+â"Å&‰‹­Ü5Ðo²ëzôœêX¡’&)à•fŽ¦²*£‘¬ øy³é£¡Ãç/Å­³Zš,¼+PýŠé×u”lêÉÛÎyú4œ¦ÐªÐ4@Êœ÷Â!Ü; ñ±È|_è}—‹ï¹k ?-¼…¾Yd–ÒJ—<ê‘{ßá}¾’¶óÊËLú5° 1\Z¯j UäÇü¤ Y;‘"A-¡¸0l-ß#öÍoú…â1Î7gÊÖ9'š|Ü%j/c®êÑ‹'ª•©‚P#¸ ñÆúA¹­‡îà8m‡Q¢œ°°W‘"9pdžzf¢üæã,}“ÿä\Ÿ•U úÈ”Ÿ´b£›÷”r{iú‰¾ƒ2ÕèÐ%™¢œ­÷{“ M'¯A«3pçii®$i|ÏÜݲàqÄ}‡xÍ‹U$Az¹¶ÆÀ cü®£"¸pc÷ß]ŠZJx-aŒÛÑeº²éöÏÄ+eñc‰.Ј %^s0ºtW; uõœJnÝüÏšÝü¯\Æ lzÈœgŸÝc“…+z ž V¹cßjQ5©¶åk¼I3H\îäÐ r¶“"Ž`Áð”b»&5‚íV(1ê¿*¬z¹÷añ!tP&À먅)oµÜ5¿”뼎07öóì„r× ØRꉫ•F”ŸEWœ"ÐmHbx Ù«™ñÍ?ö¥µ)³(/…ìX£ø¬-9õí4¹;耣\Ü´N³VÊœUŒU!cÆÏ{ö¦‰ÎÉEò-€¨ôð±mTÞ0ORî×â×0és¾6ØVäs|‘¼}ì!¬L''ÛêYÞèû$Ô:l±tû áÃÛ ­O8÷"ª¼—q… n5¡0°9X‚î‚Q, J}ÕÆ¢¤t˜ˆF•®ÖQ¼K¡ï§épºá`ïsoK`T9õ¼\„ÈnLQ©$X#J2ëaU·•ë 1¦jk_™Óžê±r6Ú«>*-I:!óÌÆ Ä(Ìs_ gMÕ¦ÃßE“Ë×Hå”õ{Ò\‘8ÐÌñ››ÓXìkßcŠÝ—äµöøØ &+ÁŒOKy X°y´>~EÄË›w®.æÄÖ㡾= ,Y˜ òv8t³s“8$ŸŸ|ŠÜøÉ5{¢¤éoÕýùM,â#»½9¤z¹FJáܼᤦaQ.6SŸÄûxäñ~ÕeŠ _v.)äåCê-‡A0@‹È›Þ¤‚`¨bÎU(‡ÂòôIõiÒ;¾ð¡3l” ¢Iµ»v;òÛqúsEÁ蛫(-ÞpÚ‡Ó¼òjYr]]^êbß2ç^“ü™Š8qÿoºioÆíì<½Öì__ÏI·‹ +2 ç)Ò¬E\òÇ o٠­ö÷àù®áñ~bÉùÔOŠÖÄÏ«P9øæ8FŒÅR£—N_ Øå{“}˜ã‹+*BØ vpÄ0dJ¹­¨ldbúü¦°Ì‘ÿÚ:”ë %ŽJ>½aÞf;¸3Áüÿñƒð üQÀØhèèlgcèh…ðÿ¾³ â endstream endobj 172 0 obj<>stream H‰ŒWYoäÆ~ׯ˜§€h(²y;O{$°c;¬ä8È*(’£¡—CxhVöŸO}UÕ$G«‘€éfwuu_ío<ú÷7ÆDn’Åž¿IüÔ5qâ…›âxåm¯üM½¹•‰ŒkÒ`cÜ,Í6}uµ§=9¾[Îï.¼½»º¹óÿãm27‹ƒÍÝž8ÝtæîL?›»aã{ÅR¿1Aäf™1<ß ÒØ‹6wåÕ'çïý6Êœ?~ªm”â'sʺ}¶»Ðn1rÆC% Ÿ*eõ»­ï´#íøNi>Ö]›7Bùs×Ýiû^íR7 ²,ÛìüÀ5/"t­¾¯:>öõÄ‘%)eëv$¦ÃXÓ:K™ã2½á-vG,œø‰-÷ßÓÚí;Y1ž‡¥à~ËâˆS2` Fnê‡$9# )E¸sVµ8ˆ®Æû͘káöˆÃj·m®ko¶çLªIiBßcÝÞþM8ø±—íXŠ,ú§XŸ© áa¾ZóýcŽrèÛ®oqÛgÔ«þ²M3§¯ÅW½˜†v²û;³¬à°ò±2 >ÊÆ¿X,4Dn-'Æ\ZVcr] Ž ãxúæææ|>ƒ¬¨ñ;NçÅ*XÈY(ž7ïºv¯8‰=%Ô 7ïoßíÈ?oøÆ?ßÍa°DAF.}Ù(ú¿ƒç✿ñ×øœï‡†Â"#Ò(ö\“„6@î€ù ‰P¢£¹ü&‘s"åCN‰“?ŠÚXÿM†ÛíüRãîœYWí6€OÕ@¥¸×Å ã»™ŸÎqI÷€iŸÃYG˜Èç3˜ÍA¾?2»½å‹£Uˆ¯¡ø‰–eKS2—Á0ëK)Ì@Ræ}9ˆY) Ü$†9=Ð;·w¿|mHŠñ(ŠOÎ;˜ÊsÊjæG´tcÄ´»ÔwcÎJ($Xó±o«¶¯?‹èo«fDå Ë(X"70®O›nvaìú^fÙ¼yÆžsE1ÎçÂåœçf ÄܘbS±ý†rR0óÇŸ!ŠçŒ¬Öí0R‚ã„ï¼-…àÔ0Ð÷]TJ¶'{åDÙ€R«~µ[“!ºAÑÖçm”Ž*aÕ²Û+eü‘>ÜŽ9tׂÇó¡.Àä (¢ÀL ”4Š4yúO6ÂK†ƒŸ8¬Ôt‘ºrø±Cbˤ¯4L Er$VirËiÌšJ:Â9Iœ+í|a®geVf`§Æ÷ûBv ¶Ó(›£(\V «è-ʽ'å¦3½IŒCÞ¸m´ø8¦rç¿‚Ù R7ôR‹ØÂ^z1v —–¤xE1ÌŸâÆ'£’jDè< MéR É îÕu£|^ªŠä ʸ°!È.G"95Õ±¤ âå8s­+?«oD}~¦&çÊfL|4˜”+8(6Y†r./,Ñq«H¶ªÊJY+8ÇŒT .[¹ g°Ìég…ÛÄ?Xr‰Æ»?¢ú/è¡mcœû}Õ”ƒÌó⚀ÊHaMžL1°¡j6hß< õ¨™šön>ËÇ쨕Yù¾O†f6Æx!‡ÕÀ;• p¶X‹RÒ(Å oç0ËmÔc«¬ï=?€0½­„¬a§¬¬Ä„33kÌ‹¼•Éƒ'|§|êÇbí,•¢VúcÅŸ#~Z*Gb>|‚ɵ WÂHRLê<Õå’(d¤Ôùü*V‰¦¬î÷-‡1xŒ[ ‹j•fkàƒávôTK‡Äœ0ß]ä‰e™¢'lAîg„š]”Hšv[>×Ïéhlžegߣ§ÄŒo¯dþtkÀbçÄbht(ðC”Ñ–/Ä‚&.¯…2è0æÊæERH%PhF0"{öãðZ*Ta3O°b2ÿIiW‹}Æ&3~Lf¨]: T®Ðà&¼k{ZõÌü˪Á†Èœ[*2\Î9l™‘ÃõyÁÞÄlq(¡@ñ<¹ñ­fLèà«°BI{ÕOÅØõz„³#&ýƒâY·êVIdlÖ}q°ï¦a•³ÎÐ!·rR‡/ùÁË^Ä-€a^VJ&Õe^2ÕP*ŒÐÍS%íå÷dÄk‰‹Çª%ï²wi¾³WöE_å«æR6'N†»Ex–h¬a±¼±a‘¥V[Û^ƶkwóÕXxé Ê«šøx[±—:C®ÕíúƒÍ£I ýˆ^]}±IT<½=~n® BjâåcB&Ä‹ÔK)¸ÖÉ¢Ju”"€,‡ Jž¥œš1jA/:n´d­¬öùÔŒò}ùEIú’›âÈÐcSßkù lAnÓ o9¶äjX)ÀU: ˜#f É Õ›´Ë¯JØ" œ‡ ‰.5$Ô8Y’'à°êgå©Ö3¥ÜÓ„[ÌlÝbÒâ|U#oK0㊓Ý"ø b&bhè5b4’(“Á:Yèü kT²•7C'³az|¬l5Åé¼}­Qóé!™øwú4ê}"ó²Oã®EÇ©eéÈÄEb¸(ô¥X°¤­³hqP™9V82kÍBÒZÇôÄLRÏ\v]—Ù0 Z®QfüÌÇðŸ½ÙF ÓjYÁ¼QT79ÃÏ z)‘à‹¨)k½6o„à"ï :ô†N§‡jåÎnê Mq…Fˆ¤!£k–­/o[ÊÈ Žcó/$»Í©£eQhœ ÝóBõ¥¨N*º¬PßY6öe+)ZûÑÿQÊ×m*é>_Sà»i–ün×¥3š–LµðÒLEî¤ÇE‰¼|í|UJ3§²«ÓãAÛ=ÞÌ綟²Ô½BfWxì †_è¹a’]boý”dùu„Ó"?^/Ôߺ‰ÞO¶æ'šÕg§[\šÙŸ¦¹Î¯N­Óqg½‚Ï_õrnÌqcßå}?÷tüÄmB·t'hœ¬ƒÅEä~ã»™ŸŠó¿§r€H¢—U×—Ã7ó‘•W£ÀÍ’À>÷>]<¬¨Aì¸g\¥) úØÇžKÕQðˆŒá‡Z¬ôÅ#¤OЫ¦>[TÁvçz¬qÇù ˆÞÍ^ø“á„gd[¤§ZÚT9Ý—Ɖ Í´Þ¿s Û i.Lj—³þËp4Žð«þ½ð燫™KÛš‹tœQ_ëLW9òZrÑm “Ÿ$ ~\Jàã‡nƈûýÕ΄næ%zp¹Y‹É|:í›Èù®ÝG=?Hœr²÷ͼâMFè@¥F³‰¼x¨d\Ǻ Ò’Â)±ùO»;M>ÜW åp¢Ü‡üÄï¹™A¯J!@ømëIËQO7y¿…9°”ð{jEÚ´ƒHKžpbRqkÓÄU,up»x QE‘>…æ0ŒQ‡óæyŽ\(›×u¹FYƒ&‹A}/tÃ,±ñ¶$ÚxMãzAfòž0{”§*[.ÚNH¯çRÁéßM7ýãUº&J¨ü#ú3Âè­F1p”fK}îm¯BQ™®!ÓŠÝe¦glnw±ÐÀDˆŠt.p:3³´€;V”VÍ,5Ê3 …0X2 é€Í5Å™éyˆ8È5®!\<]z? endstream endobj 173 0 obj<>stream xÚíµUT̶­‹Cp làîîînÁ'îîî.ÁÝÝÝÝ  îí½W²öy¼÷é¶ 4ÚüFªÞkŒªš$„rŠÔü†Öú@k+jzz€ ´=€ž†ŽN–„DШç`jm%¤çäг³3D€ú>þ8˜™8˜`I‚Ö6®v¦Æ&2Aò’Xü–@;S=+€´žƒ Ðòc = €¢µ)ÐÁ•ÀoaPøg†=@h´sÒÀÒÓ M ú@cS+XÚ,‰[YXÿ+lèhó?CN@;ûS²Ù$|˜4´¶²p`ie¬?Ô€^þß°õ¿q´°Ñ³ügù õ ëYšZ¸þw‚µ¥£Ð mm´³úß©ªÀÿò& 44u´üߣâz¦üVÆ@Ý…LíEL]€†r¦&#= {à¿â@+Ãÿmâ£rÿ²@+ %(¯ Kù_=ýטœž©•ƒ’«Í¿Wý'ù_Lÿ‡?ªcgêФû(/ýGâÇïÿ|úþ¿´„­ ¬ M­Œ Ì,=;;=WØÓóAÌwz€©•!Ðtù0LKceíð1ðQO€‘µì? ýè9­Ñ¿bÿ… hú?Ðâ2ý“üg˜ñƒm­€†úÿÕè°h ­-,ôìþ„X´6@; Õ_iìÿ½ÀÎf¢ûHÕ³ZYþŠÒÿwô%x´±p´ÿøpe`mi©÷'  5qµ1Zý ±üË©µáŸÐ‡A{ ={“?6­ÐÎúOàïµðßÌüaÔÁùÏ8ó‡E;à_ÿÔÚñO˜ÿ)©©Ó_ví?šýoþ0ktúËëGciÿ±gæ«V¦aûgÏÖMbÿgKÓÿŒ²|Ú:êýé)ˇÿúøC2‚èCCè}¬/üobý(„ÈúPýC%ûCûÿC›—øCêRèC]ú}¨Ëü¡uÙÛ‡ºÜúÐSøCzŠèCOé}ì]ù}¨«ü¡uÕ?ô¡®ö‡>ÔÕÿMì»Õ·Ó30:üÇyýxªÿ};þs€ñßþó(<´N-û‡¦þúÐ4øsé>¶løþÓ׿ðŸS÷~ÿ…E0ù ?ªðו§û(ƒÙ_øáÉü/ü0õ׃@÷áÊò~¬ÝC~BäÜ×6&yþmÏIw/Õ­Gí*UÚu׆èÞÿ©­qîæ„Tvvm¬ä‡zþ@ÆÅàqŽ™Ò>ô !H¦S}OZ «šHª…rp`-)#¡r²mISðª3ò8ˆÕ)/³`˜fÊß—Ö펨Oy0ÙñoZ÷Ñ(íŒ [è û¼'ÅùÁÈH5ïýÃU|icE;Àä/…QqÿL´ ª ·/Â:3˜“Â!ÒNçT-íj„¯$,ß× wt)uLò%– è.âò¬Ë#¿=¸½ØsÛ%㽿nøœ{ Å;äDªh‘k@"´˜cj ¤¦M£»Ñ#Þ¤+á÷‚%²áýñîîÈ—úß³ÐÖtùÉL€üÅKV©Kî03³_J²_ÓŽ?ŠïrS Ê•¦jCKCîg„Šôˬ´˜G ê*Š5„ÁŸBQ…b#®—ïŽï—€If#q ÞœLXŠ xw=å [:î½J¨bDaDL('§½¶zŠÔ¯åí<Õ£înœoŲ§ìãÏ–Jšµíý™ÚŸ“ ¡Ë2~([Ì]À|=WM3i\ᨠ€ãô#³c‰âpX…e©Š6éÁ²ÿJËIH%¹i›S$•úã$¾à¨z³áˆ,ZµH>Ém®4AAJfMÜõ½„B—_×t„`È¥{ÍkpÔ`kØO¢(ë!†Êþ’òò€•aÛüû&A®õ(ý²Å£khü &r£ Ðó¸Pýw°*º;:¬”=ÙþöcŸ'VHm@Œ ¨0üF;ÆÙÈNÄ„AÈõ çùÒr?¨&‰VÑ\…´æÖt‘a(ÇßÒ@‹®ÛüT𛽠ùn«]ËAß×>³ÙkYÑQöú’ £”ûÌ#)‰!¾.ËR”µW}æD-CWB¿ð+Ó“a7J܈ —Æ]½jè¤NÊ¡Q†zE>Ç;qœCõ™;f[ãLoYakgIŠ‡·ë¥ANÚð”7$ûV¡º)ŒB4Qü¼¡œ nžz‰É]€cš™”ÑÖâýPyÔî:Óì ô‹ßÈñÜR ͬf_eù˜Ç$}”s©eÓ œ|Lt¢©sGD$ôkÇÍ´šŒ§g¬KäQŠG'¤p 1¶¤{ÞÜÒK!\*€Ç¼tv¾3r6»F[±½y{Ù¸qv•ª¥Ú’ž¨ˆUPrŽúp°=ÎüUhyFìøô]7m–ÚÞUAÿíè~¸ˆ°wÎ,Ù§$ áÓå‘l‘Øw>õVòrn;‘ÖÒçPD65HåoÃΩ$ÒÕ‘ãÖ--ˆ˜DŸž·ÝnŠ®ê$‡òRéÁW¬ÀfS{—LnlÆ\øÜÃ3îXuŒ_%ýãvJœ[ö±”f'¾d®Ì8yôÆeB´JqcÊ!’åòšº×ŒÔQ9š‘œ‡Ø°õã]A½å“q8Á«é)ÌñN¶9•“ÕdZ{Ö»RR冓ñÈ« Ñ&^5`IÃð:Cüå+Vc¦‚VüPpù)£â󉲤¡ô5Ôų-¤†ïe½¡BF}flVȾ²Qg¿“6}ÛVÄWÍ.8=„VºAÛüëFÈøÂz\ ‹d²©Ã<Úv°ËDo$gXјG„ó •"shð52þ½ƒå€gQKÙãD¤gs6«Á±–cIØ;^¶!›˜â_9À½Áö ]ô‡Ã[ˆ’y—*HÔȜɒYdÕ„ÈïSÂñ G õ¹…FãßUøÇèå¼3YL`[*0^º×B9ÉFuñX=tü£—–ç{ pòBX„#Ççñ bZn(SÃÚòí@nL•ÒµiõéØäeÆAߨ#öx%;£Cb¢,‰ i+·M Á‡X»èÐÓ i®ùw´u°ÞdCå?Ùî0º¾"èÞEŸ¤äÁg"ý(ëíl4DY89:Þg¦,ÓJ[y»–*Zvçì}ÈšäÓI¢'o'¾[LšË¿t¸­A~{ïÔdøÜä2¢Nüõ6@w>ʾîjåÙ5 w=à›”oî%Dƒ±Yë Žÿ]8ôsïÐ>sÞˆb°"}õ„°õU‹Ú´ÑÜàä]vOïUSŽ´¡¯ƒ¸AŒ£ñ7ê¤ùáÆV|LkÈi´>†‡õ²XƧV¶ì>Àçtë ×ýòŠe ;.F ™škEó•½)Êɯ®Zn,¾ýìëæ›Öå&9ÿÕxëè†Ôñ­ÑÐ6Có¯‰KB*ëûÁvÚ}îÀ‰Î,V÷½dõ'ñ ÓHD\„\p*’Ôkȵۮ’¶yRH¹kZ´%쪰¢·ÄKµT¯“*hoßË:§4#|H| ­Ðĵ_#`› êÑÆíMšÏêgç–«#ûƒŸ[-™.U0òìoe<Ç…¾ßRc¦Ùð ãB‹½#qõªÒÄ-Kýؾ%͇zœÅ@Ó„nœlRC¶åš ˜I¢íøë·Iã/­6@¶±Î¼(šuæfÉ(Nõ7;›Y½¹áßZQÃgà!]vtŠ‡G 6ÔÔèÁë®"!¢J‰õ4ƒë“[ö0-P3>393Hsþ9dÁ"ØÌÚ~zËi™Ì»0r>¯]_ÈÝBÚÖU¢oª¨ëΧ¡–ûF] #^›²ªóçŠweò«ãKCB“#**¬[øµ¬»í¥áÆüúOµC®ùÌ]èÎíõƒíÎOÎQ«¡¦X»;ôŽ«g¦î$ãØ+ûý‹áysΊIzáÚªqjn¢¬G›ï¬iïÎÂFpW-$÷T_ksêö8FÆ|^]ƒ‚e™ Õy °§Mj;C›xCôù"a욡̼g`7¤ˆ¼V[§ !¸§0Y]îDè­yÚÇ´ܸr3P1™Å·ô|þ”ñâ«PE /ãÚDÌ ?ØÅÁÛÂKѦ%œÈ-ÃÀ fìÚq²_`»*t $ÊX» ù®[)0 ¦«úËAPè¼ßÍR͚Ѱ$x6èB¥p“Cå•öÄ°ö o-¿Ùs„ÑÐuí2¸ù½ŒMٮ܅] u!¹UÞJžf—™ÉÎœ`ßvïá}˜"'ÔÈÓt7-»ªe’Ô ìûCg–D꺽ÆÜL3rSCð‹R ) ˜*.H$ûÕOm zk qßo7n\%J`Eê·£°ä7ñGB´}Š¤š5©O×MƒüTEÍ>QŒ0!‹×!ܯC¸ú%œ{wM*ŸkT/mxWZׯ)r[_}H<<ç~PzÅÃóW«`lÓõ²MLñŽ‹ºÜ?뮘¦)lƒ}׺z-ýÔ’hdy÷‡¿{;›Üû’mÜñ ³9äg¦Jä†èìy#¨D÷î—#—Oœ ú¬ ò&ôóQé4ú»×WáîX'1’/¹u ‚>îË´-1[È¥æý¯ÑAîÁ»4Ÿ¤7Ä‘~m“À5È>WàÔÓÊ V& I¢ÈçC3’vc6(©w{ûSSXÖ ¼ÑN[”L)}ÿFnßUEgfW‰‰q‹óS*ùõkF½öj;žž1 îáÆØÜšJør. uÚT†Ÿ$ò¿Ô…\ù(ñžÄ<ß™®ˆ¼WÄòmüÈóKµûÏàü‘ÅÉÃ6ɯBpýLb•x0ªí-óØ£™²KùµVîÙ/¯®¼D€6Þj–OR<‘×S®ÌÜ úY8ó¿Í*ëŒöàoŠhi¹ýÏ™™ö…UawÃ*H¦ÇmÄ+6¤âûsI:E±âË‘X­içŽgï^Q–ÞG?"píf/˜,Ñ3Û´Ÿ)FÝÎ<(Ò/³'ߧ±Þ¶j£¥sÊìawxÒ˜%‚KÁØÅv÷¥zt&Ö™ŸŸw¶ÖGN¹­ãŸ¬c˜"Áæk†fc²3Šž›+ ç¦â£¦Ä€³bžy×8? qµGó8oïû¡ü‘L¥è¯@LºCáW+Õ€ÕJó–œÒ ›ÄÁ‘·é…¹e¹ÈB÷÷Yûd=Jñ„ű¸Pfå• œBp¶_uÂ)p †Ø6PL¼ÒÂˉD¢†éžˆâ –YxºgÌp."¾šB¬înèý~\0XѦæå&Æ ˜c;Ô'«ÇDQÌXMáúý½×“1Õ1É)ªì¾VÌ¡êÖ!u·ÑÏŸHº9˜ðò‘Ù•¯¾-&+ÓÎJUhׇ g"  EW¦˜·ÉU¡ÙŸ {áÞlO kc‹ÁÆŒC©õnî|ùƒ±XT"&cfÝyÌ9 Ûõ âHô‘ÙÜ·eUyõ¡öí¹sBŠþcÊ5=nÝ¢)~ƺۢ4wÖ;CŠƒ{8”×°F›& Ñc²ÍÎÞãÀï-zQbÿEõ[|´qþ¢•%†wÿûù‰ p)·V+þJ§\ÐGuëwŸR\ç[CLnû03ìýK½m1S*9±ØwRëPâCLb‚še©r!l£ó:;OeÇ2»&‰ŸM'™åB`mïý'`¿E¿ 9­_RûŸß]_À˜ KƒÈå%Ž9B¢lgÞn»¬™i²ŒƒK½öзF¼’)Ô\üe)ým@¥dXZ£Œ3o@´5@ jaI¢¯F¸nÝ”ºÙÐ S¸†ºͳ”\K~)in¬9ƒúžÃ‡°¬'=Uµ¼‚UÈ»›¥Þ’RfúG{8‰HLî!1&ñ…‚Á‘1ë4o]!õîq‘Y¿É´é¤šeêúð‹I·‡Q1YØ, -•¸p¼e„·ÒC$ƒ!ˆ);ÛÉEÖ/:1¼„;¿+Ã9FAÝ‘:ùNIiëa¬.:ĸ¼¼%»­\NÙù€rí4¬[o06ÂâYYt±åÍ¿?z©;׺¦ î_!(d9ÌJÔk³Û‚!뎢ך/pÙì³ÏpbU¸É†ý2ù-M*Ž]‡c²-RM¯ÆߺÚ³ ‘^$[~‰ÚýÇ Ilh¡¡•Eµ§B'¡´k[è¨N£%;¸-ÂL8ŸE»‚Æ5áxÆçôUvºÅÆ%­×ô —¸ñ¸‡Ö¨øs¾æÈ"Œìº@r{s¥®¥a%sgŽ@cþºnà‘§cSò…$Ã×—óì©6ðœ 1Š—öZŠ>»é~üWŸ¼¦OûsÏ᧑_P¹=SmqLð…lfNœßÔ,rQÊpdøÁž$xb0÷‡é'×nòªEu2vîÝ#Ù c¿¼¬,={3£ R̵@¸ ©÷rSf¼’M;%æ¥d»ePªÂ‹óO'JSÐÑÆŠ ½T'æÝÁs« ÉŸ@EhžÀ·M‹é» ¯dWO` E¢)• øŒQ+n5Té‘/¤~a¸î_3Þ­ÿY 1v­óÞOs¹ž%”@mËÇé!~Zä#ï£üö¤6010E´¯«EE–H!{L^­¬e|èîάù[Ó €@˜Ávòys½dpÖ<¯ë09^ÒaàŽûõ蜱 iñׯK† ¤”ZY¢úþ”ÜÑú¤ ËÝÂÃ=Vkóyf@ó>f¨Ô<¢Ûˆí8´¤fÒ”'¶7G½Œ÷Ò¸æ DQýri®³ÍV—Q˜À9”9È;É›yƒŽ‰xå[&©¸‰ ·Öð˜ý(/UT38”ípSPz°Ä}Ü4F!Û ¿Ø˜e° :·*Í¡ñÝ“…ô}š3Èd={߯:Áõ›œ]æ¥ 㛳‹3ÚVtE/íÊ@X:<3ñS0Ä7òMçȱÄ2GBéÖ ¼`,Èik’,«$Ù€§´¡nj Ò_Jë—­:]™ÜÒ0å©“839ÑA…'dn±…wæ“‹Ô­~¼›ŽÊ#GâÎJÈוkûòÈ+ÜtäÃÅ-D”W¤Î\÷å’è¦ê>ÓW7›^_Ý _aD9Å^Ê® -½™®=.¿º±À[U¨É«u¤ãú-Tðm&—…â†OÜŒŽq-aEµbí‚E%3Ÿt’L7舨µÉ©¤*¿äî±oß–na¼ê‡³Uò@¢ªý.ÞÎ^ 8ÃU%¯;‹µbêXÁf<Ì2˜b™Lni\ªm¿›š¸»É¶eÖ]0‰º=yáÉèé]"â•mñ w ßÊ«ÖG8]m N¸šÇ‘ÿ^^êðëÅ©¢¦¨U%ã·—ûœÈþœŒ§ß´U ¦Ô™Šk¨Ï9™‚!ÐFU+äù8¾P9y]ø ÞpÃß*Ò¯«Î4,#IÎj výCwV8(ו£ÕïæXÂZäu±ëZºiû-[HCzú+»¯y [ô×$.lŸòÓ-1¨ŸtH’²ø¹wü—çÕÁ‚]!îø_!Æ¢!, °t÷@y¿—h€Ê è‘‘(~Í%•LÖ ò¼nÙ©v(û†Ú±ÂŽñ³€€_ðø“‹oC}(|ĵKQÿT>éN5ÎôZ “ùþªþZžÔÙ &UR€ù` c¡zY6Pôü/ȶèŠÈWÓÌF}³Y)צ²KsFè߈‰4µûíV¿{…rÚ¹_¿MÁi,[­Øw Þ©Ê@óÕâ ]1ObV€¹eåoãOc;].?EÁ¢Ò‘•'ÅIœj®ÓB€sô‘>ô²'qunÀÓžž½g£åk N᫪Um[ÉýŽš‡VÅS¾ÚÙ£NÚo•ÿƒ[ß-(e üŽK¹v£lÃA<;RÂw(yWËîÐ{Ž6>÷˜^—´1»±…‚‹pçÓ‚“àJÅsÈ{¹ÁôˆOÿY’Š±ÿ/þuÿ„]3f!ÃƆè0F<+ò £ Òy§Û"1p,WR÷mÏC–âLu°¾“®©m­àD!Ó9?%$Y‡OÎôþZÒ©fl`´èÞƒŒw¡!Ewbsž§,+ öþŸæuÂÿWµÓÞƒ›¢–T%¤V£Ï(ºü}|¹µS^É‚r YÙÂp $ve *õ*œVlå«?a˔ٱµÐ\-$šRõHOQlOŽ,º/Oó®Þ äápi*¢ÿ²o¸X8sæ:üçþôÁ jº¯*”Cã–sT i†WtµÜPŽì<] áâÌì9ÔBå9C‡ehõa8hÅŒ¥ñ8¿ÁçqŽtÐѯºo×m0 éÚ2L? Æ~ÛƒstJóáW³·nE}EP6|ŸÇ¤5ÔôdÁV#ÚÂcXŸ(½©œÄм4<‚øÚ̳cØæÂÕvBŠ^YÕªÑußæYÝ‹ð¾óX0Qeãš#çS†â–­z'ÍEÅûd¯héáß„Œ»¶`£?7µ)üGªnèÒt¿„æç¢@Z·þ. .7:]Û%Öw뤦kž‡ƒl¾Û,‡õË<“,K<)¼jnHAjù)ž³¨4ªtiÎØp…ç}‘o¶…QŽË¨vŽ¼Ów-#½uϹrº×·Nõ\±Æq+$¼e·Ì˜0¶÷W÷ý#8ß©Oq‰~ [à­·³lÝDLlg,Ej-ùÉ`Šå¿QBS¥X0Io t]vÞôÐnz¢À -7CÅ©pu‹ím±›:&®Ðý¼(64fÕIÀé žF 0î¬=‘‡¹oìö&JZ¼p¾”ÜžL6lDJ –«D˜ØX(¢h bЗoòÙÝ|º:K½¦eª ÑZÉRÛÍ›OÊìx¥NLwo‚˜ìˆ§×æ번º/øe|n"Ÿ¡Vø»r‰ñkuñ±þå¶×„/—–¨q¬Ae\æ%M…õÊûLÃàÏ¡ˆš«×»8_V$»sÒáíƒ%×ñ1Ús–´º @Kh­ØØwçÄ9Y4w¶äŒ‡-¾›†W,˜4¡‘7ŪMؘ†)¥sG„GÂJo^k¤¯èNƒ,{ŸR1ß•O^Ìð†un sà '”6 åPK²pKø¦Ç2Äìdz}\w·‰ãî˜{ík¾+”‰¸!áÄ‚°…!ÖãåôVZ“5ú q2ùü‘?§tAuÞH~ÜgØ÷ÓixÊ*f6%®ÅxéµÒmëMPŒÀLìZu¦Š4GªÛ•§®$³@ f~]B%²˜§lÚõ)EîÎ6y½/·„.ÙÚˆ¢¼`¾ƒÇðãä¸çP[:Ø««øä·d@ÅòüûÛ;^ýå{ˆÒ…hÍgî¹½ät^?ˆñ@x­ÀÞ5íÑ’Û'´. +(›EIO ÔÄx@dYª¸˜ü%Òãý…kW$‡QzñY›w]/u^í>?blzNœïùÂrBŒ-³¸aº_`*;ÍjcC¹z:‡ÙÜÍú(úsFyCט%¢+ºÒcäá«+’0lºÛº9ZŒ…#o¶õ·I™¨>ÙD‡2ÌêÞY lJÊç¸ú7éx}e˜¶-!¹'ׯIômw…?¿Ð¯t*=lÊv_m:„ªqÈüŒ½üÑGÞ¡†ÞH‚Ù›Ÿ5ÊhOžÖ!-Â1UC´å6­¨ó°ÌûD“ûB@…Ò¤÷£ñ)µRYÔ4¤§¹ÆŒ-$è4ya|û}Ô„DM„§B½ÁVÈ=?‡,b|ØŸÑÅ,Æ ¯¢D’=¶Ó’ïWŸNÊ# íV楻OR]²oûÆ;–~ˆÜÏè#GSÅ-8Æâštœ pc²ÒQ‹;³Œñ´3Þœ4¾¢ö‹x˜ÐîÂT¾ I‚GjÌ&²õ`ˆŠ¶âŸ‡ã˜"˜úå<°žà$/he£²¨6bØéF7¿ªZE˜‚ó\Ù/:ö0Ð\U;Ú.‡® ”âXµûçüOWØe5ú—¦uÓtt߶p±“n·´÷ *G”mݸt>³šv^íªÅ¹ÔŠÓUF%ý}¿£”p <ÿ´1(ˆQWìNöTý#‚°< n·¿ ›ëLŸÙOöÁ†r¾™Ïmƒ†õÀÜësXò|þL Ž“{üµÐf¤/h?äì œ\y$™ ß’Jö©´™-ƒ¢›ÂwÇs­YfA,“ñªý€zÂ"hrÌÔÒ”·×NÇ'™c°;W²ƒR‡Ä! ÿVö¼‹{MÌ×o³‹c*Cð¿½cù…Q#NSè0fÊsw¯µ[Õ—>=ÑÊøñ¨“ö!L> “ÕºÛádw³e‰Nwè,ÍAÔ•Ÿ{/w9×~{g÷×놽=; fƒy @(²4ÞÀ|øìÿ^`×T™J!Ž'~Ýjêzg&[03Ë/Ìø+¸‘Á¿CJ:17(9¯<Ô ]yWÜçÊ!0ËÞÛ†W»½¡ùÕž«X7ÇÎ3×i7c*íî¢zÑEznüzè~R¢Oé±`×Á+˜6øv]ù)z"¬¦‘¥ 4×$¿j]Ð]Á˜mÍ#,i p¹ˆ “ã´Sû}La,[Þ/oÔ;nÙG4Tøn $cÇöOyhy1¬:ül&Ó÷ü­fìi“ UŸoYÉÝ&ßg]¢ó7 ©¾Ê§à„ËæÇmÖ}I€~ýª®ð¸m ª ÷¥^‡zËñ8×l¥ú6Æ^?Ü” ÜŸ‹d¿ÁÁ©Ä•÷ó=¿¿m ;ØNБÞ6UT[Ý£ºAóƒªI–Ï¡)¼EÕPjNdñk™ý€Ä׈¼ Ó{/b_œ•5ù7íXÜxºa³ë–dõÏèµns¸‘SEâUnŠmo7Hå §Æ â€ïãfÂ3¬´M ³PÒt°±ûjÄ’ •Qò±‡ÖÞp¸ÈÃ’•œjËü‚'<1æÁkîäi¢±ºVx¿3]ôÜÙàœ?ŸËc‹1Óu\퀟w­m¨VÅðÁ–5Ñ &ã«¿@"Þ“×7H«ï}? û¸!“UxkŒP¾(ö"IpÕ9ÔÑ[ÈÍÁnùllžP‰Ô[Ñ {lh76:_âó1Äx±\OZ>Ûâ"Öl•É%?Œ¹åŠ…êi#¿ršY0NÎR„Q¢¥™Šc”+R6B„×,ãµ  ù*Ô8´§9ƒF•˜]2ÂGÁk}; F"ÂŽu`—>¬Mk6ƒKR]J>àÏ·V°¸¥âË0…R èÂDû´ J=Ýȶ_ßÅZPRj4ë›sˆű"±c²î¹õKKA¥i 0¶šc5r±Vûsþ¿ßãùÍD)kŒ“›)q9ݼp+È@5™6ì‰ B̆=ð¨”Æ6“¢Eàùfx9è‰ÓP%‚²HûUøÒˆÃívnëªAzµøiPoŽQàÖ‹¢_B&DïÏ•OB€͘²Ú9Xþ5ÅpäÐÑdFÊÊ9ðIŸU»ã_á¿$›™žp˜3"Lí³MÏá„^e¥=â÷|÷ÅM·oƒg!µürðû¹ú­©‡•ËôWÍå•÷8üœCT´¤¬Ë_»½'šËûÄZ *‹`¹ÌAX„„ž&ÝÓ©o‰Œ fP F{_¿?"ÚRTO5,LªÅöˆÇmþr¡]W_ˆbÀ­žÑRm¤=ÚKlHè²|>ã4˜!œ7 ‹k>ñ/‹,—ûé¹M›TSó´82áêÊÿmŸÓ‰Yº÷7^«ˆå¤yxJGJÀûÙ­°Y¬ÑJëgmlq”ZwŽê[ÑÖÅ€ØgR›ú¸€>²qKrPfø"+Çn»…å¬Y>S±€cŒ¹°ž­ÛÕ“ %K#M—jÝj×8v™™ùJÇ“ÕùþC wlhÅÏÚáz›LŽy$ÖT[2ðr³+Ì[ÌõPq7àAMèÚa$(µæ“ËVûI š Ï}]ãÐ'GFÂ7ÿîU<Óg°<œFÝÑó ß9Á1³1V»$×ÕaÈZÐULã´Ä 5ÀïéÄ(Ñ<“p0Îs|uKÌT.ö´¯_V}òä¬ë]¥®H£CˆZÁmßV’½ˆ wnšd™>·±0º«ä'O' *ÜJËIb„Ð8ë:À |/þ¦öØ 7÷U§sêY-•!V§,lÃ'Òº–†μV µ£)hðŠ K¦=Æ[ì ×ÙÏcg– Üó<Ž`Þ­¸—¦~Èè$vuŸP†O)w¦‹œŠÑú å€…ážŸØ }¡Ôà Xø@¤6 u䇿J"5/Ôׯ›áe£øÛæ,¬ÿ2J÷/ï7’˜iâ…ÛÒe?+àìQÀ\$ü¶µ$ÃJºƒÆ˼BìÞŠDîC"û<Ý6ECxÅTì’ŒÖŹËJUþ²»G§ñ\¹èΉî·4ßu„ ¢Á^tD¶¢¶1Ä^œ‰Y=¿œ–Äö’8 &Èm`·Ñ8ûºó¦ìÖX~÷Å \úy¯ø¹aßy˜*"°žr>þnc@RÐh”Ïü!AeàV¨˜…a[\§ —cZü)ve$©ÉH5Å%Ú>õt£ešö‡m!Œr¹£C/oÔ$­wÀ€ðöŒ_ÉWc±jÅ™(‡Q,›êïH¬61Ÿâ!Oz]cÉOÞGôø™œA|ýÊ‹ëÎIÛ˜¨ù1Ë!bJÔŽÔr-U¸3 ›¯åýa9õwX˜ð£dT;»=E"épjëȾœîËïD³¯ÁÌy6A©jcUKĈdôq¢+¿çñÕvk”\‚úáºd]VqxS”Ò·kW‹ aÛ¹éIü⋵æT‹GiDÊíÍ¿*ÈFq/ˆö$h!/4®Mcóc_ô±Q%×µdnÆ<Ìnn:¸ˆ}c•D]?CÇ¡è¨Á05(¿ qúÉ)cå› ªgŒž€±ˆ€£à or¿›k5Q\c.R&¹¸×‘Ç9¬#(Û„¹W¡vDhöUÖlIyJã´D[H‚:¢«÷3ÌjÐ.K~ˆÒÉA‹—pÁÝ™jiüCda^JAã°TºòÍ­„à9w+è-êM«"j©['©"l‡9jÜÕ~ÉzÁIà8CïÞ¬Ïçk =Ú!$Ì確ø~aážC¼xÑGð®P^8E1S(ýIF9’“ŠçšÓ¯³ŠôüĈ€Aü³ñW&ÛfJ¼°h¹Uò7å#æq;mÔ¨ÎNl\gñ3ú6¤““•,q×59Úû2gjŽP²´·ç-ƒ‘ælŸ™Pfç¢.ô¸Úãk•´Ñ½­F~êbÅkÎÎC]¸m9|ŽïåÌ`Ö“-¾Oh—@ñ·D‰V—Ƚp¹ÜH„‘½ùujü%%Î*¦WÆÆý ‘;Ìx.;Üà²@Ñ[a…»Tr»tßåqŸìí“̆ÇF//vé¦X(oã~áó˜-‹½â¦Ôz…DâzücƒïÖi·õPNÚãv„ á¹Â­“–†Ì WsÝxx;ºŒç¶=føõ-ûÁ­y±OK” Ä÷Ja¿BN}¹‚Ú%ã ˆky0,L77xVËè/µ4&ivi3Màß$áa ɮψr×'ò±¼µ1VÌ;$&ƒì½›£,×à~Šögø5nfŠ `5,ñþ®À nýxêN¶ýŒ‘H˜v m»Ú|‹ˆ_›ƒV/ÏF›XµÐdŽh"ö9BÀ& 1 FL¡3®à±û9B¦6-‘bfeÏ9•-˜Êñ6 ØóÙäÉŒyxq^pՃƷ 9c£…kHF/°Èãn d f¢ŠÓEùÛOšc·~$«p2D—mxpÒFÖÏ+꥛žÓõ…ßfN¡!SgæOÏUEdŠ>U1¨QQôà£N9tfÅóÔÆœå!ÃR4 Ã7ðª2ªÏ%+5§/c3-¢„ríLãCÙâ ÃB¢ewú ¡R©ž*k¤A®šhîÃÌ…ví¸í$ý­‡L)ëGø—_‰³ª”{ð„ä•Omg1f}œG«x‰¯v»?5dJÕU¸e澬1¡D@U ¾ÆÑT'ß\ev±‰ñ‘Æh Ïâ:Û}¦EòßÃOüT%ykضQ4™Bñžá1±ü=lSN+÷ÒŸkê™YçÊJàâúŽþŠ(oRF³)À\äH5Zö&,äjHá%YìòçÊ3>±Ø žnÐoV6Àò…‰Æ5“½§ïZdÞñ5«óbèÛ‹”ì\.ù-W5üI‹c=„/lÜàcÐ’ôÈsåÏ™›­x`)žˆ¶&×ÜÉ·ãn[`‡’ Tƒ.;c“@à²é »þQóÆçÜI­ùdЃì%¿*QmTvi‹økŽtãÊ“^°Ï4O="±Ö]v{5Õ•¿ ĥ͡xcî'Š;ј0”óÌý&È é¶6­¦_ð‚H¿;+y F…kóÓã¿ÎB° /SÕÎ|»ì°¿YÒÎ ДÍù ɲ—¡sF¾„&RÞÐzJ¥´i[7ÏìÝÑÎz#3¹-¤Ê|ìÙ£1…óô™éJ@›s‰‹=¼z @1œÆR¡â4««Ñ!òh¤&"¶¥øpWŽ:Àsõ‰…oq,m—¤µ JŸKW!jáØ.‘D¾&Í‹Ô‡ø{j•±™›THè2Ä<ºóðY#Ý<«vjD0ñ=Þ z²¬(Æé–eûW·¡›·5²ôh+úëÊ0~ÖžðNðùü"º{àýùO<|Õ8t3L¤~@”fØ`D¼g ;€VTöü¼µä`=>¬Bщ5“vÉn÷ö{‹ 5þéN-ŠF—d!‰kxdíŒtêEÊN×´³Á¬¹pfq’A HHõàœlKýtS€ƒ}#ñ£3ŒÔÌÚ×æ2»#Ûu’=ušÑVXºŠ¶ ¦$,-åú“ÏD¦/xkt¯ª×&¼8±—‚Wwø•d¥Ü0ϳRÓùñÕëq`{',ŽxÃ7á9c2¥j’’ë×g¼âû,!õ- \A„VÃæ~?ï1ÖÉ¿@;;0Ù.Í–iÆ·Ó¦{uöYy»IRV£@qò%¿É,‰ú¾¤×P JŽ]9„?Áп~Î9š2ýýkÿ/ƒ=3ñW¥*žL8“3É'wZÎ9M>Z2eTlRÊÐß ÎNÈ;Ä$ Cà·YN{ÞAÃóGË×{¬*`Œ}BWÁÕ©˜£S*˜3Bñ]9¸È 2tGÒèõ…'e@ê&÷ÄÕÁ›¬œ¡ï9‚¼½Ç¢ÕS“,_Õ±×茹¯ƒd§„ˆÖ«TÁˆïÇ])å§õD|Îùžd›waumOúmž'C 3˜èMÀƒk_ÞSý<Ü0¤Ù;Ùȧî g€2¯±e“3ºbš»—Ó¾:wz‰hê–¹2ºYî—;}-\ĉ!´Ÿ¡;Eø{þü§M…wìãè:Œ.I6ä`Õe£O*€¡Å¼MŸ)Ø¦Ï NÙ„o¥nõ«íÌ¿ê‚1»¬Þð³ # á?5¬>_ ¦³;ÞV#?®…FÛê_tôÃÝ=/qµ ŸzzkɈÚÛ˜Úvpjµ^zûúÙ“£õàÈOtbÒ,rähLrþì×5ŽøÎîÙ€gÈC,ú:'ÛŸ¹­)Ê&dû*Ö¢ûle æÅ Kò„Ö)È”È&ûÖa’”œáµÝ|ÙàF¿ ;Ä9ŽFÅ#1œrcƒk­¼)îÿÈc<2û^ýJ®døžCt« j3Z ›¿Ü\zœö”#ü]¹ÓF,µHZŠÿwY  Ñ]CZ;†Óµ]Ej? L¢î´2\æ^kÑ$™…´^W>¢`3觊ôj¶üR^9#é˜àbfd¤ÆT`Ž¯ÛžupE(t?·Ž«Ô9M3‡>7É£4¼÷ú>x¸-Ä3;É4Šð^ÎÞ§¤È6ëž–cˆÄ>Âã6¡M>hºzJ'xð³ü¢’EÿVI•–•Ó¨îV?Ýr[^Î\$2‘H!hÝ`òJùŽRÉ0AÊDM/½;îš{Ù¬ÓÎV1›ûuÚ‡æ¾1¹ÍI¸²yòÃPóˆ‰Æè[üx»ê©ÕYq~üM©=¶e~ýõ8î£Ç:©’_t.ᶧèÛØ_M Â9(‚XÖ¦Û|îHJ%د_ _dúeG=Zó9. „u×:±ÈÉõÁ ^g,P®\ tΧÍÚï·Ž·Ñæqöê|¥¤â)àº=îWk”ÀR¤¼MÒ×(Jù¨&»X¬Z>-î"ì<'W‘ÖÒöÚ’Ô!$JÓD›MúN\:[šÃRÕêì˼¬ã4l+Ü]îðl‹ .ðe]ÑKçã¢A«SéŸûî¾æéðê¥~>Q1TîˆBI¼„n¯)¤B‰ðÌ­ ÁeoŠ¿_ô1$’dç‹Þs®×AÓG~™\ÊŠuVü¨ãŸ¯ \²5/°"rh÷“áP9/„¢ÁD¶Ç¸æË,x²z"w+{¹3Oñ Úñ™„´äA ÛήÓ#ž³«_µELŽÃ‘ËsÆÞ뉟À/ˆ:€ev\’3;žÂÞ F@Æ_‡n¯Èö’°²ûtË%ÍÒ=ïf¸ ­¸à¡ƒ.JF8AZwXÒPåÿ…vÿÜö%|jO°\hÚ01íŒŒà„»`¯$"°iõú…;ÓH\Ú¸yùÒì¨4iwUŸÄYgž3b˜J»ÉƒÆk`#@»»˜‡1à[ì†dPºg ‹.?ÓÕw(6•§lŸ;—Í(x:“°U0áÁw×° y2ÿŽï{*`ä'yûÉÇÞTæÜX]9#g#¡R_SWl:ZN›/#úë£å"= s˜¾k*yŸ§³)ºÿFÿM©óÃ28Xó³ƒæ¤'*§^ïèÎ_ì.ýŽY¯ƒ'€úÉé3e‰¥ì¥ûÖ‚§¨Œ ¯†Õ…¢+ˆæ£j_ûb‚—ÿˆÎØéäéƒ]nØì[]‡ã¼ݲ¼­B >Ô-KpœŠðþ˜‚`Ö½/U÷¾¨'¸|" î]¥¯Í×^5>µu\¹e# o0zkð¬¤ìÄÂal&é'Ú É`Pe%I×À„%Ö\–;Þ÷O„ôTáïŸà/âY4.ÇLr­ÓÅ1×|žÊ•§ZE*øL^Ÿêú¿ŒãñܯVf´µ •FéVY6î•`˜&ÄÉÐ,9™½‚êFç¹4eƒ÷+dÖ”wF·úô,=-#|¡ -A³¦åÚkª}VóÓf§²h†÷'óƒ?!^ .Õ”ÁµD…|e%"s&“¼¦Ä¿t¯Û›—LØŽFbÏk$Ýê8#"tµW>” Vî2bƒ«'|óÓk,™¿éúa^V?z¯"!o¼‰ÏšŽyy76½ØåÌJ»urHú–Ôø¾œÇü®ÖûîeîDA! í: ¬œº%‡š ±œðªO)ŽùFe¹ªOa?G. )î!M´ šqNÁ™ ~ÙcM{ž~«µTüºéõÀeþ´uçÓ“!’(Wb…"¡¡ß–pU[˜ 5W>QVñÐv5ÙV]šHÍU˜°¡lTÎÞ(pšé`x¬¼´k(î.„üžÚÇ-¨(=ù¼–¤ô]t¤ƒ|Ö!å÷Z1àìI&xÛOöw"Ðb­¤P$uùFoý<ó^ÙMS¦ÞÛca§w:OkÝ퓶@¾'‰8+ï€8ÍVûªßªt›2¸ZS*#@Òì ?&¹p¸0 ƒµ±çêÓ[ì™!ø¢‰»¦–kƒîÍðÀhp}màyÓØšvPK§ X8_“@)‘JèaÅà aœdÝÿÃØÿÿO,``Ô³s°¶Ô³3‡ý?.¬vH endstream endobj 174 0 obj<>stream xÚíRmXSeVÁ#‰Bš9ª—™:űÁÆ6óCÒò%¨¥‡³Ãvàìœq¶ °uH ˆˆ” ^t~Aˆ ¢`%*"HŠ©9 à ?@ ì€YWô³~uõž?ïs?÷{¿÷¹ßg®ƒ_×MI…arŠÔsa'X dŠ€˜`'>4w®ŒÆ=N‘ˆ“X"›ALßUêì,uvæ¥5Ò¸J­Ù‚’+pÓ`4Ž"$P z5¦a4P„Šcz£p#à?rBü1FGcJ'†Gõ Sá$ÄqäM†SÀõ9¬4h_´¢1ZǘÆäÀXTR$aJ,âùPÌ]ãäß05V\n D3"?šÒßúˆ'Œ¿3(Ö Çh  ”MŽ¥®Áž›S`JÜ ÛõÖ#Žº‘*ü箓㱘Ò×£jŽ:lÇHåXLp£xk<>þŽ¿¿èhÓÁI} Qû‡ì{´†ÿ¬™|h<¬ã;ñù0Cd¾»wÇ\æI¢”'™‘ŠBÓˆbfƒ©„ 8©ÄbË8æ9‘”ž9˜P@8EC#*žÿýýÜÝ©Ø8®\$ pJþÊ "ñ(æí„|>_ÌwEQMc¤~tj˜x^Ôá8&†Åb(t­…BoÈ(Ý^°É3ïò Ç»«ÊÒ|¾<ÝT5%±u÷x"ÿüʨ…Å!…YvSÍæ7c†XºäÊøÕå?oŽJ˼:lŽÞhÎzÿ+ä—,…ñ®–Ý—xßædi󣟄ã}¯tÔì =T÷iϹû¹~À{–×ÆÕ¬‹.©Ù¿Uä"Ï"‚LÛŠç9;øOËŒ*Hr1݈™¶7}â†ÄM&«rÇö^ªÒ`;g•³gx}ߌ]ÓѪK]I©–%’öæÎ’o3O‹õ_™û¥¬Àñ¬YcÑa_äî9­3݃Ò’}«T|N˜¾F‹o Rv•w£È¶µ3^ã¼ýhÞe÷òÖ씩YÎwo.–Sqåg¾9Ô½ªíYÐf©úåRuÍa)žÞrs?w{E§ßÌ#aCÇUV‹œÖ6­ðh”e;†> J»ŸÓ±böû.÷öÁE«ß^ÅŸh—g­,—7Û6¶õ'7Y²{¹•¹ΕTžItüÊnï?ù[練‹Ürû–Ñf\ñL¯—ýóË^ekÁjÅÍø‰Âî9)¯T=Ö”MÿàTŸdWÆýCc,»ÑsÆM,y×k…EmU¹Q_μègó®²~ð‡§õgÍ.î o+¬eó§qöl~Z}åûè ébi¶83Ë”@XGF»n)ÆMzÏþè§õÁÑÝœˆÏ.7~+¿ž0_û`²hÐkÒ…°Û. šÞÉŸQ›Ê¡sL'§}óž²BýðjÍ«¶.ªv7û\JrA[sÇ¿6&ŠŸ!`­òm®»xÇÂmþ´gÚÎnó÷ÁŸ‹ºbªRÐl©ñÙ岕K8=ÞïLßÀqkHNš_lõ”jÝ—¼aùà’aiÎ׸æ‡[©§[:Wî… Câgµ ³­OÚXe¤dVß}É7i…àDGñ¯ì]Oê§ì8îY8a‚õ–;£4ç–#ð¶¡ñ·Ãèýu‚Gö‰Û•Íæ6MF=‘b®]íÀ0d[ëùÎŽdImÛù,:ÐÞUš¹ã£*¾|ŽOIWš­éž}‰í'µ°XZ¾aV;%J_FØ´ ´ïMdí(ªPÇæ[¤Û·«?¿h)!|óûÒõ&Z_Q \㊶é*;‡²ÅæóÍOê á-jÓ<ˤ¯–Ìß#tx0ýaAââ ü£œ†ÈœI)ã‹÷ÏZ×sèõ4Ǹ;k*J›}¿;^0›¤CÖóØMÂŒ:q|j¥ü̪«)ôÂÈ4©E¯ZÒ_…¶- leÁ MÇD¹>%o% ”AWÓÍ ¢-××{¹ž×žÍ•Ù=tç™Ø°‡8|X]•ì¯Ž«Î¹¾ÄëÒË+Rz#lüq.åµÜ`/Ûyíé³~¸µ"X+S|çzsp«Ó®Î¨“ð|L»',îQ-‰ê‹û‚³N…Nî9Íÿ‡ ú_à?!€Bë) BGB¿+LeS endstream endobj 175 0 obj<>stream xÚíRmXLi^Û*&Ô0¨¸xÛšLÙ™9'ÛÇÖÔhE%5²(k̼Õ13çÔéLf6‰­D,-}(¥íƒ ±R»u­h·/c[b"KT’!BÖžò±×òs÷×^{ΟóÜÏýÞÏ}î÷a[ûr…2b ô"pŠ‹òP7àéèñŠ”‡0ØlOJ(ŒÀE ºT @Pé¾³Û§³Ügx §ÇÓ~ˆä„JHbR |%T8TÒR‰R R* `èD€QŒ†2E “R` ÃpÈ“7J—W°Lñ¦ É(ÚàÐ&ímQFà ÁPß gAÚÉ¿aê]q/•Bá'QÉ¿Îé=†D‰)4¯9„2BEAø2HâïR—ÁWö<Å{ƒ¼)‰“ ñ0È+‹òÂÔPæQÒp*QDÁaâ²w-ÐÁ à‹ùû,ùöN‡Ûþ §Äšˆ·ÂCüáý«¦"15X‰ð¥‰ôûæ+äqóq)!Ãpz)œœ„$%½tåbP€á2¨PM{æóp‚¢:”XJŒ¡+uuü€!ˆñþ_xxê® ¸ŽN´&"W$öïÄ¥8©‚Þ"à„ ˆ+â<ŒJU$ qjxqè„ÞÔ¡'„j(e47R÷„µ¥›µæœ?4Ò>jjfQ¹S‰%™î¼®V÷ñ—ȲßÄpZ3‘¹;lžÞ½è_êtÓ²T¸¾6&Ÿx…Y;–eŸ—hbv¯ú°.·¦ÊL™³µ½yz[DÙLÃU›ÞѧFût¢.ù–ÝÉi/7½x¼A÷ëÍfÓ=2›;éŒÜ Ÿ4Ôq#E×ÿs¢€hÞ_798«wÂÍ–U×å-c3Ûr}ô™sG£-áÚñ1!~¦ãNÛÆÜîœT²Ï¯×æ²À¼%©O®4‰zvþþ0¥Ã´·VŸ–xæ¨×yöõúýût­ÅIÏØÚ§­³v&ÖLÆ㔇#UÜ’ÉÍ5»&Xsió­p¶1³U§‹‹ÎO®KYÉ{½¾p"GŠØ·ñDÞEdõÙ£Ò ¶è“@“º 4dLWFØò;¼cû`sLQ^ºÊ,ç';#îO)Ò}-äÛªŒŒGÿH^ø¨ïËË—ï­tÈZñÜÆó‚üœ˜¿u\ãvÓƒ;“‚;M-Í/ìï‡ÆÏwŸõâ_Õ⑇ë´ù£Ûk›ºÂ­ÕbÔ2#Ö¤{#lÊvyÄp¸ÙÖ—áÁš¯Í¿zF•ò}uÜïmÍÏÎ1Ë1_S__7½qyeÁò˜ܚtºDÑ$L×?2Þ¿›)Ã>xã62'<űzîl×hAgæ—Ǿ6)þ™YÃS·@ȉOå™–Þ#. ¾¿öÚµ“¶—¤»·¸, ¦~Qö¼°BjK-Óº+⌗ø‰õøÔ䧞ƒß§Æi“¶²¸”¢#í͵Ý|»ÿÉb×Î>«yâQ ¦q߶ÚÕªš—j°©ºõtK•¨K¦RgŒ‹½Wú"iEy^N¿ùÅ—'¶ ó×d­ßd4带™²3ª’ZbW'ʳ«6÷¹:F®Þpå¥;cðRüh“¾‡§Oüv£o`Ýg?û:%Ÿ³êix>ëΙÛrî_#i¬ÜÑ73P—¢´Ò{ïÐ [Bú>.EYšnUƒÓøþÓ:›ܦê"¦×\ðòe‡!(9äèþµ•w ïò¹'â·Ç³»÷gE&R¿É^i^&[8¥ Y,`Úu*üë¯ý`tS‰yïžJ l™Ö ;“&R¨&ß Ë^‹½üîcA^Ð.·lÖ“~‘`Rèä>ŒÿþR”¡”rÆŸ ìmì endstream endobj 176 0 obj<>stream xÚí’y<”ûÛÇ­aŠìdÄM!Ì`Œ¥„P’²×434š…1ƒÉ¾¯¡A¶,EdIÇR²”%•,É.Bve*”àæ7užsê9çÏçùëy=÷ýÏý¾¾×õ¹>÷÷ºäd¬íT Q„‹hSž¤U…ê',Œu¨*$'w‚ˆF0¼1‚„Ö ::PÀì ¨C¨–®†–®: $œ xSˆÏK$àÈ ÅïIpÀ‡&b<` ]Bã˜H°# 1hE0ÄbÛï¾€-ÚMôC£TAP(€Â IÀE´'RûnÈ ïAà†Qdï¿ŽüÐD_¦)àÓ¤"À´ˆ"à±…ö©Y˜½ÐL'ÿ¦þ)nJÆb-¸ïòß/é_ÇKù¯ΛLB  MÄÿ3õúOoF쿺˜‘X Òï‰E?C_SLe!!/¬/úGGýÓóÖ~P3:ípÆÐBùÏiþ8³F`ð${Š÷ߪߓ0ô'3 \ ª”™È|ÿúrûG/<’€Âà™ëÓD"‚bî“`@ ÀàQèÀ4¬¦Š'˜%óF‚ô}˜0m@ IÀ2çÈ ÿˆhÁ5ÿ Î$ó¿‰9?5ÄObÖ^üI:L¥¿ j¨_ ¨¡"sÍÔ¿ & Fü™M}A-@ô 2ùÿDu¦åþ{FF„€@æ?ª¨Ã ß+aÌ‚ÿ÷D<ƇŒ63`®ÿE’‰D4žôcé™þ‹=0Ìu@£ÐHÐëR/Ê+óALYˆIÑ«rN%V#ÏúTËÚÖÁG{#Ç®±bKºÌ}”¦j·+r„ø9¥ýwÁ¾ ÍA6½¦ŸÂ}R³†¿-ú]X̹Òv\ϱ ,xËnF®ìoz0ô…cµ˜ê.Kw*~š·úlå¦õcû%®72,m.~um¹QZpGÓ¬Clt¼†Œ-–OYœfì¤?:•c²/2Ä+–û¡òÄ¡™,¸]Ä]˜öí<;ª÷ì…Mó×)¼sÎÛ©=›‚ÕanwæÈ…ÙNÉww/º¼‘¾uÁ®'å)|þäš]õØ{¼j(¿Ø™nÅ}@³üdüi8/Ò-­:Bÿ‰ûC¨×Ívéžì ©(–…ÓŤû>‚«CäÓ¢Û®‰½DÆÇpù—‚…\Û’™´*¬roü—[dщ–Å:•×Þÿ:=þm„Ëåá/ÔZ¯5­÷×Ê[KL æ¿Ýoµ UNOÏü?‹ÔŽËa³7íó/wün5ϵr;¥$è5gó9s"ú3›EÏf±&ÑÞCz…;”Uz/ÃSA¥9ÂUœël•/Âcà‚Û¾ýB"pà,1«É>™å×pN<ÆÂÀSËë»6xlwdFzqVN&N¥z$˜×r{çÜâÙø}‡}<Ý9=¾™òÙá´SU°Äm†«óòÔzMΉâ.5[7ÌoXÎ’¯Ož•çå%ç) ¾ÜÜ…ð7‚µ¢o}5Ìk•ØGö6ÒàlwËfPEøÕ°/G: ›-°Z†fW–´í=J ³ó{õy=lÄÑöåm+×StšÐÉs.AM°fš¯èRH†Òk-œžê+QôjÐ-mwg'y`&ºšó6-ž[ƒÓ’óD®‘pü WÍKÆ•E^¼û¬Ÿéá¨ì€Nšö[áªÓŽ‡|ϸ®(·«Œ›6\e±’ëJˆt—/îêòjˆù 4©×úÄàœa×0n6)èÒrº™g«lCjà±í©í¯ÚƒÆ%î>˜mÝC{¼Ý9*þá¨éèÅc)å=Xº¢r Ø `OáPXŠÍíæLÆjZPʳ†ñ/B †­ðËöÑæ±Všwµ¯>Ô¡ûúÓ"6~ë‰g%{fªÜŒ;Fq¶–3ÈÛõXìÓË£F7¾à,çmOËîñã6€?Ù¨*Ôjü¬Ž¸.™e´ýö–—:ï8obL±Võ(ÐJøFJG|$_Á{ÿq=ZaRbA+)ת*‘p‡­n5àæœËî.7Ñ¿»<™GÛPt”îT¶$ÄÚënó?‚8¦ .9Oº…ïÿ61ÒOÖÏH‰ åÑî“fïñ•ð-SJ]ã¸l²Qb¬Ìy¾Äëò¶v@3AŒ«|òÑáGÕô§ÃJrÔÓGÒ;«ÂæŸ'Qøtì)õn“ɹQ€å®Ü·cÉé|¥7e«a¦10ºm+y@;ïQ{êaái»­³Ò‡–š#‡‘»\f ,…GOnÏ*—Ìì «hΤõŸr—tÞµJˆH6•æ{Ûvm —·µâR;ÜU»ØÖÊ"ñB{²7vnUÕ|;,äòíÙW;Öüúöyy•¥]cOšë|kÃKð¹ºÇÏWÓyçšåIo%µUH< ïß9V :ÑïÝðwT²òº,ýîy£ãffÑ AÐõ]'S^¿Ò«ûfJK7Ôñ©k?ö`>yIêzߦm†“ŽÈ|ŸŒíÛöðg'^ÅtÜ™g÷9‰Ü:5SNe߫銔XmŸ¾!³ "ú€ÊxN—é.W ^“„«âmdøu¯d²¦Xôç/¨(·¤@ó<½L¬¶-ê— ^Ѽúj¹mY8„ÕMÅÌÈP?–\¾U›-œ m~oÓ¹µ˜7ßPñа°–+nd¸~©*nçl±c:¨¶o$¡Å=YÂ:n·ÿ‰ì•g>ÆÂn*7{æ)ê-ú:zºýŒÝð5ú&†í¹È˜8½ýuüËzÿ5%˜öN¢m~¬ð¾±yÀ;Ü&¾¤.%‚*n—¡ÂÐÈz*©Ž›'ãŒÔ°ç"—N*hŠÝ‰%Še Ñ0X¸ròŒ˜gQý맛½×•#¿* æûUÃœÎ~9 +‰ eY“3Yf©0ärxJ¹ÐÓwb붠‹ÇóåøEöi‡ ã³-dL:ûæGÙÇÑv y±¹zBUÎíië8†ïdÝøDE»vU²4$ÛÓ¢q“·œJ×Î.¬ùѲ’9SÏU_df9iZHuÿo:œÇ {[:ÐçR碿•¶7¬%äºÐ'úé%{úãƒK~ÔåCÒµÅ|‹ö^ºä¹b‰SRJÑOŸPBe ÏÅ•¼„×Ü]~ûÛ™v™N»3ËÎ_Êa•Š}í²}èSz(¨4¼¶¡T5?jŸbaƒ-‡‰»½zéÒxýcÖUãIvó$KékTRG–rW;ïk›Õh¾ü•Ì?Î[À.éžT³r{®,ŽVÑ* aÀ4†Ž~Øtl곸šõ*¥BW³®Ë8Å}¦qk›ñ8(7¬ô³, DÓö´ 5ÄîP<¾žn:((ì«~“j¹ÁÍPÿhÄÞa¶QÄ}4Z®LO”XS[°OÁ¹&hƒrlŒØå7Šð˜óXðNŠ‡ÍÉE(ðPTí UnßèÂUHmM3ûÙâ çÉ¢ךÖªÒð®xñÖì¼Ë1EÄ3tL˜bê'ÞÛ-÷#ï):œ¯’“¹kÝ‚g—}Ò¡ˆ‹îR±ËfèVz±j²´à#Ò¬Ýßµ7ï‘̈óïq;f6ÕuatÄ•²±#"ï»ÖŽ¤T~»ilr2“'z »^KñæŽÌÞOë.ªXe˜|ëù­OGÿd™ÙPxÅC6sϯ[Ý„k6çÄ]5öýËŒw©É"ÁŸÿ¨`Íì <ÚP\†ó™¢Ì$ö¾ò»Äs®u_ÒuΞÈ3þÒyf1ý‘Ý6Š–öbºž+p °¹Ë^ ;¾ÉÓ·:&äb€L·;h¿¨!a›Ñth ·±i]ŠgæhTæ%‡å\Å?]K0øÂàÂví±»š+ÙÓ¤H4Ku5¹Û„ §H"ßß-áÃUÕô~“ÿäÞµŸÚääæ\¬š[C§e¹+`ûµÙàŒ*dãÜB¯Ï%=¿²K~a«Â¥™‘Â7Æü4q÷¿¦œ4á¸ÿ†-0i$»ŠOmÜÎ<Rñ‡©×FÅ°KþÀTµzäi…b;‡aQúà·nòÄ·ìèÎwC¢¿Lv†M4nÙ’f:~ÖŸ”^–TðBÁ›4+1~]–m Ž›Ž9ýÑrksÙõ6v§~A£È÷Ë“gl!y¨-Ó"$÷ŸÞÜÅTÊ°|ðf¯tÚµÿT)zÒ-ÊÖ¬NÃabþɹ‹• áC˜› í¡3!éä¼±;Wâ3ù: çÌjôÇ)ö]#'"÷ 7Ç lÉàtD#ñÕïiy:˜@—^©d¨Gc@+}䙈 +KgÄêœÅ¼îÆ­âv%_$õÊÆ€sB%‰yN™üHj³ôËæX@OA˜_ìêä#}ógsú9¬ÒwZ¦rÓ ?}¨_W_-½×ÿQvÇÑ©fb= |¬}óx08Ù©þjß"ØN¤gå꘧¯Þá‘ð£ø&š³æ)Ïg•„»ÿáúÿH,A$pâeÐ}ÝØ endstream endobj 177 0 obj<>stream xÚí”UX\˶¨!¸[p¼qw÷àh qhÜàÜÝ%8Á%¸‚<8„à'§×Úw¯äîóxïÓùÎì—ùQsÔ_£ªš–RMƒEÜb –8¸²YIeu~••–VÒ rµ†8H\Á ?? îf à`y8ù¸ùQi’G/gkK+Wƒäë¿ñÄíÁÎÖf €2ÈÕ l­a²h@̬Á®^¬q;;€ú__¸ÔÁ.`gw°9+*0·6s˜‚-­PÙþò‘w°€xÿ6wsüwÊìì•0@%_ Šæ;/€9Ø•M 5ùÿ!õŸÅeÜììT@ö•‡öè¿eAöÖv^ÿ'±wts;”!æ`g‡ÿªþ—š2ØÜÚÍþ?³ò® ;k3qK;0€ý_!kkO°¹šµ«™Àdçþ;v0ÿO hÛþV`ÓÖÐÕ’`ú{7ÿN©¬\5½ÿ)ú×Ø¿ø›¡½q¶ö°³²³¡¡¿¿ýÇTÒfskèqà怜A^¨Ðs%n€`í`ö€=¡¾l¬Wè'hKügÔ¿6ºßlÇþ…P´þ¹¸lf{{Ðï7€ÍÊËÑ ìð;Ä`s„n*ÄüŸ7´ª«•3ü;òWaˆ›ó?h!ñßÄ `“ü‡xÙl2¿ šSþMü6ÕˆZVý7qØ4~T^ó7AçÓúMК:ÿôX²ý^"?€Íô7Aç3ûÝv¨šù](øük• ÔÇò„ YýP#ë?ÚF›?êdûB¥ìþ@¨•ýoB­þ@¨ä„Z9þP ç?ªáòB5\ÿ@¨†ÛÕpÿ¡¨†çÕðú¡Þã¿,ON~ 7û_ãðr³ûýßµ¬ÜÀòRnvvv^~Ž¿£fnÎÎ`׿ÿ ñßla ½¶`°'Ø õëÄLðMZsX…¿tÑ—JFX Ë–x•ÆžÙ.´¥X»Ò1E'ÆõÝû™x˜{{¤.Q¾o&eNƒœâÓçŸ÷ÜMö2½ÛHu/2•½v©nB¾cu4Ï]sêάW$ëæœ }/PcÒÜGZ¥„é5pÿØ›õŽ‡WW&ÓN+<´Ž“R;Ý©"‚+|Í;9~m*Äß&¹•iåÒé†{_„œŸôlxƒ‡cÖIÁ©¾ÅøR}_ô¸¼8«þ×ÀH­XÀRð‡°Œ¬>&’‹V›ãM"m<}FøY:BÙý”¹­S—ò‰–Çh½tǘ“ÉتXa©„ý,±RÝì5¥Ûþ4»Kþ4û²ÄD ñõ `€áI™[(‡Çàe\§ý¬úUT ! í›I2ËI4RÊõy8xHí]=n‚e"ù³žùÝÚÆ挕•[’ñ°Büsp2…U+Ïž\3«…SOóÈ$é.Œ×;휱 ‰v2¯Lü|^£{R«ÜjÍ 'SÒñ–ƒyü8"«¯Œz\ ÿQ¡õÀåèå:sÅFìøìçLóQe—W¬d™„‘TqWâÔ¨Žýü£A©î/I ³u3QQ"oªex{0’Öp|T|dß%µ½*e‡¬ˆ–.òUÖË?4ÀT1fdSJmP.5W6òYƒDJ›Žµemµ¹ˆ^Ÿ >¯èœy}äT…ð)nä8Öté1¿Ÿ¢äÖ,oZ¹O þfSBøMN2>‰¿iÐ.ú²C^T0B¬Ï87® w| ˜QÃ,¢ÃKïHZ«ngÑòIy¹pN“„FžÖëI0b@ú”•&@LÊ9!ÈO„_%C–0,Þ0'W.vŽ›Å–}懄òìeK]Î#îsÓTÏby#¥1ÂfL{Óˆ»ðsîjÕT~¡ôáxÈ(4Âñè‹J&¤NÓbteÀuíD^w 9úrKÛl›È ßgÅ-©·Ori­š3™Óö¹½áê½¥+Üsžf¸ ÏËrsOeúÔq¯‡;õt÷öiäBðGúvUÜ`”ÎyôîZ<>þjfcquT-áEljKß„vá‰\QžA¦i­ã.¯ªŽò3Ö“qAÄ1>²F8½v›>±ÄêÄxÛ¯îs€’ŒþV,OƒD/4n§Å4Ôpçù’Í·Öz4Ö0V!P¸[k€ÄŽÚy(dˆÉÊG8îÄ@·ëd¬ßªËœÜÀØ?¡éµôž’Xš?¥pˆµqÞ ÿpFmU@mFìs æŸìäè}ÊqãÍ픢È7+RÿàPA#Óª¾m—ûÌ1ÍF!,^‡?"õ†aÕ{÷µ[-­½tÚþûï&B˂テ~xí¾™«sû-JÉ}©1Ñ%ÐX_ ’«É©ë²œžð½óÍ’¿‘|‘Ê7¤Ä×*:{•$åüZAs®öÔm?牄rVwVUX“5×R•J1¹—ü=ceIYJ#…wi œ† Éöâ06|äÕ÷$ zÏì …¬ÉU Æ°YIâ_a¢§ÑA—Ú¬\ÚU~†ú ÎØoP=½,\[F$…,¾!#Ã0ÓÞQïW„:¶÷qø«õÙ‰Lžµ©Ã4¾V0R”i|øp|®žÕD¢ËÌ2‰ðñ¾+Âl“=‚ažÝ_ØG}5˜(m½3ËÒÈ…÷ð.­žº–'|œ3pg´÷!”΀Ôpª¨M’æÐü˜ÝÊÊ+œS\;[¡B>ÊAG߆¡X+ô‚ lQÂ~eÑõnëVí£û %Õ2x¬+¨_öBf·/¶ùK:‚ÏZ_åÀi±S°!™¢n|gá‰1ö·€65æ/m·$QZ¹©Ÿ¸X9=‹çÒFDÅ„†÷> Ñgšô½l-A&`A’Ïà·~¾ª ©ß&k­Ð˜ïÅUª³'ÊSú$úý wi\zKøØ$.âb¤Ö#‘7Ã}£Œ^'» þv …ºÐª‘ùæÎb¢ƒ{·u‚TdÅ®,`^¦~Ê=¹¥Þý»R8%‡~*CY‘¹ùŒû®…Åñ¸t8ÝðU¥E ŸsCýKÂÕÌÁ=:> ûÌÛrÛ²_›xGN†²F h¹ˆé¶ê´ø¼-I9óä÷ÆãÝüÚ]ÿÌÓn+äÓõhh›Z‚ÖÈH¨èhŒchŽ åß ßÞ'³&*Õ²ýôƒÔ÷–¼õÂ<ÔF¬/^çàÊדHkד¥¨2oôMu5[âÚ›~>-˳àI÷IR´î5ž$MQ¡ÇÚÄA_š1y¡Ž†¼ÛD™‰—UÏÆ’Òm<–™¯‚ƒxöD‹D†6œLB~u ©RÉÚSÃWyö]ÓeˆÊfPô‘4ˆ&°W›ß\ž»Am¢÷û²óªØˆ¦cßñxýÖ­y‚sÛiZUd%'BÑÛðûQl¾/+bá;Ó¯¡²Åò:ÓŒ´§%mýl®¼ÁÇé´G¾[Á FWÙ¤âYɱüAÙ¡Uá;x!G)NJ¦†;]¾´!Ä ÄZиî£2Ììk¼Aœkí»Å†ÁŸ4S‰¢¼ñ´œ~0žsù·¸ä<ËímnˆÜ[•-±Ÿ©y²AÉÁšHœ¹Vóæ'¸Z)ÜlùUŸ-VøjŸ A_¿6µœá°ýlüÀaî°ì觭ÄhrI&(ÞÍæóJóUotTœzË3Fž0,#~ûé˘lÏeD® ºoLòEŽÝè5¨X ndÒæIp=¤ Þ5ZÑï¯@yÖA=jd9 anSÿÚ¯š·¢ã¥¥4ÔúíBÃècÛ¶tŽñ"$¥sQ/-6ÀæðÜ‚ ·ý¶‹])µÁ<Éñ)*{aw—á<00…c¢õÙåWB­AFª`øcìG?™Å÷ ̃|qfÒbl͹ƒöCùèÄ(ßWjïŸe©DŒ¦ø>:iϺ±WÝŸªÑh¦ª—þJ> "äûBN E>MžÍ㈇|ˆY}ù‰üŒ7<.’GKsÇu]o¡4¼T¯ Òì´#ií[ƒðõËïÁ*Û,*ã—èSHëpÝVô8BÌYÊ6ð;¢/Äö…Ú­(EÈw-ˆq©˜¶÷qb2¦"+³àökÅì‹£†ËÃÛÄnD›÷Hä|‚o~ÖQ /ŸIÍÆ{óÂ#ÑÔüç ·”ÚؾßWPÄÖVÚRH‘rÑ®A*>Nšæò»~ÛL ÓP†é›ðõnCšŸ,ÓÖ‡›´N æšOçæ…‰ä"Å›xâ¤ÓôºÕmš¯Êæ®tËmÑîæÙƒR¸Ü;\NPÉ8BùHájz¤”›&>쥿Z[85F”D¼al råÿ(ÕÂR’6)²¼u§e¼Qü¥¿`n®5´¬ÀýrÊ!ÚOÕEÒM„p©ÀÞ-I½{§¶Nº¼§2µLÑ¥ˆúÈRÃ/Ðg‡‰ú8ƒªersÔ3o%ð¾ÑcÏŽErùª«Ô‰NWß&ãË*¨?"ù[ªp‚*ÿ·ç ¥vZ)mîÊ›noʀκ‘®¤qì8üc¿¼ñt¶€OFîÞäU½ÄÊÆƾÊY{üø%Ïü’ö(h{: ?4Þ²\CZÒåÂqò?½’T.~GӢ̯–Çm`Z;{ ¯+<»SJèù2bP7RÂï’Nzšû=Áèç4ûó¨óÑ;$4#Nõå´žò'x‰ßw¡s°` Tæ7Ð5íTE©'i?ŠÖù¶ï1õO¬¼“Ýü uñ8Yq¯)/—ºégñ%ko ,ÍƇõlù“1è1ý2g|Hƒûö¾ŠQá ɤÎ\§-;š’žTKÐìÁÉ[Ã%CüÝ­æ~†~ƒËüiäË)ñ 2Ó£oKþ2¯N¿ìCbÒCò¤Ÿe]Á*3Mµ(PeG¦‚ãÁGձߛSù³oëÓ¾­^ý>b»¤Ù#m¤s§&ë3«‡íÉ'´þ³"˜Ò‰â€{Ñ Û2¤À-±DÌFb5QÜ‘Ìn¤G8ßVe- w,?½sW¿™ˆž<'Cf½VĺŽ÷üú¹»í¦ôô}¥„¬àŠëá+]K§€ŒòŠÝæìRx0ïÞ®š‰ìi+Y^;ØŠ)…Åê;ÇÑ%j)ª>íûS²šŸñ/§Š½Ù?,…>×tE$‡8tÃs'ÿMáfѪөï¸(ãz¸pÅ°¸Bžx7ÅjU—±Î¼an+{œ÷÷Ÿ´8Ž-8¢@œ!œÃL•6®Ù¥\J©¶Ž2E áš‘S&P›Y¤®>ðÐ)›Î:y¸éë:ž[ªSSØbRœc—q=.é‰uc –ž„na2؉oKé œüì:bR"áËßÅÏ|ÓFò vUàÑk9–é øéÞrÊ—Z@òõzžm>¢™ÄÍ2ŒbÛ —¯ZnªRœŠõœ‹ÄÌRÉ-™á× ÇD`*vøNІ8Pó›{Œ~¥Kè‹q_lÂ]Æâ6”vÀ~Õä#-—•n^|úëúéÂÝQàõX”=©NwÆ~â½Å–S©€ð]7_òŠÒ±z|ѹVÂí n?oÄ‘ìÐiñ~Þ•¥z¶W1Ê"QÖË›N¯†y¦k6r¥æéŠkÉ])KêP%C‡ŸžF¡*éH*AGgTœt7¯eÐêm>¿ßúASÃ’1_+Lší»Ž¾j´>Ù1¼CÜÖ‚M+[¶B°æ÷¾£0c“ëÕugã{‰€‰É-y H¿lÞÂe?«ònÁ 6.Jì”Oµ)èŒW ÷᢮DrêAƒ¯£úõÁì×;™*BQŠ{’Œª†>2§jo…Þh¬Ÿ-D¼ÜAÂÙ"ªçÏYSVƘˆ› ê%-åÒúz\ ïì (x±|饢Ée÷xÕûÑàÌ÷Ç~ªðMB(ò]«øË;ºNNß!àî8YH³LW[¨]ìÍ9D±´–¿yôÄú¸ÚtË»Kã0QÌñबêf×<<«bDšò€¼¼%Åï˜k¯ñ¼ ¦`pŽ›4ÔžÛÛ{Û!1— Ø¦QE1\WÈ:Ù@äŒ,³ˆQªº1vhãðŠKg›à˜] ¯®TLÝCÓkˆ–!K×䟮úiþ~‘²šQÝivÐåz¬/l¡ÕÇ­‡4z>Þ¨(Þâ?#ϱÄó8ÀºE´„×xî”ÕcGJؼ!ô4×Á–%õòžÕž·¦¶>·sŽØd!#ÔâÚÄh=ËLôNdcz« =€ÐÏZ°#â26ð°%ñ8QP(UŠF0c|Æ?tâÐÎ؉Ÿ­À]’²VÎÖ  [òÊĸ,×%bíž%qmtÏt?ÐLPq_óëÒÍ =7^=EãfÙômq¥ò@›¼ý©N ßF&ÍGÃ;[ô ý_þ)& |ÊM"úº‘_CÆYµ ŸêkrMþ¸¯_I„ÐÄ\©¹fºãX8Þ¬ñ9Õåi jþºû 4úõê^UöÈÛ.béŽ^¼réî™ 2_¢<Í–Ÿ¯^O™ ù„½.Ä+ÞIÙ1î-Fßü.RÆ &jzkR`õ¦‡×‘í­Ãlƒ©âpU|¦f6Ÿ$ã+éÒøZ!l¤[$Ÿ‰¢„þ´ùVr~ÌÇX¯ÂÓÍR?“¢Tô”b"ÛÇdš¾êª4ÍÛSŒót”Lôñtòõ‡Ö_äªúàÑPgô<(#"¦ˆcšÒ¡¡J\¬‹ÌøµÓ* ÿbý*„é8»(ýqq¬÷ûʯF,Í7!Cƒ!Ö»8òã¬,ÆþÓ ««Ÿ_U³î-ìóâß×èÖ7Ë쬼µyÿÐMìúµz°x§«"Dê—µ“ÏU§YµZOÄþ»ÆY%¸™E”ñ°lûø÷ÛMŠþñm+Ó/ŽˆØ5/óoìOBycÝ´e^øTltê¡ä8Ñ÷-yRÆÚ°˜5·†s'÷vhjQâdH û,ä¶ íΙØžÅÚåð^½ý|he"ƒù½ƒ‚p¤¸º¹ž…2e‰©8ý$õ¹[‰uŒ ˜çK»ÙÐQ™w™ü ¨­Sˆ£–f›õœTýÉûÑWúqw&Û~ßÂ-œ(ä*“3.!ÃÃþtS¨íM 7_{eÝùÙç³^æWÛ’ 3ÇØQdH•;pÂçEaÏt?ú‘œF5çYù¾¢î©»CD¶§Œ%K1>…Ùθ"åAÅ+î`ÿÕÚÞq’DKÌ/–€èÍq%8<ŽßÂQd$ñ°ðàïù‘~Ë%6\NXÊUëzWsÇ)zxXéî¯WfÁ-f/â ÚóΠvG+ƒÓKî—ý¡å`!}‹o}otül5fïòv?áG«^Eª£q¯.ÑKg7œ±ká»”ýÈ>ãÍ­šoK’êç~÷dŽ J_^ßSÍmkFa¦¾6|¾0ý£"*ÿäµ°Ù®%¯0í[Œö`Ø5ᶠ¶þt šf ‚Ffr¯ËaiŠ©,Iw•÷³ˆ¡‹_á.œ*b2R¿PÆX6x˜£j*„ì:~Ó$+HA®¯}¾ði汕MR.v½lãö >iòëê7H€è—90Iû%(iæ|ômQËdvÚ1ÎI®àŽþódÃFºõtú…’‡±ÿçñ¸g…FÙUqXH‚® b7“¥¨787òNÜf¿¼p"du”Ç8©$Ûšºoåyv¾áÙCåáékjàñè¨Àêë$€1p]•¿âàUùH¤3 ÂGkÏòõ6ª7‘¥)·‡‡Þ¦.„£G*ÎÃEçOsL&SMS_8*|3‹]êW)YH%@]’WãB°x5xcÚÐù½k©*|—ùItyJYí•Ë“Žt"ìW÷ MK›:êL»eA¹¥Šþë%ÒóÛ/¸!pnDáí<¸§5>e´ÜíËŒãê©Na ’Ô\:ºŸÅ1õâ}â«n.¦#æÆÈc½0yæâ‡zº²Þ÷D?ÂSŽ°ü³!Úü¤âV*’W2;¡óEš÷aÌNHð©NïsBGEç‡Í*jý²šæîHüÖ¡ûR~h¨=]Kr‹DÐt4ñTŠƒb%Kå­Ýw•âT‰bivD™Êe}lùƒük¶Ë9Õ©±¨üÍœªè M–{­çýeÒϺ¨áTo9ÎÊj´‹ûYÊ'œ‘Óû¦Å6lMúSÌÚþPƒkôžÅKŒA(òQÂZøU”õÊ6»{ut¢-Ç„=h½“]qQúÆÓòt•F‡5Ecë¹vî”—L©aÝâÓóýþm‰i[§ÂÔ$ù:Îo2ÆÄ•"zƒ9hèÙ9O#“í±‡Ã°¢~ì [C7Ý×yè¡Úëž+yïM*&n~Ã3cãõp3…Ɖ$¢ j‹[•«»z±wD@/8¼¥ÃäŸ^Äô!'eDădÄ·Ûý$Ô^¿fæ\Á‘Ù¸D3ÌR~ŒÑ‡Ï^ŠÔʶ?ŒFk"=nÃ÷¦RÃBÔ®ñ¬m_x¨t·‡ Ño AE6ŒR€Ûè‡ YñµÙ%;lufÂx®A¤T†É6Usr?fE¢)ÑyOr3QKìÒóª«ÉÎC?:ÌȲ1çr»&Þ=¾ÛW£ê<}%P¢¼ž‰Ô—:ê¬0Á¸Ùò'ºFžNÎJ^[ïOµ C_d±š ùŽ þãQø~–›g>s”áÛCÌð"|ܘ*`À„ûcnSuS0Ç1»5•ÜÄ–S%À9‹cÑf’PlÃ\l»÷ˆQ[›ß+GZ`""î…ádÏCn¸ÇB_¡˜&íµÆEú NiW™,²ÅñNqÏýº¾aº‡ì5Ûí×ýst£&ñºƒP<À ±#ù>÷deå65\XLz?žñªÙu+Oó¥‹&ë'4b¹ÎÇ·æíiøúâ!-ÞËR5j?¢P¬<’î}¶Úi×÷í™·Ã)iÞ^¢ýò,™tFi¨};J!4u¿„)Ó>stream xÚíRiTW«Æ‚ ¸ò %K©VQ£1€„Z—a2„Á0† &(Ј  ¨(JD\AÁ¥‚ U*²¸£ˆ E«,âRÚj{Š?Û_=}óç}÷»ï¾;÷}6–?‘F¼qŒtà09Bà!öó“M·±ñ ˆDqÌ"!à R+— 8<¡£“ëD·¸JK ŠPØyLé#ñ€(!P€"C‘pJ†”À‡Q„Ô2H©Ò¾‘@ŠD"D"gÒ9 Ga# £³ú ùb!8à ÀrµêS+ !")SÀŽ29På8¦Ô9BgÍé»ÊÉ¿aj°¸·Z©œ…÷É÷…ôY G•Ú?x¸JM"ãr„ÀS‘obDŽªÃw}IH‰Â"L¡D{B#½Q "— $ B e$Ò#˜|° *·~ ,÷Ù çOxÏþžB1Ò_«úSµÜ_sþª©tT±™l6‡"RߧÝâAwya0.G1j œ]D–NMU9ƒ•€brD e˜ÅÄp’:¨Lb@NÐûž“Ï,iDÿüÜÝqÍJGàÀu¦4Ù\๰cþN ÀÐ5âë œÙl6ŸÍíGa5A Ù?4T<Ÿê” A4L¯¿ƒÃÓׄ¥^—ë•Yud¨½¡»âÌ–yù%·‹GÆÿœb¨V…&WÔܱʫ“¾Ó4Sk`_y蘨³dÍYs׶6s‡neè+ô½¹FCòzÒ*7ÕÙbàq¬ɘp·Ñšíf±¯+kíÑÙ> ‘=ùÕ'SÍ–~¸^”Úà -hÏw™Ã‹{c=£^`ù*ÿþݲùÍ'9c‹½~³P8©Ëâ"4þ¤¤…æÇ¿hÜÌsoSx€ÚáÕõ¾ÒÉí±2Ù‘”.µõËçö&»ùWß¡:F¡~,¯R\þmÑžÎ@S«»VäÒ†úÒÚªìĤ¦ÆŇùÇÜõ&ncÀAÛ9 Õ2ц{$ÿ•µMzÓA£q¿Úf¬»1e£¨«%A¢§XÝp_ЬL¹;ãû×>›BiµFŒ–¹cF;-)}€g–zYª+öâCÒÕ ÅÝ™lïkYU>9fýª}zï×GÏ‘ä¼À¯œ°x”Ȭ{°\1¤ ßxS—÷~Û™bYÆS;Ë]Ci{*¸?- ~˜+NUb7íL›Û‰ÄìJ'îÔ`5ãH o´É¬µ8c–Ûí‰FÈo¦y«jýyÞÐÞ¹?,ŸæÅÀƒœ4Ó&4ó–×I­É×ozÞ†:SEÝ’™S^Ó“c˜¯²˜ñÔ!­&óÇŽ‹±·ñë¢N™¥°ÿá¢ÿ/🀕Dx8D,§ÿ}°jà endstream endobj 179 0 obj<>stream xÚŒVÛnÛ8ý•yt¶æýŠt·(P4E›ýE¦-)ä¤ùû‘%š”å&†D‹3çÌ™3”sÀ@0Zà 8þçÀÁ«!5^%åðŠ{,Þs Rá3n@jÚgA:ŽWJS¼epŸ` Æ Z[¼ Ðã„í1N(° ã„‹{…0`b ŽÑÚ£üƒ7¸O2ð„#‘cHL ¼ŸHdŽ4„TÀ ‡xs¡„4xcè‘.ýãðÆz¼ñÀ•C@……k†H 3k„X×T+¦àÆbHŒO7˜Ù„ÂÌv|„™T£HÜ3ŠÂÌ^#1”ƒ{‹TqÁ=…kŒd®% O{HzN{Hk`,šTUCšB“Œ†Â‰7–" £Ú0|¬ßãÊ'znF´‡r¡ªÂPvÊLmë"E´§G‘j(’Új)—ŬãµÔ4KUP¤cdü9ZÑ¿ÎÑsÌì9E`f-$'â¤õØ8Ç@2r.ðÿÆHÉÈ[Nâ ‘Â~HFîpè2.émÆ©‡>C $¹C87ÈùÇíU{hlõöæå1l¯C]5¡ßþSuý0:œÁÏí·‚È?bÔ¢ =wãóïá÷0ö“7ÕP‡ŒVŸF´ q?ºð4ÎM‡Ó3Åa'ÿˆwä3'QY“˜c’ÍUÛ”õ¡¯Ú¦‡?oúP¸zÏÅ»í¯í—ö¦ýO¡²:y¬“Oun¾6ýPÔuAéXü X*Á,Å|ÆbÂúV=TÈ´,‹½ʦP2ƒRJOP×Ã}è ¬‹¾ 0Ÿa=õ—X‚N¦&1•° ‘vT¸ŒŸùÈɆ›‡ª®†ØšrE·ZÿTå„—;ÖDÇÚ3çMq5“ÅE©œŽq¯h y¢)§Hf=‘HÎ=ùûw©\¸/šÎî].‚]!5Á„>ÇÏŸHÇVfcëXŒãKÔ%R#ÈÌPf f#ü û€ùËOEW·õÒžfU™ZÁfJÛ8Ôöüð’i‡l6 6¨KøTj…i1u&RY›”Œ*¨I…Ïa_5hhÂóú”êu2yM¬ÜøeæR:­À¤¤}Ìß*)èñ/Ûæ QÎ'Z­òWéô˜Ì”&N´9Ÿè)îÈMgêꨮV¯¼óÒ$ÓÛrN'BóùÄêÇúŽ½ªÁó´è¯}×>¯p}û{Ü’/OÅonpg׶Ӿ)(ß.^×jêÔ$€Î¸Gáô$ÜæSY†þÄöU¨w3ÇÃm¤yaØ2dIŸùOÇñ6ì ù©ê†CQ_ÆÖoÀÖ öÂ.ñì3r¶$¾Ç ¹§wl a¸oW‘ßàM C¦·‰'»Ñ ä §âðX‡íú_€Ú%µ endstream endobj 1 0 obj<> endobj 2 0 obj<>stream xÚ•;Ûrë6’ïþ ×>Ñ•# €<ΞI¦6U©Ìžsvó03´DKÜP¢BRñz¿~û¼X㔫Ll4¾JøKÓ´Œ“ò±0Ilmù¸??$GøòׇT v² `þýÛß~ÐêÑÆ6×ß^–h¾þý­J£îi§Êh_?íÒ¨>4è:O;­MÔ½àSGù Ÿ¹O%‰~úç·¾ÿæçw¨u›¼ÀÙ{øû?“ÇPúãCk˜ïÚIœZûx~HÓ$V*—÷öáëÃn¬eÂFk)§¥˜BÇ Œ ×¢–D™â_²M@Vl+×\Kò8U–f‘cY=ãj~¹ ÄÀƒû¤lô‚uã‰_‡±`ç€àc³oª ¿©,^O‚ûõI|4#e« y€&ÍöûÐvWD˜„‚‘†‘ß.õ+=×ã‰7üàhø¯E=ß CæªZ÷±C®³`Wb›e´þgœ§“Œ–%ÄôØcxؾ¡.¦¿F”§D–‡Ã^.¯Ä)±g”/gWýúÄœÅâ,Ž&iDP˜ñ$}Hh5­Õc@ï™*XDÕ÷U@4ñ©j߆Fè:Â2g½tÂòû²¨i«g€j‘RGÝŸ èÈw>W,Cü´Ë¬Š¾ÐÛoskzÇ¿sÀ²±/o´‡“Ìà>Òúª9N°}®ÆÏÐ^Yš-1§%ÖÿHÒ\öÐmI¡)HØ2 ĉi¡<î2³ •G°ŠûîÌra¨½p Å« œùMe>5$é¸í:‰þX·­ãÈ 5оԇ 8åF|—#2®œ¦´‰q&Ã}´ðîÖ¢ñ€YÇS-¢á û_åó O|X/,ÈpbÇÙ­Ž7ÇL„°$Óç2fQ\ÖVÊËN‘®e'ÐÎfEô-€ú3c:„’Yý•ÌùÑ##+BÆgÒ{þVñ<8iÕ#@óN4t!âS!Ú7î §OÆKJÔж°x*XÍz#{ Sðõ NŸ’Å÷UÅKÄô‰%cÏß©Üãà–½çÉ¿Ù-Š} 9Õx7ƒÓ´CÇcª¶ežÑ« ñìO+™`ä(ãÖòÊýŒ‰m5°#Øòµs›ŠºQ–°©ˆÇ”Ñuµ¦tdCëD’iX2&ËCëÝ gîõ2hÊ5Á^tM)TCƒ¤ZÂ(Pí9˜±ãǯ„`bp"1Á™Ö‹óNCꊬcw†ÀpÌ~ã Ûñ¦%§ø„ÇhÔOnl™„Þo˜Òu­¢F0¾tÈÜ–ÄmÍ!Fb!qH¦(W:¶)þ…¿Ï"äXe  ÈþÎeÅ”`ÄG–üðÂ]ÎSSÓÍM95À}’ï\>@ öÖÖ‚´ŠÈH‹€H ÒÒú–á$ðŒî(î)’,2Âуrl‘$².Ö¦aqZp‚–6‹~Aa¬™×­3ÒÝ×Z€©.â¼,fæ 4ÅÃÇ(Ôd9fië'O%}YB‚ŠvÅ$pÃl©/S"ð”¿{N¡X ŠÝ°0Êp±«F±äß\¼È¨i®–äöxÐáâ`½J£¯òÊ(Ö2þ—72?賄W´Ì³$Îlþ˜©<.“”s4LËÇþøèš_ÂDWFì‚!«”miùJºÓ6£OyýäsßîB]¹D`|¬z nbd¤«ÜBB8§|‘] È=RXÒO«™ ë¢øLr#îμÀŠSC2ž¯f·—ü‹… ÌÝùxp>”ZÇù¥„ä/h/{²Y‡º`Þ þ~ÜAä.v¢>ð¸Uü!Z™y¬”š ¨xbSpþ€ñÐÏ?ÿÍéRî’ôÉMJÖ>qŠ™;Å,$£«{à÷Ž<§K÷ ãqN -,D ó•–3-,D ‹èGŠ68'}7 ¶}þî;ÊRáuá8¶½+ÞM)Ó¸ó ŸçrPã"~ ;±~€ìü ¬ô– ;½eB?ž²Žº5²u8’’E‰úVÊ6¢xôG¦cFÞ •°E¥z¼à¼ŽIþ«&#¨¦älíM”‰Áú‹åç² läaàÝyF—R· gbø<Ö—º—â¾;1vê.Œ­MVÆÆ”2Ý–­4‰‰³4{46‰­Î?`܈]0dUI[`ÅÙ?Ÿ@s`«¤¾Õ+RLk¥ç¤,KkswòžMóg2«ò,›ÜxŽSl_¹® X’ß_§ÀÜnÇÙ>¶L:ÃÒb¾•ÆÚ)ÐN¸@R·~ê¡Òu‚Ù+GZl„ðÃÚ‚á0'ÿÉ=ù/“8/ì¦üƒ:=ãKÝz‰>JÖØñ“͉ ìç’ž”q–Ù)¤2Ä~;q).á¼#@Ž})ÿá°ª´±ÒåŒMâÛ’J0;‹· NË%9[RÄÏ)¿/3#ŸâÙRìºuqüxòAÂaB\‘áƼ04 Ó“o¯*DaìF•3,C¬1n¤º’Ñdh~}sÁL{!ê¯Çªi |D&>zOáÓË»+ƒo¼²Lʃ«þT£ŸØ“)vZD¿p&syÑ„W>s’JÆrÃ’wœ†É ušáJ•4žÛ×3à“à”kág–îøZŽu&â†+„,wߟ—U¨’‹OA)[Nž@2+¡àõ4 ~Í`YQÈêàl€ã“\!žq†}ÉQØE<„Ü&ïï68lOá74dn~9t"­ˆd“i6U8íǹ۱¹² Y2P—#™G"Œê˜–“vœº­Æ“!l£ÎãóR±;‰fU×hžçÌ–c”®5°‚òu¡–böœê$¤AÍ¥’µÖØ_Å…Ucç*J€`¸ùHL‹’hgDaÔ?Rm¾û7n¯…šûYQ Aâ«þâ fñ˜Jƒ/²ÑO˜°ö›±YÇg½Ø>*ìg•ËëÈhuxŠî6.Œ¾K¡¹¶•$³lß›Ë:©OKˆo¬“ûuVocˆÑä+[ÈzéÁÐÇ&7C ðÌnÀn±t• œ Gt‘ƪP3:^ÚÜ›tV„3o…aº(ãT§`Ñ2àîÔ3œtš™$ªZ‡€:NÀÞY¨¹3Û‹ FÄÿ‚Ò*‚uªÂ“ì‘låà\²Y.ß)l-*üŸQ†~†wH ¨¨¿›¨|ŠÍå ¯ë§oS¥鸵Œ‡Í4NÍçÛµáÙ(£Z:j™ °Á¦'¶­ú£4½§3 täÿ»á¤Ñ{q0!ÒúèNåR+WÙì{<”DV¹Z±b_VÃTžœ"8\&,ž"L?™×yÀëL¬ýgftxñÇÆÑõÂWOk3VÏÞÆ/Œ³Ù™0KœÿAÎPß´[Ê_yô#lÅ[±·äõÁó…àõ¸w’k‰3m9«nÙÒÞ`ÛÓË^ÂË×êzå¼sÃ*·Çú™¶}/J}POÀ› ¢/?uþ78§ë?ñÁr·€Õvœ:äôñqløºÞdðÉ=Z˧|ð”ƒðd4í3¢jq´œ‘x¢û¡Fï…͈Gó é<ñ9Y=Sv+µŠsP{®[)SPp$Í&aiëªç.\3•!¨¤?¯)Ô}Ò\~uÅËR À[EuŠ3ôv4ªJµVLìœÎhñ`Π°%.§íÜñô¹{xŽ†¬ŠNß2É …ˆN€Fñ¦Â÷ ÈSa7ÄnT{ç‚Ùl9rˆK}Ç—¥‹~ƒ»5—'*·S{J+]ÑŽ °ªç©ju¾¶Ó}wÚ=e]€‰õ`ïœ×ÞµÉ$Ãú»?øôÍÓú&ÎFA`0÷5L}ªø¨¬0èt¥öT®L¤:8¶ÒT~Òüý‚šÆy¦?(Ȉ]0d),°"þ›Ž#ÜÙ¶¬Ôû úKsb…™³˜BAZmôœÎeP!0÷([âÙ®åè ËÝç‰ ¸;ñ§Ôr캌”ʼnÉî¯S`îN·Àãk9,h.4Ò:‡Ù¦y2 ÄÌà3Ý‚ðëæY ‰eY<ª²ˆswŸíþY‰ŒØCVg% ¬ ¸èbn³9)Ë3¹7ùÏöñVž«?°n7âþÔs¬ï••±`^ËûK˜»ó-ðQw‘XoíH4ôZ4jî¢zÂ^Ë/ýÇUn§ôt&‚ŸäÂÞÚu@”UïúŽs-tS ƒ=œ_D™E]¥q`¡¨K„7 ËÔQ{l.—©6‘8o™l‘ÎÈ—`ƒ#@…zƒÏ ¦ÅW¾v!¾BÓw¨yxÉ‚`ÝõAl÷5›EºŸ‡TQ]¡Äæí±Y­|çjI™¾«ÕIjU®ã¢ü¨Vãˆ]0dK«C¬Ôê4.•š“²Òj†¹7ùÏ;Z]ÒñãÇ×íFÜŸzŽÕeÒÏ«é3—ß]«ÀÜp'8ÕÔ6òËé诰nøúæ““/”‘$ºV(ûØâ‹C®ÌûY:\¦R."+\²ãK0°q”Py—‚£,|¶ž‹Îƒ¯Ë¢ßÁ¥‘‰~õ—¡ÍIdÄ]5¿gü=`lê—Š«„ þBÁß™_f³qB©“òFOYNû]4ÝUAÌ|Æafרá­$>å¤Ä°e°®6¼]gV¥ÜzlÝêšò†,L©Â{'TÆ,£?·aþF—[x˜”-T™Ë¬Ž3ìn7“`"¹¸ÛòÛf¹ÁŸýÛ2ÃW K¬ŒØ­¥í¾¾—°Wý) 袬¢#f|’§I8Üp5>ê »+Îq -Õ_†G— 0W+>ÕíñÅí»ÛÕrÍ”&Wq‘gÓQgú‰„IÒqÖC©_¢E_]œ¯÷]åÒ}¢ŽÖ£Ý ÁJM\Úùÿ;%rÊÝß; R˜ï¯k¾ámÜÍ+ƒ7¬8ý3òC |úÚËk=8Öí‰8n¹à®.“<"¹!5Ùa¶èS8>eÞ(ÔÌN 0Àà6·¶DÂ=6.)Xº¡­¹-WczþðâÁe`—Îá_¯;Å6] ZÅ5v³@­A† [¾œä±ñÇ:±;I-bµˆD¾wฤ"¦áÏ ¨c}õOléàË3ô¤EŧCMXSÂëíþd6qŵ$‰\ÕÞÛT+¿uH‚2€uïú¾ä–6Áúl¾Þß÷|cßå†Ý&Ñœíws° :õ'n7r¯Ð] FºÙ†]sƒæH€¢Ù1Ät£ŸûƒÙä°&Ƚá; ö6,wЂ~¡ÛZR¡ñÙýË¢\Ëçâû© £Ä(«É(¿·ÂÑ p'}A…Fœ89ØQ†ðæR‹+!‹tå³À0lð« ºÎ-¾²ÞýÁ Ï7S³­ŸNÈ3lõ+ìtJïn¼²â-j£€Ð¾¿9`óÐÓ•¤Å/UpÌ¥v&dì¸Ç§(ø"‚]ïñr§Ù¼·î¢ ã®F£¢Z´ÛÁÚѨå6úþ)Ýg—±tF_?*78Õ“°Ñ½ÈÏ<ÖóâÊ|ð ¹9I“Õm5ºk>DLǃ|i¾jÑ«g7M‚…âú¿p¸pá—ú·ýx©•ÓOðm:…„ˆ(85q»M7F{öæ`%ìGÎÆÝ7,¾+,Íq†‘µÀ(l.¿¿ ´ ØëÍ@[çø >ü?b˜ endstream endobj 3 0 obj<>stream xÚ27P0P°±ÑwËÏ+Q F&@¡ }7c ÛÊ6R°„ š+@… ,Í@L;;ý€¢üäàÔ’hý7ýÔŠ’X;;€Ͷ% endstream endobj 4 0 obj<> endobj 5 0 obj<>stream xÚ•[[s㸱~÷¯ÐÛ¡«,†$ÀÛãf“M6•S³Ù™T’<ÐmsGµ$5;þ÷é¢ìLjªF .  ÑèË×pºIè_ºIÓ*NªMi“¸®«Íîx—lž©åOw©öØj—mÐç÷Ÿî~÷ƒÉ6u\fóééšÌ§ý?£Ÿ†û4êï·YíÚûmµûîDUÏãýÖõOük¢?|¤ÊïQ—%‰¹ÿ÷§¿Üýñ“Ÿß‘6el‹’gÿõîŸÿN6{Zé_î’ØÐ|¿Q9‰ÓºÞïÒ4‰³¬ÐïÃÝÇ»¿ÝØËLMöRÍ[±¥‰îeµ([þW¶i—Ûª5×’"N³Zf:õ±ãœ"¦ÔIDeù^¨®år1Ï ªGæíîžØüҹܠ¾è·ªiX‹ŠVPç’;7Žn3¡t&ªCû…iɉ¸Äë1k¸‚nò<ß滌ÝIW>¸.O®À5[f&ñˆ#®ó\¶Ýž #c|¿µYý¹ç©ã…êz†FR—Ìü+³8³D‰)üŒæ´œ›ë8KŒ6w#ÚCî'q™æÚN›ÈÊJz9í¦®çh¨=4r—æ¹E…|ïµ<<_èë¸âXVÖÔˆsy¼0χÎ1C”ÑÔëÜLÆÏ-ëÝlë,NójÁ«Gžã•8\´ìÕ®3ßÄmë|ŸÓ6ÆqûøÊœÿB;¢ ¶+^iœdŽW£¬îØ`3Ýî¶$nˆ¨õ˜ùó GtÒ…°ˆÐ&vÍá gL=u¡úõå>§n‡‹Û=t^ÚèÇÓèD‰Ç{#Æ,"«ð„9•¥U;æ8ÇõiÐÊlbi5[–&®g ·9Q·Iɹ|+fý%b~àjÃûÈq®]óHÿ ¸˜¤9íÑ Ì{E-n'„H‰Ý4°Èhü,9Å53IË–w(dm5a™§ßTtŠ†ö_Iš·»i?¨n½Ó¢ÜÝs7߀›‡g3}rÜ”q™\ïfqyèî³"≦· ÷ ÍÃ¥FûÊõ»OÁq^ÓZoÕ]¬®¢=oÊò N·N•Sƒ“ä‰ê:êO­´‹$šnp ¦>²ñ3ouBÅõæGŤ˜ÕÛÄMÃI¯=ÀE.ô97¶¸Gº"¯JxæyÎñ¥g¢‡ýÝŸœJÓz+Iº÷sSšà@ÍÕžh¤Ú`ô'j£È :Isp¯‹u:×è†)ѽœvƒúžî‘ü¥ÅÑózµß•”f®~.oÈ5¯Âé“:z½¡LŒ¡…ˆrú—+ÇH©ñZ€ÇL¸Þ=šºKR!ëïZèæŠe9¯ŒëÖ‡Š’³óÇ-TùBt¸ iNúKÊ騔ݜk«–,ÚÏ·ìñs¶k¤ sbŸ Ž¡s«k׆¢H⪸²-ÿî¡•E{±˜çYÔ>µø=í¸ËÚ‚Teœ{ ÒèªD…Š7@ër•pH¨‡8ÌjT6¢½X`YoqÇ…„óm,¨©ìl©/Sã@f3.ˆ‰o©Hù¢È£ïDw—ѨÒp¶­–åra!¹Ü£Óð§˜é§gwU0ÒiðrqßPÃþSñôo;|/s˜†2:¨A"J닲ëÏÎè¤èÓo7é/¯6¥Õm3µ{TŠåáÎSZ‰IjªØ’wºFþºˆˆa‹%*<Þp/è(›) f{m¢;˜ÕÑ™‹ƒ.ܱíjÊYãþ:+.±ïÔ‰í ¾.b[¦ Ö4{VVÞ«¶¢vŒ¥ÑC°âÅí ß27·Ý¨àFðzäæñ=»y1ÊBJ·]+,ÂûUVµ‡8äôqÃ%¼:Š L©ÄeÍi­0ª¸6©v:B‚ö|ÚO¯Áœ-øÒ‹gCÖ_EŒ.]ç4gÈÎYÙ³†ÌéÚýpO÷pè| “H}CþHåBòáͣà ܓ"‹ ÿŽ½GÒ9ØùˆöæÆö³¬¤­¹µÓK/úkíë›:¶•÷õÙIãIHP;8u.ëyÑŒÇ æy5ó6+(‚¤ða­^ bia:ûÓ­õ”þN‰‡Ä¡°Øü…sÆcÛœ À1FilÉá¯ÓT(}ziåªäÄ®{½?TÙ'½iôV9 d­œJgøuDoÑ ÔBÑ$1àryôT×"XڸʲÿzSØv¼wMHE˜úÍk ºe,óœ‚}³Œø&&õ4ë¦òÝÉS#wbºl•›©%1_FZØO$d™çV)Z6ÃùŽh¾e¼ìÏÁˆË¨ÒÇkÞeùÁÚ¯|N¸Ål˜ŠcuúêÏR¯öF×8™þW’'× o‰…œ~*[¤`œ¤Ú ÏWü9€,tÀ6q Y\Ñä©ÿ¤òthùÀ„ƒ²$úñ…˜‘kœºPÈ‹1E±\Ü5‚¢}Þ[Ï5^ÐÃz²26ÿ #tÀû/hò¼Y’¬ÎÀš’ìHþþ>µÏ»Ó]ÑÁ>Å9Åei•ó.HÇMIeÒ:NË¥ÆÚ·ÇžEg܉ŒQ1½%gumg9Ké"•$Ð71蔎,Š¸-²˜‹8¡ÐíâËœò¨Ëβ™Û‹¨mÂÞW*á:ðСkåþ•7±œtd‘†ö±?¿®v˜Ù8KîÁ=%vÑFëÒ.aª¥ß/ L®›Q5®\¿@bÀŸ½R"èçßÎleíâZqµ)ËŽ ݤMž©g™­tXùP./*2Ým§!«SRu7ÌæöQt³zíª]ïS¿í‘`a7­­­Ícãù9NP—êâ—\|Çðù…õ0xú àGvq÷Ž‰,K=÷±Ë2êèû~R*ÁÄÀ&sxEç£Ä²‚R×áû{E¸*À&\Ј"x0FwkþÄ­­Äe§r·õJ‰æñ 1w8 à¿-Žá_vØÊÊúƒW®Ã€C·k¼G(„~S³oª“=:XÊVØò t >bÁå±8#þÇËÈ¢ ºþó—h}‰X˜Z ìT‘ ™ hp×ÃÛLxöTØõäe[ °í¼W߸ݳÎI*2Þ}¨Ê ØXAkdk»ŒÕ·^‡°ô| Š†Ã3¬],Ó<}ÓÕH‘Š@óUh+øy=‡/Ú±5ÔÜb`áü¹€ýòG4BAÔ¥¢4LˆȲ*NíÜ Ò\Wâò ´QW(Îm½¼ðžéG?|qøPŽ±¤!7t®ÀTêE†÷ó$þ®9ê4N¼DæøÒ|ö‚·›ÜÌùƒPÛb^’ðŠ¯]MWÔY{úÒ‰Ú‹z¼OÕ#½¡Ár²yÞ§}pL°Y*ÂàÀp0‰²À=T˜±¦Â„²ŒVaýlôŸñy9óoª\¤ Er.ŠPrUwrĦƣ¥­À’Å•’C@z§÷Ö‡ˆš¬é-ÄRd³÷‘jkÎQ µOç%yäQä2@‘Å0GÓíÛ¥9û<‚¨š…á©õñá5èÜŠ¹´`øiè ®ôÂO”~`»kaÃaý Ñç L Ecl\hom÷[ý^nžÖ›eîí/Hûi€ ÞûVAœ «:ùühð«ä³è£…¶>©ï¸CA:A”ágQ r‹Lá}Ü, S€Ì97¢m%Ò¦tÚ”‹3;ÊèTûsã1 ¯,ʱ†2‚ÿïÖp+N±ìÓ–¯T†\êú›üsŒØCÖú’*sçû—æÈ»~TÇI·Ì|U_§ˆËz ýy›UZšÂï*±S¦±©ìí̹öÙV9à+:7˜ÔqšTËÉÞåñîÔWT5†IW³Åææý­jŸw绢s{«eFÇUþ/[ÕïN}EU·š­f¯³8+²÷·ª}Þ DE'ä°Í(ÝÐ7¯£o{šãQmfÎñë1|°ó/ýÅË »&ïr‹¬ý µ¯ê92Ì£H“QÅOûÒÆi•-¤>tžÅ÷²Ñ_»×H¢Ÿc…Ë%æK]fD}°Ä¡ ‰¢Òuð¾€±ãn¿ï8D:Î["`y› QÙÍ·PZÜü¦é” «Ýå­×c¥ü*1°¨·GïF‹Í&E!P¦( üB1—>n£¢ÃWÛÃRѬ›Ó£Z|QâR=iÁÁ¦Èåм„KÇ뚶Ö9·JÍðvß9[r5<;÷®6 ¤¤‘ª:.LŒ¤ëuô& öëèàH1¶K¼P…{ÏãØ…M>è¥F„'’hr‰T6¦|;õ¼aA{Lë-6c¢§ÙƒF^ÂXo ,ôÞsD•æQP8v;g™ûfðˆ^ªé³žCèèGa§9rVŸ;Ñ”Ûf8à/Ñ¡Rr‘¥t?͉ÃÑ'çžÍ'ÑÌ{`´>Ë™™óB;‡€¦°Š!“w&eÁ*ƒô…pÕ1Ÿú–áNk·ÕúD´ôt±P¾¸à—F^™üÿÓÁªM¤ ÇÖ8#‹Jˆ^oåwá3vAªY ÚD¦R³D^Xp2+¹-ãaY^Kf|*”£@‡­P5Ÿ‹jæ]ççEB?³s†‚†Ê­Ú£ìs‘Tþ,Xæ¾võÜ浕º¶löåùÇ­cufÓJ^+pÚ«EÊ›pBM÷¤¿zzðÇsAŠ¯ ° ú/g8Òý0.¼Ô)|ö’Ô¨ÏãJîâ’§V~§xãðjqþ¸“¤”"‡žoŹ‡\ô^°yD¬JMPu.hç¹Ä\Ø ÝÔJŽ¤Á 9qF"³Êt݇ùžC_xì¶òP }O'1« {Ô±u™†¦{~‘üÁS¿¶*p&Öf•Õ·9¤“ô‡)\/là èí5ãrå›d&‹m¾ÉÈñ¯Lö Ž‘Ø#ÄO)7… ›òXLiæ±µx똮ç¥îÙrÞ+—H»¬f 1Ö%—¡íþïmy𶂱ä¬æH Â…ø­ Ãoûõ| —ïsV]š-n7Â3}šT)húzï2ëÍWP™³ÆiWK´—ß²yý™­ ïˆZÏœšLÞÉõhB5Ò·×L-²¸¨ˆ+äý—å·&lƒ+/iÊÃÕxõt5+é¬ÓåÌ×lj.ïε¤âü[ìû¥CèŠçÀ°ÿèòorïœ °X÷¤"|mÕ#PN õåp€ÙÝËdoBe£õeÂ+B1ÕüúŠëæüôün“ËÐF•b«½,ûKGÆs¯lÙCi´OƒºÑÃ|Í .+Wvdz/èž©ùç¡p°´«n±ªõAL=ûUc÷–€„¬žý8#Em³Lèy\Ñ~¿zÄø2v`´˜ÉªPË…cÒ§;=FÍ> ´¥e¼žqàáè°0{Jq‰w^'÷t†Ûı®Šà| ~¿üíÞ,#cK/­„iâ^‘Pô5YÞkK–Mj÷–“ l÷¯&¹îÑ?ïT+>½òC±èµç‹H‘&±!¨óó Z²óXA×=qZkعä£x:òè”=šQm/+ž¸A½>—<®­¢þA+ðÌš[¶)Ùdq^Ã_X#uñî_¤9¤1ó_´ØMNžQ…§œ-Ïh-dCëtv¨›Ù”ÔM@FI méÈRƒ8÷”Öòj{ÂËñ*>ð—À£µ<'EœB '¤$¶?u_Q3¾’¾9út¾ßî˜lí[T(Ï"Mk=kL­£†ö×Kp„µ?¿ÏøS-R­±4ý’´nå!ó>stream xÚ27T0P°±ÑwËÏ+Q F&@¡ }7c ÛÊ6R°„ š+@… ,Í L ¨¡!TÔ¨¦Ñȶ±íìôŠò“ƒSK¢õ\ÜôCR+Jbíì æMô endstream endobj 7 0 obj<> endobj 8 0 obj<>stream xÚÙ’ã¶ñ}¾B•'ª²Bˆƒ×£³±sTl'»S•‡Ø\‰1¦Ä Iyvÿ>}IvœÚª 6ºFßÕ›þéÖ¹ŠóMæbUùf~ˆ7OðåÏZ v² `þøøð‡ï¬ÙªHíæñ¸Dóxøwôn«£v»3y´¯¶;U‡úCOývg­‹Ú#þÚèOað=™8¶ÛŸÿöðíãHߣ¶™ri†ÔÿûðïŸãÍVú·‡XY ÷ϱÒE±9?h+cRyo>>üóÆ^&l´—|ڊˬŠaf¸·\”˾Ê6Y±-_s-N•6QêcYÔÌ}Sö=2ï3ëå̪÷[9ÉÈ\1ô'šKÌnŽž~lTŸŸ¼ó œÄ€Hཻî‡k7}ðÇU^pê~ib’Dÿa0í‡]ÛÕ ÕU_?]²8³3VšöúÝ6¼@qÔUeß^z~iê_üªám\_¡£’÷lB¸ãb}º"Ûò"*ÚGËoípªºž`Ü Ù%Üf:Ïå1þ²…-•OBœø[ö<áà7ʤ›öyâ8~SÛ]ª]ô/ÜXå7¬µ*’”vÌȘ=€QÃOË¿WTCÕ55ü^*ùx*=˜_µ."Ð"S{‘(?Öí…Áêž/­ŸÇ:ˆÓ:¿ögxhʽ`Cí³üHG¡³è£Ci3äIG×ÅB«ÏCu9LØOÕy¶Ñ„7Z(ŸiŒ»…_óº’Q6Ká/ÄÅŽG‰@ÊË!­‰'<ÜUǪ“=ƒ ‘Aá/¿n“4*»ºÄå6$Ô©Aºx&3Ôçr+xóÂ[2’\Ï"9!íO–vr¨v7vŠ² ßc:b <ðžºò|®/O<‡sÁhÆ¡úg"¢ ˜‡B%:“¯UI]·Bb綣“Œé€ÛOWøËJ Âèl=žä{‹Ÿ††Œ°:2/ÔÄg²Ú-"x¬f¬ø A.ì´Ñ*É‹3Ž-žmC§÷B«€E$iýy”Y^™0q¶—¥e5±Q.N6©udÚÉ´¢uÏ7ÝÓÆ?~ ­Ÿ± ¦,-í+.Ö¬IgÊæÙœôª{˜ûÄæxj…ÑZg iËŸb|aîÔ,w“ã<\CYÏëóûÀøìë²aˆŸ´uhŠÊ¡”)d¯Øß± h+¶*OIJöã'6è ô•TšLç…VŽ÷›Þ/¯é°šOQÀž¿•þ—f¼„SÎ2CJŒßú» ìúXoRˆÃ\þö3vÁ”UT¶ÀŠL°kÒ…2¹™“^†esŸØ(°Ëb¯À,ãN+0,3Á1å žÎÆÆщ­"¿Ð‰X8 o­hïc·ð{™CbˆO£[ùªɃo&ð9ˆ(ñU"J|üq¥ xÐ6‰¾9HÉø€AãÖ‚>9ÏaG¡V7œAx‚òñб*ÇX’¬¿xÚ·¨þôÃcÊV«„¡e~+é17 Q )H°åQ‚ø _ž›’ƒ¬ƒº±±Çmn)d²Ì®Â3•†ÁpM1J]Oq´8:²ä³8ÚJm8.‚ß7„ÐD±©ÎóФDkøŽ¿¿«è¯OO•„ñëí•·â«2w' I…¼†ÿ0²1S72pèS@Æ¥óSœÄð#¿‡WÍjèeïõÚžØ8QIšo’Ô¨”S¶¯Ø?cLYªøëÍ,•¸bNzaO<Ì]b <â9ÓÑ7¨Ê” 0#žIV$C®X#¹—  Æ(YÉ0YI%YA¦Á#XÓ ˆ|Òy˜ÖUM]’[ by8TÓ¢jy%´º‚H‡F_^óߥœ{aÝPÖM/DZþ ¢ð‚—<ð¯íd$êOOÔÜ8õ8•®‚•f!å£â¯‡ù¤dþø<lcÁ+ ¾!`Í-Dy›Äæ*KÞ"ž2aÌXEsœ¸¥dM7W²‡áe´*0÷iÍñøhÕ˜¯C=¼`lOàgŒ'ØÀèÀ„ ®ù±¯†÷5`¡í>Z´ d–†ggÒD剛ùWÌ{Vø5ب|Bÿ}5œÚÃÌ™V©ñ¯¤ü)uw£ïº6ƒdÊËΞ´ïÀ·ôc´­‘—ÌkaΙÒT'JDLçLsWhzÜÜñŽ.ª7>„µqö¤[6gá%V1,á¦`¾vÕ¯u&¹€äiL±«1ŒÙódò†¶ÑõNhQÍ+Åuådú‰ð̶äÝlíù¸&‘¸ivy–0É =¨ÏôüãòXÕ ò#£Ò¿Èi! »Ÿ÷ü"vg)+ZT:k þâ6#¯½à·z yµ(P ȈàDât^æk$‰Â‰^Ö,xÍÞN5Š²Ñδ£1ëS¬ÆË(“Gkù=Ô=XWfëA>]å=7ÊjíƱ*lú7-3vÁ”•ç\`E>¤+Ò ÖnNzé¦æ.±Ÿà&NŠ(À .æ!Â+%\KG ãv’ ›Ä¨ÌÎuø™m •¸AXl,Uá7•pueê€Çal6…²,eÏÞ3ÑÇK[ãc4ãMC%ecXñ¥öyÇ4ÑÀÊ_ðeV\ÆEÔ²¨i‘óäf,}¢È¡Ûd·°® ÇÊZ®¤¹~Kš(3vÁ”uñ~Ž¹­I'Êj;'½ªÞ3Ì}bs<,/œ&™2(ÛÁ©¯²ªÍ32ÏàZ9 åͳÆ6Ï'gcg ò}’ÏAii«=Êg{Š$5drrøxGŵ°)øM3›·¨¸Ÿ± ¦¬¸¸ÀŠ¬ÊפseÕ!éå‘ Ì]bΨb…XÈUÙýα,l> @n1FeŸ6.ITü–ÐOØM3V½¡9N$]¬è:«]Ìè.›wrÒ‹ÿ,‡ z^gji}|Á%1.ú{}®!ì÷ñÍå^΢_q%È …’?SÚVŽÁ“¬.ÇŠD@Î÷;aÂ¥zᇠz¢ž½þøåFÊU]Ž(\­u,z:$ÒØ2!ƒó˜ ¿ÇrXWëDÙ<€i1±µ› ¿ÍþFé²C³Ä~’š© ‹p.( :w£ž?-KZb7:õR/pÚD¿\‚äÔi=m“_¨€Õçºz.yˆ­–€¢ów:–¼c8M%•ÞãòXKÆ99u1i€:]ðÐ_)€8à«N‰ºqéâñäË¢Ž„¥ÆÅ’D‰ÅŽ;3ØSSŸÆl+¼r!Ø$n†yÞñÐxgÆä„cI…Ÿ}K¡=â{xÛǽÂ<¢`áŠÃË=Ô0Y¥\°9¹½Ú똯°Z¹ÄaƒÞ*Âúúѵ•T±-’{,Þ-ªç×`‚Ò¯ãœøŠšR› °&¾²‹E(±…Wø*»‡Ÿ(ç\7Zë¼ ·a%Ϥ“ /ƒÜ‡ ¯ÔHjÄW9´Ü÷ÑbYªFPúÑ°,ºŸµ ¨Þ|SãVÓ©0a¦VQàG?TŸåz Sª¸ëõ>}¸S‡ì4iõ'M§ï™ÒJª ¤Ü@0©X*3/5NŠ‰X ¯Ô&£rC*µ¯4(§Ý[¶fœˆ;4†®U¾r‡Ë¦~b@ÓŒÎâ:Ö»n• ÄYb~Ky ˜òZyÀƒP°óZy`FúµòÀ]bs<_)·áä÷›zï‹î‡’«,¦†V"±UöI7 · l©SHF‹ð2ÜíE˜P%qª*åkp§ƒ–C@úMW%èbÅ 0nß–0Îújý…}ÚXÃøÏk!ŽÓKŽ!vt¾Gr]µ¸9ؽc箥–ëû¦*åfÜÈv|fÛ„]ë…ðþJ7 0ÂÖ&ó ‡< +ø$ y\¤J%oýÛõ0]”dÚ’òtý W2»'TXv¶¨Ž×EÙ L×EiS8§ ¢¦~¼ÚI¿·î¬.or '7L‰apI ñþx„½ÚŸ€£ XÔýPu¯·i¬Ê ß×é*n£SbdKþ3?²^ÅãÆŽ ãÀ$ŠÇ¶;ûÎ$Œù{¤W¡½’+)ÿh«8çl˜KHÕãq,™Ê=ZÏÛñ”H3(h§«µ°TT)ç÷)¸Q{ƒæòÚ óc;Ôýóâúäa†d}µ+5ÊYÏûçNB8±Wùn åâI{¸ R@²„•¹¬Nr*gÓ95¢„$oRö£?ä²^DnTÖc¥§÷×`¨<ž+B†çJï2þÊ]Šû àPKÔ¢F&Ò!"•Iˆi¬ 䮡²¢hâ/_;‹Ä)S¤K50¨ÜÄÚnŸJ “sß´ô"njَ­ìé"òª[ NÈ% J¥“7ÕwdÆ.˜B..Û¤#:î{¬©Ê2ýʵÊ ¸vsÒËâAš)]«ÂÜ,ÉÇ£’â ÷ÿ¥ûöwïÿk8ŠÜ¸éÿ2¸M›Ê©Jò¯3³Ñ.W67Ó¦Ìn2#{A.©\<Ýœ©žÊî@V»ê%ÿ#?‹é_I\Jζ±Â™6Žª9 e”I¤$DÕÅ#Um°‰£zm¹œ)ʼ 5,XªÉ•­¯W±–ÈK6úRÓº%E*üÊÈAÜȉ«“ ³EV¥¶ô—Õ4HGšÞÇHcÖD‰Îy ¸$Näðõâ¾l~òÄs†)M&Hèvk1òòÀc¥ÇšP„#·gáŧ_pè†B­‹€Û¦áʃ¥Ë~…`ÅëºHI(\ø÷Û¿ý°åÿ •z’z–Ó÷5,=ñ7íïûúŒt¢ãYô{F÷-`&¼ø’WÖ¯(¤xK lî.4ºî¦LXð­™ müÿs£±5“&·µ¬$¨ÐÍ®ƒMñ7øð?¦àe´ endstream endobj 9 0 obj<>stream xÚ4Í1ƒ0 …á«øö )I$”©ÊŒ€ 1!VP†¿¦q'ú•ØÁ‘Ð0p¹Îú DB|i›¸8¨Ss$'¾±u0;J–"–A©oÔ Xõúâÿ±SÛn¯w`Ý‹ú·1gïkŸºòø.¼Ÿºåü`±8&U endstream endobj 10 0 obj<> endobj 11 0 obj<>stream xÚÍ[IsãƾëWðTe¶{²c{”Škì$¹R©±’耄†-+¿>oéÆB‚ÙžkjŠ  ·÷õ[¾÷©…„j¡T&d¶H­yž-VÛ+¹¸‡'»R¡Ç2tYú|u{õùÑ‹\äÞ,n¹]¿Kþ¹¿VI}½ÔY²*¯—*)×›ܺo®—Æؤ¾Ã_“|ón~Í÷´”æúçÛo¯^ßvëÇ©M*¬OqõWï~–‹5ìôÛ+) ¬÷m)Tž/¶WJI¡µ×ÕÕÛ«MÈÒÏF²d½(65BÂÈ¡,îxS6ý(lÆËÅR[‘K?õ\I'¼Ö‹eÛunØå¸+Ì‘ihA—Å+uô kÀýØþ+Īà”)‘š38ñÍ¥‚¥µ;;u’0·B´Î„Íb.EæL‡¹Æ³9Ȩ âX Çl…59¡þ÷×K¯“_ÊU{‚?òb0åß áˆ%Ë?p,ØK÷ŽÇSñ2ŽÏ÷ÏÒI— —êO(œÿsÛêµE)7e‰tÁ{µHU*R©I'þò“tÝH±%Ÿ—ê¯×KkmòêûÿœS“~?$žÇ§8ÛøR åg¥G‘Ú”¥G?¿QjஂsÀÇ_ðãÁ$œÍÂÓ%AWlÉÆÎ÷×kç“¢: tá<b·ÓKÃУ •³*äs#ÒœUèÝ;$ŽX¼H‡‹\œüŒô¼ø°nfÒ þ©9pnV‰òc%úŒ#öPf”§ßâÅç½ÐùY¦Hþ¢«k&è‚öŪ% BªƒÀ 4‰{ø¤XaŸ6ÚØþFýN.$g…±³¹b«gŒÚDÞ÷€˜<‚Üû ëI[~ys­”J^½AÖ÷:x¡G`‰iR7ˆÎ—p_ÏiR·•OÒ§ŠdÞja²y”¬yÊš´ªê]y¤4Èxœ›c<ƒE.NI€ŒYÏÊ¿R±–¬KÒ6¥ˆÃ9©û©/NjÈ(l:êZ éùÔˇ¢jPܺ}è=Â(UõýfUTç°è¼8,¤NÍk¡$k@ù{O¤së“Û‡M¼‚bU y…ïcÄ¡ÛC‹1h4>ù%¢yÞvúí]r.·ÂùY-ry&€Ã"p?Ie‰W›ÿ•1ÁÌ't¦…—³êâ23±Ô÷e{³)«uó±¨Ô•…Ãêý;Ðï“ŸÏ!ÕoçÒB‹K¥ðƒÔy ©Ô m ¨‡¢yøº¦˜º>Ž0›"Ò–÷³Td°ÞÅ)Ë„T¡¦ ðZ茕¦ª‚c»5ZO[ˆ;âgœÁ¡_ìâp°hù¼J8˜Û M[´›Sö ërÅšCY¸ªúÜO%„û]Žu°—‹ƒ °H³yu1™0)«KÝ°HÙß‚‹ èÈa˜vÉSÈYS¿‡‹ƒ¨IfæµH{aWäÑ\‚ ùXÜég¾8¡a‡Y:¯Ê ëÙ6²Ô_Qè2MmÓ•ï|ófLNÎaÒ/üç zŸ¢\‰åb'Œ£--Ž°òf,½vT9˜À*ÔÒVÂZf·7›{¬ìKDÃ';É“¿ƒö¾½àQ/‰à•¬Tà¥êöráý€FXöÃø}BÝr2R¦ˆØ!fO½¿úŒpµ*#μãÞ¨Ù—Tƒ>gôÕ:GÁ …»EÝÒ¹K¸˜L˜³Š­C‘l0Æå>ÖÁŒâ<ÿŽ“!d4K^¡Â¿}ÝÁx+h­÷a®}ÙPv o¦»â%¶Ðð·¨*n„È]F=X‡± PÜ‘~±¢°¤C]ª\ 5p¥¸0Ö¢¯p¢xZqbÔãâP…S®Q[ªÐ'ÖNéǗy;ê´| vÖX´%?Â#R|UìÃéwªß’çØÅKÜ„ˆú¨ÈUbFªîÄÏ8./d+ã€šË (ŠãKœ9áu_òQBËtp>´·†—FU–:rH¾ˆ$mŠï£ùJ>p 9X¸CHølX)ØÒÉ×õö Œñ0BúlähÈŒ3ÉÓ.žtð.Q ›û<Œ±¢œÅ Àgä.=æ\°Á3àÀn:p  E' cHl§G=ˆm”»U¸ä%&Åû*Œ+vx"°ûqÅ~B'·B¥ùÈkœÓ,ù"êB)Ôœà@õ¹Xé-÷ÓJ• ­òY¥~Ê‹Xù”£pÉíÓMóˆqè Ø*‹5ÉßïøA_ƒ~=).Cƒn~@’Ç•húPEj?&‡a¸¶þ$ ÓÍÉ3'Ìàõ#p6­"„·?üøú(9ת×0ptL‡Ÿ6My:¡ÍD*£BÞ¼v:#00éàÜ5iÓýaªÓÀcÛÓ5°I×`j~²F&\w3!x.~ŽYä´Üz,7,µ;J§B;/2n'mg&$ `5<Ö¢zBO]Wo"Ç$•6RF¦bçø"dÛǪì0¤ä”ó;2í¤•^ Œ Tð@¹ZsÖù˜T8}úªÞÆÄ2˜ f¤ú§«ALC‰Ç‘P j¦'k-  ¤`Ž¡c=þ†âèû¶@áÚéê›m~‡§é#÷èõá)(¹Ò$\¯öeˆ8Ǻ;Q>8t%¡ÙŒQT°k'»m!‚õãó©ò ¥ñd#6]\I±Ñ¤9%MÚJ?˜›%oqÀ²At*]x‘§–•'Î !Á³öŸ|h šz  Ã…?ö ]Ž—Éx–àvÐÞ–ò@¼¨¦·ÌÍýS.k½i–¾8`f‹Gsâýéº^¤@-fÀˆ]fWÍ2d±+OÙÐþýЫãÒJËyŒ´y ßG–c¥ë—{ÂǨAç×Ü·«ÕàÇ0H>žùú=y@nSVŽûbÅâ¾äU˜»V]}ÕRCC"ç2œ0ðÐèÖ©ST!Oφþ˜éé,?‡pæä,=…”1d]àîiÑ}—„ñãUQUìÝAß\DlT ƒÁ+²[Q#>}ùkO/åÖ1G5Î Û!9ÀÑT*‚_B½ø/ÆÙ0®‰ j’Ýö¡hŸ èлpLÆKH2š¶rHt)H¸ÝÍØ1R¸9]EÃgªÆ ´ã‡Gþ-îZJb¼ ÑeÛOPJ‚X”sšÒ[Ãù m²ƒ¾ØEçJ/¸ÚODˆ°RAEëŠaeÚ­3È ®¹ÝÑ°¦¦ ¾Š§©3H2ü–”» ÿ²Vï(âw/C x‡Ç´yR°eø|w‹§H‚óÄa]¼ U(Zî×ÓÎ&<>·Ã q÷å g¬ê¦\Ç`²>â#gÌÙÇ!|sк¬J¬œ­89;aUÍ©iƒ•i´Cúê!Ú-¿<V‘¤QAÕœR‡ºùROW aâLE—¢ž,­ráÒHïøë<£³Á:ar;Ü*©YŽ£ "£ålèòLiVײNO…¹Ð@;_ðžÂú–~ö»},œJ«û¿A° ü¢*c"±<ÕôëûHÌ"…Nüµ¬røz°ä ð7õ†Ë=wµªëŠŸî›®HôVƒa•|ÁHP;<9](§·3<ü‰ÖÀÒ-‚‰: ©pE$¬Ëx-ý]ùĘíºßt¡NŒ†Š±ØBïÇþŠÿæâ\)I[nÓéó‹ F7ñÿ¨AüPC¯ endstream endobj 12 0 obj<>stream xÚ,Œ1€ ¿Ò” $†É0u3N†UÃàó­Ð©×˵΀‚iÂTîúò@~`·bÒÄ:{ÐÊv4‚ 9 ¥D„Q4ò£Æ\ðÚ Ëµ6ÌòÛþyó1âò”kËõÀeN¸ç·ž1~ ¬$ endstream endobj 13 0 obj<> endobj 14 0 obj<>stream xÚ•ÙrãÆñ]_ÁG°j c.Uñƒ×ñ&åÚØIV®<8~€Hˆ„—$\­òõék€Á±k¥T% =Ý==}Õ&?µQ*“|“Ù$.Š|³¿Ü%›#|ùˈ€ì˜·÷wß¼3zSÄEj6÷s4÷‡_£¿·[5ÛΣ}µÝ©¨:ÔW˜:vÛ16jñi¢?€ÉïyN'‰ÙþvÿãÝ÷}Úd±M3¤þŸ»_K6àôÇ»$6@ïÆI¬Šbs¹S*‰µNåý|÷áî+{±Ñ^òq+63q+ý¤s¦lö‡b…Øò¥Ô’4Vº J}¹ßê,:L*”ŠÊ+öÂ\œ—Ò±Ñ#NT>ƒŽùB_`“"ð¢ï8‰úF@üÊlð±ŠÝN hqCö8ÅæêyƒÃÊ’ØeéäÔÈ©XòÁÕò°LÛ\ùô`ûÅ65H.×#¢> auEÔÖ´öpn¶®ˆÊëØŒØKŲ_«-â$——â‘ѲQŒžZà‰àÖ¡‹Ç/á!xj-bYŠh"˜vО[{ i±LDâTMdÚVU[]÷+,Ç>Õ}ì})i¨¥yu ïùT²§É'’bµ¯Ñ mî¢ ÅÇž49[¯²*Î2o5Õ羺’tIQãý¹ìºŸÊK*œªTTx]‹­qD3Aš›»…æ’H4x2­ô,xº„HÇJiòÍäüènìßd‰y£èKÞüAr "ºoZÔ€ãјi¨ §Ð ¹­Yø‰÷Œ¸Ic‘;%”Ôn\nEkNž0Ë7íqã‡ÿ S)Y± –P.•mÒ¸È,©î€lÆd$»$ƒ'›‘žçm³ Ú Š?/<ƒµ£”žOuœqftâãuJ žz’”µ˜€) ø14zšÑyk¶µ+ÃùÄÇ«þFoP V9ÖØ¥^ºØ¤Þ)•í3…‹„T¥â|ªUtS¨µp³ˆþ®)èò#}ƒ)2Í~ ‘ù,^@ƒ£tY5Ó˜ÛR¦ˆ$cFqÀ¸¼/¡ú“ŠR*k£wÛÜÛG KÓV<Â(ZŸ;YK&"®§—†YÌLÍLš‚ãÊ6±<ï£Þt(ŒYÆ-šâY[ý•C¸¢ Ãwvw0˜E'_§˜ÜŸÅðpÓ“Ô8­yõæ]‰úæ‚i©í²^c‡žá.3TgµÍ±"æ¥BÑg ÀÍXËu<ÅN0œ&E~¢PŠO × W>ïlnœ¥ À‰|Ý3¿„Ù¼raLÎ¯Ä âïN„æ¼VŠŽU¬®úçâ¥èïs=ú{¬{­2\RÓàüŒ ´Á—Žçž¸õCé * 僋[¥±–úK‚º©©%GÁXøhpä³½zäY$ ŠyZA2›¢%Â>Ír¥j€ªÒŽÊ‘nÈm2Tbd¥ëH‡à¾XÑê~H”2ëÛ/3XFÆ–‘_ÌÅ <°yÆ4VŹöi,Éóv¤ÔÿÖ³ÍöCø…—ƒ4Ún¾çég¯q $·åÇáÍF·N¦© —Êa~ŽP”Œó¥_Ôõ¨Z‡þV}./OgALŠyÓëöÞë0®Ïz#þ-””ÀŠK©j 2ÌÜÝhûŽße|†‹‚r®[X\+ÐÜ,Õ×퀧ä‡wQæÝÕƒj¦=íG°KÜÅ ƒr¼_f³ÆÀAj¨r‹×d³²b,Y$˜3¬(£·ƒ';ö|8Ë°(MÇ 3_èK~…ºô%m’Äp”C‘±èÌj<@;ÀýñÖýŠ]°dA|†©ë$Ñûy›@6%?ï] ÌW ÎðÈv(Aô¾Âz1Õƒ)ãxÈùõû(l‹ù·Š¾ÛsÞ 1S¨žÚª ’ê퀧äúòc‚ûR rধöˆôj_d ¹ÄtˆVœªA-¤³I®«ÑV}÷Ïž5›ßÈЯü2vÂÂvèŠEû4ž¨×!)9Ⱦã1ö1‡} +PÝSÒÍ %Ù»µÂHy„d±!øWGê–Á˲•¸[s)uãë)%nGO΢EÈ ®R‰E{ÖèWUÐÎSŽë\Žƒ<×ØÅQÉng"ïÔ /kyAR80*ÈƱ.ó}™øÉí«e÷B†õÝ"IÖË ž6 ©Û4j¨î¤ñ«l6ìj/ï$?›Šü`¢ôûeÍdÑ€ïtfÑ#©þ¿OëQ vnSßs=Vý[¢·u°ü‹]K—ÇÖš°ki3ÉÉØüÓöå΂÷ÿ¥ÃÀ¼`4· &”M÷J>l¬”çM2c@ûv“­Ó‘ïÀs¶ìó3üBýG€ ùñ…çHÀ8(çÒÅÉ» b¢¥­¤ÚCñ…Ü ½›çhÆêj#%ÙI(ƒðê  O}n7מ_jyßK~\Álû1¾ÂÌÂäPðü‚½@°Û¼\øúÈ:ÉVÈÅà[éEVn­û iÕÌ)P¡¤ó”Í0¶%§×˜#âGž ÷h8>Œž`” ¹5P©7|eTÇU¼Òn*«uV$whQ§ÊgTªòçÚ¯ªV®cg|›FxYbÏ©ä;ýOˆ¹éêÞ㦃"Y%½ê¡ô†/²ÀÍù~(.”F•Ñ6N€›0‚øã n-·Z±H;E¥œ […— µÊ°^š\Ú))˜°Wɱ³zêG¬t\¾ÄÒÀ$ò½Iaäaî”q.Øas©Ö4$TXÜ›6^9WšN(»üÿÿ:͹‚>UP1t<ÁÅŽ–ýráà_´äÊP%>ŠW]n± ïG±¢ö#yþÿ PÞpïkìùÚipÀK)©ÍÍý©uöHU6Ýã…ï»gBÛ·ý`øßA®MP¥ ß\eqžó•¼Á¦’Ríû-Ý\âåö¤£<*/Ü1äU´ã•Z oÿŠñÆ[¶˜%y) PH¿ü­¥æ2Ÿ½_3¯“<Õ,oâ{ÄP FI‚>ϲ³˜ÄZå 9«ÕÅ«:‹¼b,Yv§X×;‹©£_TLHÏ;‹óubS<¾í"zð}sK „r x/Ñ ÝŸË`×ò#‡Òß‘Ø BZ±Z_¢šÝ:¨§¿A ?ïÈ:ÛÛÐpó=áz¬ÔÃÔ orœõ~þC ÖxìÀ Å¿'’¬}›|ñ*ÓX,¶’ð¼é/aø—)Z!IžÀÊvvÓI@‚±#Mƒ:σÌ980«?íø¹Ü•JÖó"4&xÑŒlÏ÷{åðë‚Nº}üø0q_ß-²Ii¶ä´¥üìÅùÝו#r)=Ä©{r0‹~ÔA½q{–3/èÄPÓ/´[¾s˜¼­5ÔƆP™fוœýÓ…Yùp®V´Éÿxir‹»û4NÕ$Ñ_ùÁ”Êtœ¥«íéd9FñŠŸRYC?]úêO©Tµ‰;Ü-¸¸Èr®å‹øب”ó•áRÀÌ&0ª[bå°g爲l»“pí¯×J:‘ãmèSQ?½žäëT¹ Müh‚]ØÑ-÷§¶ ¨`MŠUr3-C—Þ•¿?ÿ,>ŸXb  ¡ý¸…¡’µ`BUD„¹ƒDúz,YLY~¸`¨}öºÓÔPðì ¨•¸5A?’)èjÓläÔa+‘txãêÉ8n|á“óÖK}fé}Qgœ‰³B¯ë TìpЫ} ð >ü‘[¢Å endstream endobj 15 0 obj<>stream xÚ,Ì1 €0 …á«äé‹Õ¶ ¤³¨›8‰«‚tðøFÛ)Ÿ8K†úžÓuæïÀ|«ÛÄI ÅžÄØÂF(TÂŒ©3(t…V"ÅZµ°Z»êFýÿŽ‘ÇûÚç#¯<‰—ãÉ[Œ¯˜¿!° endstream endobj 16 0 obj<> endobj 17 0 obj<>stream xÚZmÛ6þ¾¿Â(œ[³¢H‰P¦íA{é%[܇4´¶Ö««lm%9›üû›7êÝNpX,LQäp8œ—g†Ò«þôJëDÉÊÙ@¥i²Úo‚ÕÞüóFˈ­ ÙÆ|wóíO&\¥*ÍêîaJænÿ~ý[½Ñëj³ “õ.ßlõ:ß'è:4›­1v]=à¯Yÿð:_q_fóáîõÍwÝúž´qÊÆWÿëæý‡`µN_ßÊÀzÏДNÓÕñFë@…a,ÏåÍ»›/쥧F{Iú­XgT3‡{qS¦¬û¢ØdÈLl!nI¥Q4”[+¦´–Q ¦ÃhýÚ»]Þ44N’‹ÖÚæå¾A¦F¬°ÁD™„ Ý=æ(}Ó§'”;þf'þ¥Cið€Ú ÙÑ,Û㟎(a@Fc?ùºèxñ¸‹–˜)<@³®Ž<²fU¨Z!WfMÃÃÞÜo¶Q´þ¯'´k+z.aLèÖÂZ¶cjÖ+måÓæ÷(°:'-²ý¦Fw ¿í ~ž7@5ÛcŸ¹ƒ(Ç¢Ìjîh+þ}¬pÔ3SÉKZÿ˜Ÿ°³m¸—$æiƒ°ŠN°Ò_çüø'ÆY’DjcÕfkµ[ÿ´AéËòôòSv|‚÷¼è-¼ˆÝºÁ#½û w¸‰!"1d|œ. %ðÆÑ{$“2ÏðÛ’²@##ÖvÕ™·&£–Žúû#"¬Ö<Ôy[~êG$›Ëê÷^òÐÎ à¡f6ºWê0¶ÊY£ íµö…‚=Óæ¦6ÄÊÄ©Œ®èmM¤•ÖñXNLöýûo<áo>|˜ÑÖAªãYÁã ÜúnƒF{C>í¼å)4ˆ"2=‹Òô‰JTg4A/yC2Cá- G;«’T_Î -F¹0í÷»-(ø—SþüýA:­ŒŽ®R‡* ìxé‰i ^Ë^[Kã©%Fh=eɱ­¢R²†!4ŒJµ¦‘ÿªZM-ˆ'k±eHPÒY4ü{ªø÷ë­fÉ‹'r¢ž) ÝŸ‚Ðäb÷"´íJkRe»sy"õÿˆâOwo"%^Ò⬽ë%KÃxý³x´ÞŠjð„M¤þ Rr‘ ÜX¹«qC®Ê’i÷è›ôúQÞ¿Eoøê? ??—òæ 1ý¢:MÃaè œBüŠ«‚Èp<Äœ¬êÃÊ7ߢ£Ÿ±L™Fâ)UÜ‹-„Ê‚:Œ–ž„b?æêb:|‘æý“©²†¬-ÅÇMCW' Á±¡\Éâ÷ü²ÂvùùúìÎ93:M ¾Ï=:Íæ‘œD‰´#»&Æð@?ŠrXpÔ¿åI‚˜ï‰r]pÆ5dwÑPý…‘O X6aÅjy i#.VyéALÆ%weŽ!‡>?â¼*Ó#ì¾ï¢ÆŒÈÕÀÎÛ X  Â‚Y$ÚÆûÈ}ÎÝìÁû3;”Ì#?N·]=8uÊ ©N!pHkðMqjŠ=¾cGwݱt W¯_Îü|ƒˆŒˆ8=g’õ¯UíU£ž3#.<(Ф™R=:<²£ z$³'ÿh‰_„·èoùHîÝûü!#Ýkåå á¾éeäÊ¢ió½AÓçÛôÁϦ!IôL’Ñœfujæ^56*´>Jòö§"'(Ó †“:O]+„zgü Q‹¹³€næí£s4gG.W„ç炸‹ ÏXÊn‘Ž$pØÜee7sHæŽÀ÷4\,>*-Ó,%g¨DÞ9U Ÿø<ñ†ÈDuºåw÷gŽÈØ–M+b‚®¥< û³†»¨£õ =¥ACgŸÔbzcÓõp“E)óš'+çÕ;?ûŒŸéoàNÒqâ¦Î: *ÂöþÚûœqJÅ!"* ¾*£,ä™Ï$0RtJ8¹Ïy6çÑ»òL0A–ëbÐÑ{5Îqœ®npZ49Ö¦8âXÊØ‹l‚ÔвHJ§”ðÏCgb»D¨}Ü׬<3:ˆj†©Ö¢Ãt©2AÒ'¨±®äÈÍsgE¨ÕIBšÞi’v ¶# ösÈÏɘGR6™X Žµ`ái8SÑ©¸ L†œ¨íA´ÎÕAÍóÎ8Rq”ŒD”=£h$½å´¤D†´,(m墤¸pÅ ˜}>vL¬W¤Ž«J?ݬíÜi)Ž £Ï»þìÔÍ8Š(ÒòŒx*Š­±Éúùö÷&ÿuä½ [òahµ£Ã‚Žcö§œ«ÁâÕY ¢±©dÄâCN)¼‘BÃI8+„þ;³dÝy—Ä"¹±J'ñÊjÈØ´ý $âglSfq}BU° À"䘋PàAö3ËEõ0JTê?bwš5˘k Né°1‰Íƒ…Ök:U0a ß{ì²ò *Eª€ÝRÅmNOr™‡™£ñUšO×ÉÍRç«7o~ãͪ59L2À>R©°[.ó[~^PÖxx×å«´zé ºZÐŽA™ÚLŠE^¿Ã$„¤0ãZÜÌÁ%VŠkz1¯p|‹˜˜JÅ—h™/Chôû÷ %MecÝSÓL«’8_gm%if˜šK9~ÓI rä˜/,œ* ½–eèð q¢ ´Ã€ö$€`Ù°Õ8!þÌ]Màè\ÑGØVñ/Ÿ5¬ñÌÏoŽù!§ù7¡KšÆáú)£ Ÿ”]º"¼spÜaZž•'Ü]ÀCÕnH¸g†4¶U]êZ¬y”}ÞþÊÁöÎ]yÅ…ïð÷µ‚¤„oNè]°éõß7øOö¬èØ$¥"Øê•:càÖ}Ý¢(™~;ºþÉ… 0)<ôÔJ™Õ¹~)7wÝ´%YV#À˜”ÚûÊ{òp§øòÐÄè¾YEƒáýd ’ÏÙß.Ø”s¾®ïùEZûŠ@ùÓÕ´%þ x¡Ì¢&µÀ ]]G º&G#¥~Ãå¸ü»…'†óØ=Ül½ý§6# †n½÷•AÈ™¨>¼óÊ›]wwϼçhqòÿÔJåo)5 $)Lú¤Ð^M ›vãƒóNÒÄ|œ^Ïö^Î0pÓ]*x1˜Dsþ‰ êmÔÕq¤ãPÅÚ{‚4QB9üÈu£‰RÒÎÁ/Þ&Š’¾â‹¾†í™ò8á¡8Ÿ¬NY·•€Í9S> Âî‚«‚[gçO˜xw)ª8„"2ÎêÏμ(ûNÖç¦ t0´«=ãC—±ºt–òb Lƒu¡üþÀ%DI°¦È d÷,ž\X Òö×ù_ç¢îéR „þℼ“^:ÇRwé¨È‰‹¼×p¥Jn/p}Èo;#ÜûÍÚÀ—_aà› Õ$ÑÍÊ0`Yzì*Ñð0÷JÜ/wã^Ë‘ü%´@B‹ÁÇßyFŽU#Ks“ì}v_Îòä¨÷=ºv<1øñZrbÆÿ,fcX [¨m@/©Õ§©RÍ‹-!€E^…#6éî[Ÿzí'àèá–ו‚£ZB€R"_ç{sgÖ¾(«l®ò¡(óEè†J»¨«íî—®z-`O›ŽDü#¸Þ'DÈ/yûKÖ´Ô!¨ùrÍ×BÚõ0ÅX8Ày ÎtT—IîÂ{¤ð4‚œ8}L!l6]¤òB`™xînýÅn a+_\’(ˆÉ •ðÑâ©2N÷öN<^6ò@ŽÍs³,/ˆ0ñÖa*äËŸ!„¦Ô¦ ”êÖÛâ¾/“Œ«˜Õp´ó2ftíÓÒöÚ›ÍkPý5›¯ˆXýÇ.î¾\é\ v¾§¡€àDŒI2L# /82X¤@c B=ð4ª%b}>à¼óâ˜ì¿ºq‹^¡÷Mxeõë(Ú5~•î;îȘÚiÃe͹«â¢AêÓô¬«“µ*p¶W§ïxˆ5ã»—Ð;¼ÏYÐJ:a¯•ÿ ”ǛèEô…ÏLì4—™ÒÿSR}ú˜•çeCÄR}ì±æŽ¢¥M×׸Ž³x ™‘V.Ž'ù¦ÜÎ?yöW›tOm{àm-ãýüÄŸKØPêÑäf+œ}¤˜Þ’‰ØÈqPDn.˜IdU” ÞÆ)é“òXÂáÇEÍ‚’hXÕ+ ËðÅ™À°¤»û{øš3™³¨º»$äÇ KS–ËAfá"rœø˜ˆ~Æn„Ç.à€ù•„ioòÌ h¹ìDáDŒý’ÓÆK2íz…ž¿í>ö ýë…ãXéÀ¿ÃIÇ•>,‰¨0 ~˜½£Šò裯ctø)Ö¤rpñË. ÂÐ_Š`™øÅÁçHb¡ õÀ3ºûª‰¾Øƒ=å|µ^ž3ÌÐQ9–¿RMeÍâ=ž‰ñwðâ•” endstream endobj 18 0 obj<>stream xÚíTy8”{.{#e˱„W’™y³ïd/ËXË’Œ™wx™ÅŒkcÉI$»pŠä´+N²'…ÈJ-–±&gÒ×uú:~ß_ßõ½ï?ïý<÷ïþÝ×ý<׫¤€qQ7ÃSü + ™®"A}ÀÜÞÖÕD PR2§AX:L![`é>êé€ÃuPG_SW_‹CÌ)Á4Ø?€¨˜«~%éf$ˆã°dÀK€H –¸Pp0D@fD"àüõDà …@´PD€ €‡qtÀò‡ÉÔWK¶dÐùVÆ3‚¿·B!ZÇ Â1© p,â)db€‡”…sÄqòß0õ³¸ƒHtÀ’¾Ê‹é, &Fü‹B!3è °§à!ùgêAè›;{3H?wméX"Œ3#û!@ÔD¢5¿Õá+8Âc`:. ÓÐz"ã6ÂIoÝ sÀÝÂÁUíû\×»,L¦»FCúoú:ÿÆœ”hp8à…F¢Ñ ‡Èy¿þé6K2Ž‚‡ÉþÀ^-mK£a#œ â - `2  pŽc’L¡sŽœd˜BC|«@Y}-­#Íø   à^Eøj(ø¨  ˆëðŸyìÛG âl™ú^ @[[ÐÖÓfþ;Í S­ …F£utôÖ«8‘éë[ÈIú;&ÀœÙ@P8„C ôQp ¹ÕIåÑ–¥]¼ª!Ûó/%<¾Ÿx+ß9=b ÚC»óÄ’›I „+…sÞ¨Bá Z£RÕfG[£\P‰ý"­Bâªç \ø?⦽}¸ÚJ6m%¥LÈ¿¾£öñÅNÖËÐû¼WíÞ‚:ç¥ÞŸà)ÞÇžŠéÌÃïœÈA.ùÝ.rŸz™Ñ¾:cM)¥ \hûÅ»€%öe@ªiøiÐP¾^j‰ý{_X²L0-jõ˜LȘ$Ϧ̲±ú|úÖô ëךy.mâg·¦ŽÏR4Ôt “˜üÛ¦V×$ô}¯v}éƒzåêåzCÞÈöµWÇvÓºƒ¯~åŠûÀ‚å‡[,³¯ýúvâ(Ÿ·©e°uððn_+Í₃¦)ú2=.Aù3“jâQTm)núÂY~UáËŽŽ\ËŠö¨­b±Vä¸ÑÛ£ˆyc.i7?Dä™ù:ÛV„CŽD 9Ç+ãŒç­Ñ“17-]›6£AÏägرh3žó5JÝÃ凰Ž‹k§bã_·ltô´µ¡ÿÙÌHƒS*Z:—Q™5æ¹YŸM÷«v%½RÎÓº§¯øÉÚ„M¯a© ‘õí™}…qžeñú Ñ—^-ØDîn,heèÄ„Qã뎳»³¦Ü*Wµ®^Òà¼×äo.#lIé·tƈ¤l—LŸÛo} e¶³âö¦ùG,Ñ1R‚XmÃC<»TôöÈYHÖà}ö~¶­ûͧë“|\©u//ÜÞöR£6}mgÖ.”ÉØËì*‚ØŽú ¿ïõê¾þ¡Ó^´NY“™ñ~nãFý•N­#VÚœ®½¾ã¾Ý~jè¼ñ¹2Í%Ë8ê»KšüóȇŠ±ÆÕògCÉóŽ ;ôÑN^R;õWfÏŸí+•Å…q/^Ôlñ½Ÿ‰ÛÆSìõ‰Å½Ð´Åµ»Q¤¬äÍ?Æ¢UE¯ˆ$ï—ȼâQÏ\FüÊ…Ï|-•GŠ‰Ó°{¬®…gñðøæµRó:¼w¥aZßÒQžA7­=j²ÅÊ/h<ïv7?¤••o¥Y#‚Å΀–ƒŠ*ƒåÆ@‡qöšaCóR³Y‰S+»Í³«þ9¡ÝcF=kézˆÂI¹ '·aæ6zøKö£ƒÅ-º7ÍúD¨LÖô.×Ú²Ém¬và.Mˆq2Úˆ_”çÎ_T@Ñ°2güÆœXšäAâKÞ4? mɾÚ~ÇÍft*Ï‚ãë¹êè%e-´Æ§=ÒÏ~5 Ã>k…éNzÀrìê=œt]Ì]öh{0œÝ§;ä.´såvÁE»GÄ¡ÕŪC ÷®Ì‚¸]ÂŽg3_Ö½a:‚ªŠl “«¤¥è@h>z<8Rj2‹‹k«P¶/R2ö”h×–Ž×aø¢òÊ>ºŸQß›£+üæ)Jj’ËÔû˜P»Ç‚±D²àøqc»ô g„­Ž!Iþ²å,OÔxiôD‹[ùá*#êò–Ts~ý´'}M¿âÀ½k7Eõe߯lŒœtšk9¾ÜùE¶Hœ)´ÆÀ³ÂÆòºêz¦f†Õƒmšþ†UgÌJOïê+à švû{¢tW¦*ø<‡„‹y[/âô“S·7†ì$œþ<0H±{ÿ±÷é>­åBäDÞÝÉ Y}•Û'b¦ê—à…ø­¯¨ÜÍH· V~A¡MRuVѧ„™è^ŸhwOjôäXKk…L³|ì;/#OZ¶Ê “møpÊ7nMn*7yìœ,÷[“¢jàÅq-¾¦èWIãxo°†{f° Ưun~à0®¢"Ç$a z„Š xxz +eçãÃ…Óó\¸s›Ê0{î‰: èƒð£AÃwž3 Ö¡±í/KNeÿ>9¨²ÄÑÐe.±¨'­¦¨++QÄò»–,{Dn<öãD¹ºl¨\þ,\ïãM­ßØKr“,«ö|ŠL˜‡*Ø:oëŒÙHSvâ ‰ÞA(Œ„ëê÷ >ÉçüÈk§Õ¯ÖTP{?7ûtO½¨LHy{UXê˜.ÿ§ã©]í©]91§Ê‚„O…ElŽC1W 畤ɅšH+F³>7ñ4ìË1´®öñËñ1TiõøLÖ“œ7ww8Ýýrk³'~8¾´ï“fÛZÌs«ÉËž²â–‘»#m.¿žÊÁ䞣î7Ô™kÛ%¸S‘¨gª¯®†‡G­F™ä¤2Å{‚LUgl74+'=éõÒ{έ—9”ucD=­Y@OUïŸÓ°Yù$§*m·É>Ñáî‡öŠ¶[ª £Æü½ùÕd‡5ù· 5¥–§ƒŽU» œ¹xs²ž‘6ë`Uóäé2OÍÈÃ*µ2fÌY¥Wy8–àÁhÛó›œ 0“Òæ½çºD/©ŸRÚ~X/‹Ý0Té+ Ì¼ö€I<¢X™´­G0uæ p½°fg ººÐ(á8t¨7빀kå6²·¤¬žîn$ðÍÑŒ’Er;ð³.uÇ?û}xúâYawR5½öÐFH¬œtéþw“èÿðAü_àBG„°4:…„¥!þæ["E endstream endobj 19 0 obj<>stream xÚÔTÛnÛ8ý>n±ÈÉv-( $qܦ—ÄMÜlvƒ<ÐÔXbC‘ I%N¿~G÷òÚ·….<3"ÏÌŽ˜½‰È¦"MÇ"ËxHf"›‰t4‹7o°r6¶Ã(élÎS¯°š‰Q2éá8aœ x$æƒ;e¢$Ü©˜O{83oïj±ÀÚ;uMñëå ÚÇûÅ‚#m^j™U.׶ÀRïväÉ* w Þʪ’X’‰›’øýQVÛ\âVc­q­ þü¥Ú8‹uÉΠqYQ!!½wÏMݹ{¶xl\¤ÀA öÊÈjpSˆÚÙÎÈ]4˜d_QxùDª‰%=ÇÙzbO%Ukø6iE¹6F¢ _I›oM€$8¾ƒ‘¡Äñ.ùî'ô–¹k©yô©ñ:ئڒº°‘¼iÙkòŠl„¬æï§{]”µd± íÔ;e»V‡Ô¦ P®±|©K²-™v9úT¾‘wp–Ÿb鉰sÇNsAï¸R êH­æ‰ÊµJªtZ@4,Iû]OȈcœàKœa…·x‡s¼Ç|Ä'\àk|Æ®±ÁÜàoÜâüËòJõ@±«iË°OuðêSZ+íUS¡±9«¢œ§^–nÄ 9¸(¡ñ0¨`áPã žðŒ=^ð­‹@CTß[?E‹Úä„\so~ÙDnñ9þ².æ´é4A¿µ¿Ó»"ÍÒTÙøÕËqD:ÏEô¿x{¦¬´a¥fý¹ÀöɉÛߥ©8Çb:‹é|zß}¹aýáfy±ùóôÓùf“&XY1Áu¤ê†§âTÖﺾÓ4Åí€'ãÇ¡ý[:÷’z|4p¥Ñ긕L¥œ–Òóqô·fß(æÕbq÷º;°~÷jWžƒ=Œ÷ÿ 0›tÌù endstream endobj 20 0 obj<> endobj 21 0 obj<>stream xÚ•Ùrã6òÝ_¡‡ëÏÛÌá‚M© #íqEÈ”lÓ7®ùnz­¼`7YAô¥›$ÌSKô9œy˜ZKôÅË}ãÐæó}¯ˆA;M9‘æa–ÌYñáTvpb£ò @YríkRAÑËÈp‚¡®¸®,jleAqxÚÆIP4Èá8"‹‚$æ/= &>!»»áRÀOÍC¿EʺÝê´úp»³6 ¾vÕõÃäÊf—¨0Í2”²0c:D…´%YPõüûH¢Eˆ­¯îý9ÞDšÂqr8•ÜhŠ3µò ¿7%ø¡e°sñQdAݾµ„íG©F8à ÿ ÕEßójdd!mA»â= °‹Æf|ÆùÍ8ðŒ×ˆÈtYô Ð|e׸ĚfÎÕñ´Õp™Ü½8N•ÜïÛ3õ†¡8â;É…‚ž~ðjtW¯¤í&ÛõCÑì§uáÉpñÑ¥ïkÙeïNTð-É(H5ˆ=H½¼Êé¡:4‰"²8Æ“Ðó–®2ÌÃî€I'ÅQdfYzîá¥1èY5y'V‡©Î`7RÅ¡ºô 5yLƆ9¼7†)š54y˜(‡åPÁ^p <ž­ gyŒ@ZÛH£Z þyªºNu¡ggׯ†^ˆFú£x& H!\„öLÓ© ZÿŽ›‹6éM`£Ø´.ÆѽÛà{âlI»âSÅ»Îâàž*`å5,eI ãYÁ}pDï뮊L‡ýbp9šmÐãC]>€¡:—@\¬Tð_Jâ^â؃‡7q öé6ìÐۇƥhÒU0à´J`ÍCSÁ‰ƒÎŸü²'E‹=º©ä)–r²&¨J—Œúl¿^œx¿S¦éÒQgy@ÄêÐÑ–&´»ªÿÈ­ÔFÛúªÙ·M_õLô-†Þ¯Í‚ï+jz‚-÷Ö·’}Î%é†éüÌC¤>@ã;ňß6#eô¢±A*H6Z°: “€¶å;‚Öéþñ&`Hn‚Q‘vuv Ú£&;ª–ÏÅ#6’ kIS¸µtQ ²oë˹é¹ÃÚnµ¸ßʯˆÎ] Np p(†bE7!•ÞèôpõMËcçíéÁQzrCåààpÐÞ(˜Öj¤¢Æ›Àv9ì…Ñ)€Þ6- 5¾cœ%¼W–˜g*YOBƒü¥AúU~’]¢vn6W^[‹„fA7Ê®Ú<øL·géöb¹õ Qô¢`â±ÀIs_L djaúx˜ ^£`G¬HulJäð'³ùh¡di¡âH±ÕX;% .3^Û¢F´Ή‘³AãM=|„šQr)øzï¥[üŒ !ñÂG/ ¢¶[™’ON ‡ª˜"’ð(q)6ûSÑÍÌ.ºšàÔÒëzå ·`Àüü¯Ü=»“¸ŸNÕh±³B>z¸·2ÛžÙÝÁ UrKÑ "ƒ%‚¯˜b"úÇ|e¼ªêŽ‚vŽæXå¬I±Ë*®« t›ã+Þª™t¼% ¯ÎbÙ;§Öp\{•h|à9:Š"˜sÈ4ï&Ížq#p+cÿL΀ÝÅðíÆj+áx”áªIKu˜û8ì®­Û®ÿâÝ×_…ßýòõâÅ¥&Ô:öŒö½Cf“PÅsC6‘Kï:â Á`A,pöÇIBaÈO@Ï·#Ú@z8éµûÃå'FùȬÄ!æ/b¦g…C£øŠ5ÄAy¸5qƒ^ê³È`t²Šýšy›ÞL·Ât‡ÓîŒ@¦‹ßO`1úÛý¾½4Ãô_ ØU|—þÁ?jq:FmŸŒ™¢2!™ý,×iT˜¥êÅY ÿÓP6bÔpD¢3œz+‡õñçÀãWØÇ„…§i‚¦æÜ¥!gÛ\ˆƒßo`2;ÏlÉÈ>l™pØyµk!Ò£)ÎòP1·á#\æ=sŠ ˆ§‘N@æ ©`bê-ø‰c¯Î² ±bÞï8Áe`—™o)X5¨¥à_IMÄŠ&VM½†ËƒÉÔãÑóT”SÆ1娟lžÑ):é ¢Døë§Aâ&!iµÂ\s(12`<.èã½ÝS¬9°‡”¯·•îÝå9‡>°ð¡­kÿþéÊ}¡Ý$g«Cå³÷Š¿>ûÑïÞ­ÆôH<ÉxÄ“T Ÿ×»LqÎ…Ã1‘f4j*uÉ^ÂÐ ö¾³ÞX9ç,R‡‰„–ÜÂò¨ÀßÉQ\ £³ÄßÖøàvmW ”ùã®Ûdá—3¤%9¹—úXW÷öíϲ‚cɺ¤ÜcÌj ÌyüÒTÓW(»þäó¶žÇu-ZciO,š#e§(Ma2²Â¿ ŽÉšÁXÊ–ù*{¯#ðžÁ4V‡(®?/¸»É’ëlþ5V$qM¹!U? P=U|‚o)P¹<^Sl4àVs‚¯ê ò…WXØ^씆‘ÉþoÜŠ×wžcÅ­_z±;x¸äÕƒ Ì«û]á‘HK¡ôëó½\yL†³TÍÇ©ç I8¾5>‘…ÍêA¦èõr†Wg‡™™xr ‡â kr6.¤gÕ®VÌ"¿O„§L3®x 4‰É­ÄÊ P÷@ñá >°¬ jKJ@L°˜À­\ÓAkóòQŠ’¡ŒWò'©Á®|(»Y`3攥Øi¯a(qž EÊ-þ;Tl¹´Œ5OeƒÔ- U¦B3 QQ¶T!Š#Žš#(¯™™”¹¯@Äñ鮲®¹ç•ËNS´g1?èl<]§°ØK &rHgM6y™A#õ<±K0ä+Cè×¹\aÏsYÆyfc’uKŠÌÕE%•À•<)¥ÎS&˲+‰ôÙ×6$'€üNœŸ5ÝC2¹„3v ¸^üÈD¡Û9ŠŒ<Ó–Ö|úd™jD5@þóàd8$=3’¾‚‘²!‡ÂkÙZÆé0ÐYãA¿p5pÄ3§…’½cš“^¦ëÅç |jÀзT©òIÚO]©åMÞºm,Ö–ârÃiñÁñªÛ‰$]…™’¯D³ÉdÀŽG°ö'%‘ ŸZo*¦°¨¹òØ‹g2OÓR=³çñ‚zI·c~·s´¸b„ÆjØÚ¡;ʃ\èã ‰ë"4ðµ:hS^±‡¨±*¨ C"nК¡‚çÊ« ˜¬ Ê&äëØy9?û³N=ƒÑ§ÄžV,ðÇEê“Yð±þ¼ÕtTBµN5ìõ_(sèö‚iB ¿å'<×d¢jvxœV*¯1Çyr4ÇR"Ô]%¤žÁOÔ3àX·¢±•œdü'û¾¤«3‰Z›—«@©ÏOêNØñB "u!ÕÄâ2´gŸ$ š ULÁ[zÃÑó³{Tc1ë‰å~–Š+zïaPeTJ¤|³íÅâÁÃœRMùs¦³Ïà¥À_²UTú²Þ¼@úD ÁºöSU>“BÁ.&¸8 †SÚ¥s¯¢+ŠÆÔè3Úñ¤è‰ÑØøùŒÆ¬ý^Fž'³ɺÁ¶ûè¿YÁsÿ+9}£ðƒ«Ü» 1&’èp®"§›nª´ï¼ë¸ð.bêlZmy‡dÝÝù¤'0„9ÒÛÒÀjÜhT+½QY&±ù+q£¬ØM–,âÆ+¬Hç—>ë{¤Ñ,¨IcpªÍœš«XÉÁ¼ºÿžÕ°Pƒn£¿utYñêÖWX]XxXÄ…Qf‰~õ¬æµ ¯ñLãBÐAÿ.?Éõ³jsm±Å¨ép`,™ö³çøk)ÑdŸ¼Eîhå’Oèspþc–…i¦çE¡b´fâÔ^ùÝ”ëÃ>U‰ Ó<^cW´Ñaœÿ…K!ºÁ9_ý°T%Ih²xüHÖnÐåϨX¨óP¥ÀònÁêñ{J3›À¨>ª…&„ˆ‡_ÀgþžêP>€Ž#}úçôQÒ…5øä“+*´¹ïÈN4½52+äË­Su$ úû¤×«¶¯^ŠW1~X¸ðŸ¾Z£5R|Ë„=÷*ÛN°wAv…@dmQ \û®Å­ž‰ª'$=WŒCmáµæ¡M&_RºÊÙh£jâj9W 3Ë9Ëâ¾ÜQñ¹ÝÍœ ð6(d9åsª4 Ünhw-6¦ÃÏö ê%±–Ådò åZLu_Ëü=ZvMñ7î~tsd,ñû:ô¡jØðV¼ÄÙ>äõŸîH®ž¾¼¿>LÛùÏîì• p †ÙN-ÝßÕ7Ý'hv¬ìÙó9—„ym  h}ªïѹPÁ‹ÏÏÄ¡IÔúóÛYæzU•™'ÿ¯ÔV endstream endobj 22 0 obj<>stream xÚ4ÌÁ € €áWÙlSIñž¥ºE§ðšzü4í´ŸmÚsòUÚ lZ[0¤:%UëavdÖÀD#3Ø©³VæQUÝøeõ÷Û{Œw>×TvŒsÀ-=åðþ`4X endstream endobj 23 0 obj<> endobj 24 0 obj<>stream xÚ¥Z[ܶ~ß_±è“ð¨âE·}°¤AÄ©wÑ>ÄyÐj´3Šg¤­¤ñ¬ûë{n”(v 0¼C‘‡‡äá¹|<¤ºàŸºU* £ì6µQ˜çÙmyº‰n÷Ðò%[!Ùz4ïîoþúÑ·y˜'æöþqÉæ~÷kðK·QA»Ùê,(«ÍVÕ®n jßo¶ÆØ }Ä_|s•ï¹NG‘ÙüvÿÃÍ·÷ãøŽµIC›¤8ún~ý-ºÝÁL¸‰Bã] …*ÏoO7JE¡Ö‰|oînþ¹²–‰­%›–bSFÐÓ_K¾œ”MÿPlBr%6K ó8öå%¡Ò9eC‡)?C¹8Õð·ÙƒˆÒ8([üØ|Ùd, HÕ6=Nu¶ –…&cöwí úh“Óh“ÃA*‰vˆ?˶ÙÀæ}Á?2ŒÎa¨¦~ÝhÔÒ¿Àñ#ö}ÿž?Š§'ìð•¿Ñìö°ÙÆqð{U"¯aÛv¸7dF¤ôµcö»ªÇ/$Ú7Âç½Ã¥ÓrQ¾ -÷‰´pß'XÛ>Ül-¬áCÃu&sÎpÎSÝ©¥n©OOPHƒ¶ Sáø=-ÎóÂô´ŠcÑ÷,š7P›§Á§HÙê¸ë™¦hv\8UÃd7±ë-Év¾ ˜ô@sÖ&IqǪ,*¶&xKã–m‡ŒjR—$ †V~`KRØ’7ü… zæÕUO]ÕÏ¥>²á5¡2’dz·ëØvBŽgž= +çÓ¤å42ÐÊ^ñÒ.]ƒ2‡­É ÌmpªŸ«Ë‡7YôCÑ Ne±éRÃ6R |â}«:é‡l¡/.6¤ AÈVŒšŒEÆÚÂÌÈXŠ/ ‚þmY¶çf¸²,ðZÇB‹Û'Á;¥åi·ë´Ø­‰Ò0µùlͬV'Z5i¡Ó¨7AC€ü'j‡µ(ï,8÷·‚Æ&”1#ûxöíj˜–…'ž9±ð°t¤IÛ Ù~ǵžüt"œWeh"æÊÉð¡8 D€¥ðLFÆ ÅpÅgk¬ ó…ÀöÕðŽ9~Šâþ«+ΉÓÄNÛbµ ~%uõ—Mœ*˜N5mŽ.™ŒêIi#ÎT͵XQø+ þ‘ApF¨w´UW·´7;š$”Øz¼näœhx™Ê3ÊTõÝÄHb•[ØK‚µ*̬*an€UÐÆal³™‹<ŸeEƤA=ðoy¬ŠŽ‹¤”Åà·'AÝówÁ?´O¾X'ʉmð‘}FÕ±üvLÃC%E×Õ»ž ÈEÈ5iÆYr›¨$Œ¢œc.†ýì¶ÛߺâG/»[¯Ë2Ú/¹¢@>ò$~$Gµ?{YÏ7®+kŠ‚ ¤KRÕqÆQ2“ê*”1í£ø6‰b³Ž¶„fë-'½äƒã±’™Ø°KÁ¹qN¹xdE3°kŽ©](ˆíŠGG¶Ç¾åæÉ·ÃÇdm½«„WQ’³p±Htl9‡#Ô F!Ýs&¡*X.8WßöW¦Žs¼2°“Ð)[@_ ï ݹÚîμè6ò¼Ö« ¦”i5ñý ƒ÷î– °ÌídŠÂz)»Zäˆ2K³ ©ž!‘¨‚ǶCìlÒ|Ä'|YëtšDÏ$äA8“Ç¢á¶Bh’ÀK-èø¹ˆµíÀåÇ=ÞQà ÍædU„¯å‘ÄàÃsYßDzüWÝ ´oŸËê „U—RQÊ„iêäHŽ†¦vHñúA-\?»é4;Y>àëLÍVï-7%ïŠåªA `i² "ÅÊiOŸ#Œ§`.%.ý39¥¢jÖèÓùÂúá81Ô4}Ë‘Zø}]ŠÔ"ϧà¨lâ¤v­‡¡µNy 8•ânda’ä#M®’×&bÉàø“e3¹ÀF#¥™0¦¸Wô`› bG&¥¬ \QÂb ­C¥`(1¶‡æÉrñë­°-øà¯pC\ø™°°¦‚mµëtdQ㟯R'˜›á¦÷5¾§=ÌÁ±  :‹¹á£%VŠÍP™'1ðW±/êÆwp¹qȘ Hb_¹áÜ3ÎßBÝGäí¼¼°ó0£ï%è *àÇ÷ïÿþÝÛï¾½Úø, “ÈYÓåP5³á¬ Ðq¶£8%9©ÅŠ¢ârÁÚÜÎ Ô_iY—UIðÝÄÝ"È‹#gaÔ·î|÷Oø‹AbÖ(t…ð… ÁdbS‡zN~âÖ¾ª®NÔÆ€sÍoc£C£õŸï®ÇÖëru˜_pEÙ½Ýë~`õj›Î÷³É¼p¾et9ÝÇ:Gº0}…l”Ƶ#Ý/ÝõØz]®_pP¢wWÃÛ4´j1ü•Í«.ø8T"Hó64àøÚë<4øðr˦KÎC`Û\j!0^$õÁоZÍqÀr18#§{ÔK«ÁYIË/`ÁPëAÌÛêkË Þ*õ·1“Ø\á  .Ñÿ°¥¼À°2Kdá"»X ‹ XÊ«è"RêÂèxhï<ã.´q¦üý1é¢åYÁØ°ÏBY4N%#Ô%®,1„Ý „e›¯×Ø6h¬`“Ç.ƒ´"ÉòZ1þOÙ<Ü ¤1'¦ý°¡ùÃ!îw׫0L€À„UÜe`ðA¥ª«¸«dðش+ nu˜X“‹1¿¢ß1ÀDíg R~ W'Qêšõ‹Œ·N{yjfR¤LS”w 'ÜûASÀ¾îW‚'B¦­åÆ;ƒsTÖåM‡ŽèWne¬™ €€ŠÔ¨dJØh-{‚Ÿ, âÓ²™Ð¦*5av5ÚGŠ{›ólËïnÛŠã tBM{<é‰ä"JÆŽ‡¬{¬ÀDVµtñÂI×HZ­ŽŠXjd-PÄýiªjÇ_b‰CÑ.ù¤Â­º¦82ÁŸûŠµì l+ NbRê& ¾÷Ž<“ttÆ?iÜŠ ­ÒÐ-±'+—½µSº„>š‘8à˱h¤3WˆácÅ ˆÑ0KQ0j;‚›ÑÕhNŽŽçPVkÞÁ0çœðg™ÉåÚCA39ý]W•8Mâ3ªµ|ÄÑW½9€«Ä>5˺í܈++‘¹°â3y¬c·C¥«ÓÀhÃ$îz  qÒ3‰Ä„y:,PC<:.(rúêXïøè›t¼*Àf>21»GšibGì$Öa¨¤‰µ©øœÇ«%Ñ¿Ëú_æçú°·.º¢„ý­ûQƒhêÊ©ÔMSŠåFé¥WO1`Ë”òÓ„‡&Q*ÍáI1N`™ÂÇÌPë0Q•C}rÌ‹Ï#†RÚ#3 m úx 'çÚjí®¦>='Ów;ÈAÚð/t|œA­âá(ºCžé%°o:¡éT³ÍP÷ytÉýN±zˆFiç܅Ūé’Fñ îìÊÚ¦BƒÔó³4:åö4Ýi?铈¦&ZüBïµ%­ [šë£+‘ ¦„ëÂaZìh“/^rª'?µ]µœ G-“ä“jÁžç~ÍüF]5qða2®4‰Å®:Ö^.«ªçòxîk™<Þë7üëóEpc¸(Âu‡¬Èù^Á’b-Ç™^ƒõ” í¸ÎáVϾâg8ÍË…Vs•ÔŽç蜡2Œ` – Á7 Êp·m@DQ9^Ü ”³k$3",ÖlG‹{ضñóçêbòå=½èq/‡j¼ô“ElÆùáõø±rpr¬Âݱ8™–¿Ý`yç&º9t÷_ó.Ÿ”±,W´ñê/\»~± ¢MA·¿÷.!¯Ôg‹?û‹ó#Ç#W0ÏêÍŠŸ³|Y¼r&K$&Sˆ‡rÞïÙªrñ¢BÏ‹dˆXÂs0“'Ï>kP,90à ãæ-;qšÔ]STÏCÕì^<èX8ß[—!X½ø™ð2cŠ’HÃXÏ/>\E<ÏDk‹$1ˆ…ÝâÊ xó“ ê;3HL±“1B „WÜ=,zÉy>˶𮅸p}®ðÌŽ[¼ä²º à=ΊÀØkîÑ™­ÿÌ–þA¡êÈywò¨i¼b¦«àÃÕµòEM=†½ÿršÀË–¯„0»•†YÆ‘bÿÐ2Y†ÙÂOxÛµ!9æ´®ßåcºìZÏtÅÿGÊ‹o(]Ú4Ö\p%ø„0;Ãð%7£»=0^ž7q“3• Äq .ˆŠýº3¦q¤é¤:Lñ…¯U‹3ÆcY îª㱠ܹßï쫦êdPüösCÔ%äÇ+9Îe £±Ð×ù//σ.kÜ 4ÕÙƇH™÷$ËV§:faºýïÃôÎjkÐ#LæJ cü3hri}9&Óv#¬ÚÇN6©'û‰Ö´ϜQ E›•,¬N@#•þsŽÏäaœ™×ü<Ý“<ÏQaœÇ«ÖOïÝÚãôÁOÝÒ•ÌÃø‚.uïà²)ßxá?}!ÏpÍò1>Ãçô> ó“‰cÒ˃»–«F©¨\ï˜é䃄µ°^ž<úš¶]Í Š!é$׺§sp¦º0£GGqFWðSúž¢ãºyÆ”&–û÷N¼Ÿ ïD9—T²!ÈRÒË8ètו¬ô3Ã$Ó·òöà<æ^Ï}¡Oæ“:ûå 儇êo/>stream xÚ²0P0P°±ÑwËÏ+QF† †–@± }7 #ÓØÈ6‡²,¡Â†æ †PaCK3ÓÎN? (?98µ$Z?ÀÅM?$µ¢$ÖÎ ÀÄà‚ endstream endobj 26 0 obj<> endobj 27 0 obj<>stream xÚÕZK“㶾ϯPm¹*TÕ !$íÌa½öºìr<Îîä²}àP†¶DÊ$5ãI*ÿ=ýø9ëÙcJ’@£Ñh4º¿nH®BøÉ•”©ÓU…"ËÒUq¼ W{èùæJ:Š#ÙŒh¾¼½úë;­V™ÈŒ^Ýî.ÙÜn ~lÖ2¨×•…]od`·eMûv½Ñ: ê>uðÕh|Ëm* õú—Û﮾¾íç÷¬u""“àì¿_ýôK¸Ú‚¤ß]…BÃ|ð ™e«ã•”¡PʸïÃÕ‡«,¬eàFkI‡¥D&R&“µÈðRª(ùS½i‰,Å—H¤&Ó,èX‹ÄÝ$¡Re½`‘Z¥ ™+Ù‘ `­íÞÖUÛ5碫›úç0_}ÈÊjß¾)Šú\u¯^¯7±2Áî\]YWHr—òª°×!|H쎃ÿà A ‘ŒAXUÌ3”;î ㆿñƒYø±ÑdlwßÔ$Òmó"ñˆ®ægÑؼsÌòÊ=Qf4–ªã†Ç²»w]ü¨ì>ïÊ7ÎIô9ñRûV”ì mãdSRd’·ÔþÑÙj‹ÂÝÜýj‹ßp€c1WâòÅD'דù'SÆôÛŒÕÍbý×wNl2Ñ&TDs{Óé4¶¶@]àåMŽ›‹íîhAç ËêhlSv9Aå»ð8¦&Øâi­\ãC™{8Žå3Ñ ¤”™Î@°©.¥‡3"#íhä ˆ/;‡-ÏÄ2GƒÌ7w Ì8ø•×رÂœ©0Ux`@e†8‡¼E’¶NÁˆGä]k•`: ÜÊ#v—Ðz8`l<Ô€Ò&(òÃÁn¹£áÙÎ@Û´åÃ䳇'îkF¡Ï{’ýÜqkîyvÐzïX¶ÈàD˳M/Ÿ¥‡Xo")y‘öçPF4gØìqô†º•Æ#ÝUk•HlRÞðv‡½OÜKJÌqß¼"&ayáea‡È†ãH9GD- WW[fêl˜ôh{ŘxÑ^U&Eb^j°ðÏ –¶_kàs±ÿÃA7ÙĘªüèZSó6éuÛ1zŽXÓ²xlGV.ô>©û¨H<èJortFhR¦F ±nˆR±›-SŽçÉ÷™½};Ýyã®3(r+Ä7r­‘žôï[Q£h [Ð/ûÆ£iLÏ?oç2û±G<ç>Bu%Å$±`âo*gÂ`Po[~}XƒÈgg´´ºý™ãÂFF±ˆ³äÙð@ H: ¬Ø ^’–Úb) Épc®GÐe¢T “Gíø‚Ÿ¡­â@«U6ZpÅ ÛÞqHmLdy¼‹|Ö›â¶åv²˜7lJìÊÉÓLf¿ÊšA¸EÍlí.GÓ:tìνjm‹ž ؼ#±÷*Õ´D8kÝqÄ$ˆk£€eãðÁ–)v„ŽÜ»à·ç~/R˜‘Yt3Å«X€opDE=„¦'ž–2Å(¯.˜ŸÎÖÁzЄyC<ÑçbEájôÚò+­—±:„H†&À~ŽÆuKtåOH=è²ãx„mˆð±‚ ›ÿ‹bn<ÑtüôqŠxãÔÞÓµ£ÎzàŒ[AÑRtD…-Za2¿UQ6Eo£;ÁPf+˜ì" „tU¨Ä@2˜ˆ0tY f¢éªÙ¯üëûQžçGlFC(ÏKVXD¢x®i(ŒÒ$‘™O‰$Š§S_$•žf6Ùؼ.øôÇ[O"ÙÌ{ YzwsŽäÒ ?Gù9õîYç*#ðD2ûÍ;º#¨1ß«P$±ŸüD{Twu÷tÂ7ÛÎóD¤¡?BeÅ`XŽs…U6à̬ðDD£bÔƒ™$,í+þd†:‰À6º{´˜=ØBêi»N³>u›‡"H¿ÈèÿNü`-[Nèµfb:ÓÏ'UJ+Öb7á,b@„ÅÏé]jœ08¼ç•íN]š_§ù–ðØÕ÷¡Ã;·îc ¼zÄÁ:øºI#99¦ìá1BŸ y’ f >t áèZèváÇ{Œ“w äY8Ž!+{ð&?ðØ­íòòÀ#ˆ¹÷’ôásx?`ß7}¶pDÒK7xM\AUw Xí>Ÿ$ 'Fµ{¥Wñ7䌞!^Œ“$¸Á˜åƶçò'(7ų=Q4XÊÁïœ{[A +¸ïyáìTMºñŠ8=ÄÖ>àÛ:{×»èyQÚ“e1x'¡àÙÖxò3Ã3!¦xtnÐ(=ÅÏ›¦ÑÜη¨¢, Þ­±Ò¸i™x;NUa»­ã¸-Ûâì¢WRTÀOÜS¶øÈ @q}jÇh¾Ö¡{*¸¹ˆªBFŽøâ#­&’€gh_ëcÞ•XŽxâÖrÇÏcéÄr ²`ûµLÀ§i š/ã…NŒPà/`1à7¢„*?b3r=.¹²«Œf“§dæ“_VKÍG§»àCÈu½IBÜ"h«Y—ÖÀo¨´nÉý&ZÄ:ܯCا@ˆË&»ú%œK<û:’÷¥×\7' äJƒ{†½‡ÝZ—>;ÇË-gˆG*€ I²Òq&dò3ò#6£!—ˆ§çj”H\¤LæSC˜c2õeÝÑÌ&à >8ÙçóK®ÇkÌüLú²Úýˆø¹Ú½'Gzå_Á7›‘}uQ„jLïWóaOÛ×¾:îLÑ~Ze÷ÿ[ÜŸÈV¶ŸMKó—+ýb^ƒÏ>±ïj}<lgù«Ïïó½Ï_© ²P‚"4Ÿ ü ’¯–•í³¦«âÒ‡øe¦;"~Ît=É‚ébÑÂía»ëW˜pC¶íïžà³¬J´WGv‚äìãúÝ›ï?|Ý·Õ- vûVÜ@†‰–“íi;Œ’“¡ù]Û5yÑM! Ę™&­[{jl‘_L37[=”Íõ BvÕ‰]+¼¸!b ÿƃ(\ß¾ÿ§ŸÅV»º)ìû·o©uq#7Y$$:«‘Y=ÞÛÆ.d[‰ô •Öfe-¤Ž{«€°¢”+*å«JsµS ¥)lsù ",ͦ—2i¥Àð}&$9½-¢.!ÀW„ý ó'B)?ÿ`Ls•jˆ^*I.£óÔ%‘+Jq ç x¯9–Âb)6õ5*4ÆqÔ@CovDßr²:—;M…Š7¼Jº't…ý9™†DéÕ‰–Ljú‚¿©åÕ›þ5磌±øÈ× r^M…=èQ|ù=NTvN¹t.—h¹ Åœy£òT•Á3¡ªÜ ƒ± ™Åð ®(æ{âû¼¢‚M¾·Üð­ÏÕÁn8µyÍK8ÐàbME¾D«ŽæcB^òé¯~I,¾•¡T`ŒRù.A°y|Ky’_1hƒ‰‘˼`ø}Iב\ Ôë*…¾Zœ)¥Ñbµ˜3*,ß×ü<· 9t¨“¥PÕ~$V%XÉ’n”ç?¹;ÑQ<½ç½aºY …´wÃ`‘£¤ÔÊé²#y¤ þÀLŽþê·*å¿í3.‘\š-mu¸R"Î^ð·“HÓ?A>ú·i%ÿ; 툧—ÊD,€ ´Ê~@¦W ÞÓb- Ž3–ö«{ âk‰ œ-µ>ußQ:Áv\ À–¼¿W‡xö3 *‘Ã¥p—“„Ó…hhÜÌiÃ8ÀêÞݯv—’];“7à åøæ„êMŸ¨ûj—šp v8”¾~Ñ—èJ½Xc‚$‹¼œíQ'_ôw® RÕÎúÁ §‘$¨g\u©ÙSMÈÄ°õ¥ÎñÆÀ~djµ1ÂdjÈM>¾-?Ô•—žŠHð…¦o±0ä®2LÀ+)é¢oRrTÅJäÔü¼££k,M¢·-©¯é?Ê]âKcw€&*:+Tö¢KÈ8ƒÕ—XOò÷ÛZ¹Z¯/ô‚®üÂX¬Œ½5`öˆ“~&ðøšSa;SH :òI5†Iƒ9:’8©Äl ÎŒv…ÿ‹’r6M‚=,·º›Ž4½C}ÝÜ`ËÜE=¬¿Ëb¶ W¾óDÂÒßT¥É”ç[|Ž'JP{¡ 2?.õ¡äGÒȾz[6ÃÅ}špí (l_AEážÕ~ÈÚq•Ž;¾ÉÝŽÎt®µH=Òy¢‚.N’P¹;ò¡¿"DÜwó#œòùÙÇÞýÕ¡=ŸNdu|È:7pÐ|r2àÎ6â9ï ð-JͲwÅ*{-^`@@ƒç¨ãèæ¼ endstream endobj 28 0 obj<>stream xÚ,ͱ Ã0 Ð_ÑH§ˆÆ†à©xi¶Ð©dM xèçW5éq§š&®çÑþGAHÙ³…k"ë”r#A$bP~tšT»½Dü=†wl›ÿAä&î{½ž¯óóÚÛÆó³òºÛ»”Ÿâ#ö endstream endobj 29 0 obj<> endobj 30 0 obj<>stream xÚµÙŽÛÈñ}¾B0ò@V/»Ù¼rª««ë®¢^…ðO¯´ÎT˜­Rª<ÏVÅá&\=ÂΟo´@ld3ƒùöþæ›ï#³ÊUžD«ûÝ9šûíOÁ_»µÚõÆdAQ®7:(·UKýzE6hwøoï`ñ–×LFë_î¸ùî~¼ß£ŽRe“oÿ×ÍO¿„«-PúÃM¨"¸ïÆ¡Òy¾:Üh*c™×7w7»ò– ½%›žb“Li.Þ¢õ9U6ý"ßä‚oÙ%ÛÂDi“ÓUÃØüŠL «y÷t°k;œØ;uh‚Ƙ·<-ÚæçPǬxzèyý¹ìtþ‘$ÒðUš/*øÒ"nÆ£¸Ó6ýkÜ´ÁóÀ@¢{F—ºá`]ão©aVóäà> |‰ü¶€TÇôÒjXol˜ôÀêpÄCB ­ÓcqÐzžŒ[Ûò‰°Ö푬ìzµÞ$I|¿Î¢Àtuƒ ÔhÜ—Ï>÷ñt˜œ„;DJYòð`_ÖGFxtL‰ sR`\ê.¸C®4ÅüƒBˆo¾7¨Ñ ²Cx“ª,cÑÇ À" A›8x[X÷|n¦5xK¦"9u¿/tv1ö-@"D_?–þ]Ç:ØÞE?‡qúo’€žFrˆ¹Coc#ÞÂkAŠ®tC‰ü"¯õ^S\³%æ ì¿!DÀˆ'BP ÌìÐÞd4 $bï&ƒg§é‚É£‚ª9è@OÚXò„^€wàÄáOÚß”é;¬é;^Ù6 Çæƒÿ”Ÿ‚»Uï±!Oë8 \U»‡QŸA5c¡jÚÀc¬š~pMQ¢]¥ñ5Jèy è1ð-êäH“ÀQÔ½ 7©^œk¥Ã|î‘®xt†ÝÌ€É5Y³Ê@’™oò sE%zõXߺŸñ ÞƒÄ^ݹ§ªy$…xSí©üÖîĦ€'‡}Õ“ Òίôî\Ymà,cï «þwêoøkÀ%Ô¿¯ê2ZpQ³ÿ—Ts´aõåh3ºZßE¼Míqµ„dcÒTB†°µë%¢¹†Uã¿äqáÜU |ÍÇ*UªEmÅæ+E=¿(jAŽM¢U"R'‹ì›™PÉÿëÍa&ȉ¬+t J©‰„¿÷%¨,Rj{®´_¡9ïÐè5ȶî[;-þot:5ËÉ9æÎ/Î…OhÙ_u[}bØòcÕSÔÖädq©!µØL¾ Öæ¢à™dAÑny)""Çz¦ y(½¶ ü;ÙË9:1’‘T¤Å±cöúÞ2##=ËnŒU&Í% Ì4j[îÜ©^ D:´* 9îÓZ¼ÛyËš¬¶vÃPŠUŠ„`D$~D.ôcöÃ&ÙI1&ƒ¨/ÓË„Ï<|FA“Wÿtbm¬b8ú›Clœ¥r¨p(5ÈWˆÌ¶~½Â%ö@ƒärä.^ýL&Â8Å<á]Ú)?’;)’ÂñªH6›$K ”Cip s†£»‰zÆÓ±ç,,kG ç˜uÆ–0lŒv¡ˆ Ž8þyÉýÅöÅs"GHd^q¶6¢h\Íç8ñ†G,˶ûÐ ÆþŠ%ô'HnSNn“«¦‰ó¦ c”ó¶„ô›,Ž=°¾Ð~ßž:OTÉK…„™IþG–Çôè5%Þ±¶G>óüqn‘ÌÉúñÐÕTþJ’QI#Õf±mbÀPnŧ4&Šfä®™^úBÀŠR0„P]Àš¿°<ȵÜÄõªØ»Î ev‚$Žáì¿ÏNŽ®JR78U`0?ì¯ü=ÿ>Ì£ò‚mà/_ÄCPùݾ<þéŪÿE”%éVý‰'cB”¥“k…±äî8\&¼ps÷ ¨¨Å­÷ö èÑ…[ÏTš{9¿kŠi€|Ó°¦ Mð®‘k·h†•XwcС äßëKŠ6ôC[»´ñ¯÷ÔF ­Â:OÆ cŠbÈÉçOcZ@Þm'`â‚l<=Ù&ä9(€¶½ìb¼!µfk‚ñÀjˆÛïÑ3ÝÞòiŽ¿•ñ^wª½¡²[Û0õów»ŽÊVEM]Sˆ|äɲ`Ç»C°í³:—*Ý,¢¤>¸Œžßdúÿ¨ÚšJ%v`ß}äÖÖö,6„EÕpBÍoñ»á +^w‹n¯¸ëî$%ú.ŽÕâÈž(ˆÔ3¯u¿8Çq¯åZM.®)¬U¥OækïÙÚe†³Ðù£e™Q©ÇDç²C´¦*Mìe£ÀJ£àÎaŠY’=C%Ytì°×JIG`lÌg‡¯qöŽQ¿Ôhøç~ 6Pž‡Á3ÅšEsê°°ÒT ?–¼Nš`U/󇼶óÚÎûÈ8ü%ó“m<ÑŸ$ á„íŠì§Õãµ›·c5WÊÝâžÎj¡,;x#zG“›à8FCJ|êƒ[»Ë†ê]Ä6er”ÇoÇÁë>ßÀ1¿G•¬àCh €˜Ï2/õ¥ÐγZy6®“C²à Çí°^ F6ÇB¦ä(:¦ÌÓ²Lcé€$Å…·Ž}*Ž»rëÉÄéô}‘V6;k§V{ñÅ‘æ¦F齃÷Õa-¨9ã'„í†ò€œ_ A×ë•6£^Á,wª-êIß}p R¸òÐvr9µŒ#-‘a¬yõ l!$3 *â¶åöŠ–Y_uCºpûþÍ_.ûnNf ü„ÊD W1øÝ)[u+?|?¯eøÀfv‚J™”$O-i“Ç©,æJ&»¸7³*2ùòâó²I`.îZäßJÄfă—ý8²ÑJ 2ñ™8©îÍ"ÔdL<—Ÿbe×¢= ²6å¤M0šI0©[·¥šÙFs/Í~D`Z¹Äí¸ÍC¬¨9ÅÍU’.;ü³!Ææì*á—’^¾ÒØŒ• m¹ù!i!ÜóÚ¤¾4-”<N> zûL±Px¨|oA®†¹Sœ“Í&¶àòE`ô/i»>™j›Òç’+ú®ŒŠó¯ø˜j#úvùÙ©Ú¢ŠMSÁýÅ ß{K(Á@LˆŠÙIÁ,Z¥F½4¥Aù7Fe:’Zât ¸‘âÔue#z„ PvëÒFžµ¬60æ}&¤¤t‡ Ç;t¨U–ûÞ[C™L J¤/,þ_®¥‚ZR—ª8ñÝHLåÏùm²D…)¨ UªÍWxb3;¼›®=ÇÊᆞùVÂjJX7¹àÐ-ÂÀûu–‹¯=`HJ4i‡…‡‹Û:„’&Z¾åü˶À|Žús<Â;Í¡Ã¥_ÿñªôéÝÊØexá•N|ÁT;næœýH/ÒGõI pâžœ~ Ær¹<´È+æ¯õ-3‘gôi—*vY wíCMjyè=¢Ú7Ç^êEûÆí†:·Òvâ­Fzçýò6,Ñ8q/xaþu (ƒ7\ÏbúbŠ@/{¨ÇÆ>>Ú§ùéó±;E?}Ÿ1g£ééÀ² Y˜K‚ˆ|äpª‡êXK‡™šŽ cjq L³g}Æ…äòD¥£`%ðI(këIŸ}3ÓR™ŒÜ'öx±`‰Y$ÀY¨—|!üä dW}!˜£ŠÃ«5Jðw¶ñߧ˜p endstream endobj 31 0 obj<>stream xÚ4; €0 @¯’äc±-H'é,ê&N⪠<¾ÑÆ)ÇKºóy”w‡¨nÄ@ÈUlHÙ DÓì‰L3Ķ¢`‘ÊZ0[á´þ4ÊöÇ©—•´ÿ®§„ÃunÓ^úŒó~—5¥G€¬‰&M endstream endobj 32 0 obj<> endobj 33 0 obj<>stream xÚÅZK“Ûƾï¯`©Rl•ˆ`ðF*>ÈrœØ•”K.l°$È…kÔfÿ}úëî´’O)8žîéžž~ Ì& ŸÙ“ûA¾ÉâÀ/Š|³;Ý›#ÍüãÆ(ÄVA¶˜¯ßßüåÛ(Ü~‘F›÷‡k4ï÷?{o»[ãµ·Û0÷vÕíÖxÕ¾>Óб¿ÝFQìµüGÞ7ïh𵌅AÝþúþû›¿¿wô-ê(óã4õßo~þ5Øìi§ßß~Dô©ø¦(6§c? Sí77ïnþ³ÂˈyÉGVâ4÷Éf¼˜ðzWqöY¹)ÈBnùRlAê›°`Rçv yø·ÛØÞ+_x§Û0ó.4¼Cã^ûòPuÒ,hî¡kKšÏí|ÝËÿÐÊ¿®¥sÀa0ä™9´Šgמ LB0õnàåÆ+qf{%‰•-õ›X^ Äàžìñ¾:+möXò&>Ü&©W+È”DE‡âIÂÜcÓqxM[î«=I!ObïÛÛ<ö.är_u§¶«^Þn“ öêA íªú„]<½ÌkžvOU0Hÿ§òƒn?ÎŒ×_:Ù$:¼áÒÂßWÒ82wgËfÇ’j_Î|44’u{^aì±nZ†Þ#h·ÝíÕD’[eÁJûa.(°FÄÌ Ã:Âp¿A)z¡ÌVà?ñfyD®á^€1G7‘á[ è&D¡I¢$üÌÐÍlU¨´¹j˜ŸYʬµwt‰÷[µ¶¬ ,YXx7±uS@K˜/ëI,èÞ/A¼Æè{óVû{zj*á¼êÇ®Xä55Í­6²¤«~Wu'r›*uNÕpßòú½Nïʵ»/AØêy\ªÔèeóÚ;—'mñ=Š tM×(rº2…òÆqÜ%³Ó3@¥Žï›W@Õjáì>ƒ•qU¸·èÁ¼â¿ìŽ@x²àtz…߯ŸÈƒè½J™­E}xÂÎG™“«H2>ØÌñrª¹Œ²u'Q°Ð°äX«·¶tÞ tWÀvlÇ6¦Ûsótµ|yît_Ä÷×ØYaò%…®ü#/ fFKœ…~F>ƒ×«áUW•&Þ߶ò¸È~¡¥>,´/g¨ïýØWÿ†^í1ûB׿`¦41ù!yƒ¤H””îéñV$géhÀÔ62‘OSÞÈbA*yæ®;ÚŸ0R˜šˆ)LLüb¢¸ìíz{@Ô±ƒjKEMë;6h¿¸ö‡Qœøù& C?Ž#q‡pÉù¦;nló‡‰søídûÆl“úECPcê‰xábA”Ž"L‹9Ù+/la¤&grÄÈü¥ûžÅVª8aó!_ÒÎN†øzö¬˜Î$÷NÜêÈ †¾É‹¹iqÚ˜%ì¡ð¿ëXÊå ÇKj1O–Ì”©ß“R-D~žÆ›”b¤8Ï¿äœtÅv²d!¾+¬lNœ6‘†a®3ˆ´’ùn®Oaž¥Ÿ?OÂ}\Ä¥º$~f„{]ñ<õ9VP§86\ ?ì=Ë­€ Ôl„Wº0Mªd ȹ{ã¢1 °k4ÒÐu ·çqÅU Ô_îØø¯+ãŽmÜU¨½ ü½)ÊE.‡©£rƲ·Œ2?r,ÜÕ¥¨1ÂŒ”cÍmœhxÀ‘n74+:VÐÍvþ½ƒnUŒƒJø øoy&qè'&wš°Í‰ƒï:§ˆL¡uPuÕ½(˜hgæ'‰Uéx‰¯ÀØíPºsœtGôÜYžÎ0Pi¡ªÉõ…œR3ó+’~#†­÷VÄhpîDÑFi“I¤15㬉wEEÒ|)¢ eÏùV¨yWø‰£Ç½óÜnÏ•€÷G66ç Áe"šD‡ÛØ­ò6Ó1¡!ÀöJµWÒÇA¨Ë<¼ŸjöÔˆ2Ã/U?¡GªSÔ£fFs‚N8%̵&W&rAãqA€$C0*êê£ÃÉ)Q#@+šNHIãÐði}Πƒ*¨¥LÆl%$St-C)5ÙúçT!9 eÍé|{ÕËI2(U{Ñ,審)iãÖ®•È»´êdý”mð ÌÅW@ †øÿ~ÜTdkÉ£5z®º1üuYFŠü (6qšøÝ•‰û]©x ìvÌ~879Ý´tR»± |çªaÎ,oxËcœ|S6e-£ÿ*Oå‹—ÒNsë…˜«€¸’RP3ǹOù•ÐÑåwóîî«]ÃYø¹ðƒ%o>A„ã«#ƒ6*펲O?tõy˜£]úÙü*x®9–¬†P‘ÿ§ªìt¨möþ‹Ïlrg7Yü¿7yí¾)à(BQÈïË“ô•,š}U•k,Qâ“©´Ž+E—f%¶ Š,.õsSøAd=×ÍäazJùû"KÈ6n,ãaÝ é v&•d„cþ¿d<ÎübŒÕ{¥8-tW(ÂÀ7±ãæ£Ì¸€:çÈ[NÚÄmR —ót̲—yœŠådÃjOc¨àÜb×´.Õî¥hŽ¢²|ŒÈü­ø ¶ ³ˆÐhЖY¹-'©¶Úʪ?±=™rÀ¦F¥Êvm\šÅ€p†X´êÊŽJñ'ÊÙíÍ `QTx¥«?í\M/Š2-ÒЪVbj®Ç­2ÇuL4œë1™Žò ¾®>bê̵ž(¿vK=A*šEŸ»dÆòhŒê@~§Œ×½Ö]è&3×õbRÎÛmîãîQ9TšE ©’†C´iQ©yªž ÍÓ&n»Ú‚ÖMWîIîg.b…’VŸLs"jEV ¥¾Ê8Å¥v)·§ëA,\j U‡z-chiqRÚžR¼ #¿0â8‡1‰Ú¼¯cŒ}}lÆûêXäá“«+#ˆC­ëxèI`x„44ueáIíOâÞ!öÒîU³ÐÑ»ôâÂz\ ÎøV·û0¦Ûjׂ³ö0ÔRÊzùX°Fi‰/ÕcÝëÜÄÀaÖ Œ×!ϯõé€Ã´FUŸؘX o-$¶f}ë\ K½{{* ·îB¶+lºÈî%²À§Yã¾¢è°Ñ"¾412F¹[âç®ÞÖÚºf{MA­¥¶¾ñÊ;TÉŸtÜåÊÉÚ“ûʥdå°ÐEC¿Ëš5…Lc›@-äâÒ8$щ:»†»¤ 6?v5—x”x¬¤’í¥‰3n~.¹ÖtV&“à™v¦M¥¾JêˆÒ£it¬Šó¡È òœ*‘ˆ<©¦ò¨Ërij*7ð¦F›”7µZßÌêÉû™æÛ©æÛ‰%3+{A¢ ò@A;y²r]½»t²è¤£ÏsÜà­rjN‹&€Ç¥&é×Æ{XÚ¤^ Úè”|˜ÁŸ‹¥{:Y„¹É%át¦.ÍÀ¸,®¹þM‘Cÿ¤€«ïºqz¯Tî5Í’ç;¦­_uŠZÙÚ¥jœÚÙe4Z«hOŒ_v9ÍÓGÀ8Û…Îë7oÐ{+ ÎjɤØ"jh9‰²ù%†‘?y8£ÉmÙÈQ§JìZÜ×ýƒSv@u/z hÆ/ƒrˆuZjB/ªŠ7Åæ´Ò–[É™6õÜÕ¦ö^ F¥30™Ë7BôXÞË–þÜë8>Wà'¼Ú§“?MòõÀg›? ×æ¢ÿ“‰ÿaˆz endstream endobj 34 0 obj<>stream xÚ4= €0 F¯’ä§E[NÒYÔMœÄUA:x|£SÇ—à€ ë0ŸGy0pˆêFÌ„|EGÊ­±@4Í-0‘i†ØTô,RY f+¼ÖÿˆS¶?ž´ùSÂá:·i/ }Æy¿ËšÒ#Àñ#ö endstream endobj 35 0 obj<> endobj 36 0 obj<>stream xÚ­ÉŽÜÆõ>_Ñ0„ ¸i«¸ÉÅ’ìØP,ÇRƒìEr¦±É1ÉÖhüõy[‹Íy éÚëí[Qí"ø§vJåa”ï2…E‘ïªÓM´»ƒ™ïo”¬8È’ƒ·æÛw7ß|§ã]©Þ½»½<æ]ý>øyÜ«`Øâ<¨šýAMÝö0t7íZ›`¸Å_¼| ƒ/x,Ž"½ÿíÝ7¯Þ¹ûíÑ: Mšáí¿ß¼ÿ-ÚÕé7Q¨á¾hG¡*ŠÝéF©(ŒãTúÝÍÛ›]Áe9pÉTLš‡Je+\Ô*“ý)ÝdɆn1âIâ.JCtYAPLÅIð}9~(ï€~:K‚j€™®ƒ?DÐjF Ú ƒðÌCóq»Hƒó$ ¢<üŽö [Ûp#ȨŠ˜6ÉÚæ÷s ƒ#MËà©9aoÀm2Tö. 7ýx?½?¥‚°æ<ó¢Rö?à‚ƶaKËøÑ@óù{% ô“ o>ÃY„«ŽÖÈ"5SBö— 1@Ò\Ã2œ~hñtg"ZέE·Dâv¸& pEùQ`Ä$nnçpÈbüWš<Ó•ýÝï˜Nˆ|^}Õkømû;^ûË×ü{?xÂ'\TËM%O}À³Ún>1K‡ÙAP;Xiï@\ö‰Üo’°‚ÞHà N‚‚sEj²8ÌŒB!hi<™2ÑF4ÊÁ‰¡², ´AO$N@ç†7ÁÜ!I‚ÿ6DãyâÑÛÉ­ù( YnX¨PØí|9s« ÅûaF$@ÁrŸcsÛŒNškTÌþŸ y…¶åüz»¸›¤Ið–¸U5¼r‹Ž’I;6c;_\v;Š|á*BoäO…i¼êÊIN,GYKÄœKšð®Ÿ–þäié7‰ðtA€8!X$t¤Q?Pþ¹SvÓÀ­dÅîŒL€á1oÿ°8ó:&,¶™§Ð ‘´ —VC× É|±ÓÄßísƒ–„ö4ŸËÓ}ׂDÈ#â3#ã#|œ|lʹ©Eùú©­ElP5ømÞÙ™9² ´¡ìeç-ÛWj“}Bzµ Ë‘GûIÞË)WµÿŽÍŒŠ<öM(e…5D°i›lˆáÚ–ÕM×ZçHZ22ØFÒn$!M€8…°z+E˜GV|Žh]ø!S"dEðCÏב"ü'¶–lísF·_Q ØUü‹ZJ ¤]é›Ü;½ƒÌ q+"^¬çI§f%à$:æ‰x¹s †í'ÞC–™Ø.µ<ÞìÑ1²_h$Ld¹vü¡³Äj9¬je5r´§{Z?Œ3[{a/”äâ`”¥¦¯œOÍÅHñɾH0ºl P­‘tô¬¿æ1`g!Mf%gã>Š¨if<ÁŽ_£$‚ÿj#<1(^‘,®Â·‘I:š™;< ¦òã©0JcÙüÓ¿_¿¾v|[ÏòI?ȉDXÍ(X z´c¼äŽƒÌ_óXeevr†æÄ›XâŒÈ§Ø@wË$–&+À¥d+ÚOrMÏak)al)}+J‹"ðx+ëÐ. 2Ö7"CN¾‘eD–Up̳0Ïó%.Œ%.|ÙÌ%EKÓu§ñ_ñ´OPÚr³¬|#­6BÇažXæ‰Ã]–‡©±R4ï­ø‹Þež+Pzr/ÌÔV `SEdÍ”§~0J+N(ç®\;\ÛœeðŽi°ç‰«¯àW˜0U©Àßôæ¿¡oŸÿŸÚqÕПš~öÈå#Q1P›6¹L¦Ã4Ò»$†sg ˜¹ä»ñng›¿ø¹—l8,;.ó•‹3™ç !÷ë’(qfC¯"„û×H *ZqzÈ•\ͽâ" S¯à½Èrì’/@xqŠG…ÒýcÀð’S%ª *I Å˽¸W1€¬ìPN*>1Ú4ÈÉC[µsGîÊ©u’ä+¶²'Ž~G™dïþSZÙ%Ô`ƒ]rê a\Cö¡–.ŸC%ÿth°ÉÄÆVª<¹³t×Ì(D}yÂH(­oz@ýï 0WÍ´Š@˜£ÌÙéÍñI¨í,„›í]¿OôAFÅ:]‹}ÙŸw=8”"·ª„1” ¾±y†…ÖÞºÎG(Â0|&Ž`p2‹Å4—ìŽO’lNMf$½{E$¤œÁIWb'ÀU'¤¬>® M”G‰º©3ü ‘¥ŒvI»u‘¤K:ÊÉ¥G¸ý(‡Žíô‘[.º„¶Ë¾Ça$Ò(øöQæúª¼ŸÎEœ=âí.ROlêÚíåºÔ9bßÖ­£K®ëþÞ„Yìsrs–ÿ¸ðÚÉÒÕÓt§Y™¦l~Ɉ’`¸_ÐH(Rd3'…/{gt×µ§È nÿ²Ö€¼)Ï*_…2•Éת㟑‚fY|ß¿ÿR°¤ ¨ðÅI>¸þIXuØ¿máÈ .±´<< Cæ*ùSf B8ÒPýÁ ª“ÏùQ*ÉⵊÃ4Y§ñ˜Û¨ 5O„ë«B ç˜4†8Ç<ËÉòŽƒ·…|XT(2Ã^Öžš„§®¸w jqqõe5UÖl.[¹ôõ96ìΔä){¦¦«…2/¥^ªŽ£e%5<Òk¥„É–µp ½å½À™Gn= K¦„ç‰Ð®¨ãL­l–‹K9¼uA7VQ ¦~ËÅ/1»© 3µf2Ÿ‡á•¢èʹy*S€ ¸¢Of¸ˆÉ3ú °è«úB&¡ÿàWI[Jì3ŽÅqIyž‡ØRŒ yj7ÑË!”ia‹j~™^¥Q~°¡bž>x§¡òì_%½Ð‰u´®Ü1Þ§k^qQp)ŒŠ?õT sÓã4ó0 Xü‡£+L¸íä•Ú“i&Þi‹>:bƒKþ'nÑðÒÞ P(‹¾›¤2f ùVf8:Ûæ©_d©†­äE.e&lݳ=`iź†gfY1•(˜®€#Û Ð´ÞR3~Ð"¿Rd" §u¦@ØUg{ßi‹­Om)`^A³ú~%f^gB q»"#Ãn7“üíÕ窹wU'4‡G®ô‘1Q/‹ú>ç1ÇÏ\›Iƒ¡&j¶ƒŒÍüî¢]=•8..tâ‰[N߈uÐô¶.sR‹”Ú?^Ò×¼ØU‚\š7Ëq¶¶Bâå9a•öÙB/6îK[Wþ¸sŽÊ»%ï=¿ ‘$¹\U8¥š ýr°¿çZ3Wßêk‰^Q?¬–6Ÿ©,Ž DáÄD åOð¢sà”ÂRÍ:G¡`;qzJp=É|šT1¨I±€ÊFyá>®gù“•ÖˆsÒ’§?™UðFågƒ[hÛ352Q•ç»#é÷%½À«·RÄ2 ¥ÊU¨IN±BAU%#¯J81ŒÒº%ebs‹ŽŠóKgz´W‚ÓXâ­ ®0‘g*Q:Ñ9åªJÔ¶h¥Fš-VÚ¯VD·ÇÚ’»Î9U·ÕÈ&T zÊ›K7¯Á-§Êìt ™wþœ4Þî8x[.þå©H„x{u&Eº¾ú"°k¾|Ùú?'Olõ-#æŒW4ç$<÷l‹¤à:Äy–œ[­sÊŠK奨­N ±1)š^§õ<ÅzS ï$ôw Ë€ºqo•wã‹0l»Oâ„Gm«A™ Ïàþ¿Ÿ•Tï©Ž"'Wc]R—Uü°H5,³×û'éEýÚÊ%[[d{Rw‹U^ꈖÔá¦j“˜02z:̲çȧÝqð¶\FÀv .¡ÎÙ)µ¹¤Øäw_–ŒdÍæ¶k/ã1Þy³óô_Æ_ !ˆxT dBÑ‹^Í$i؃ {p† ÏïNÏz9G[Åù|Ëâ/v”bäÒ™©Ü£Eéž­²0YË<:éÖÚÕŸô>ó?x×aðêû©µ ' È6 E•ÂWà‡§St¤zìøõê!aóI†£¢ØÅô%]å9W¾áµo11ÛÄsiêóZ–Ð ðW/ÛOíDºå¡üûG3áWW±A.B'–ßê Û§fó;=¯¢¤[ÂkÇKsAäk4P$„êy$XÖ>EY±"À+kûþŒÈ0¢ˆ¥Ê•ÏhTn ½ª—Ñ.ŸðŒlŒ¦ïY¾ø V2µYp…(K’®1H§Òå`‡ŠÂK¦aÞe°Žk y.3s¥iÍö9yƒ„¢e,ïudG ŸZÊ !òªy¬ù<¥<ð¢À1®áÚ`Š~ f!ßÐCЋ1jÅ5I₪c‚JNAŸ—¸¢4€Ei꜖1y' •-'@²¯ä5Ô~ÅEm”Å‘ápùFm&aŒºMêj#t:¥u†¯¸Í¹ãG!ŽÆúäÌ¿§M&¯ÃOlR&çùùXÚ·«È<9\É“pÀy)5HÑ!›TèÑf¹}¼øöÈŠøa#Z‹}¢m1u¹ÍËÄÉY£é·cÔ0’Â~[ËBb¸\¬ì)úúM„¿Ã } G2!•up1‡8…øZ.|§ïš^ø±û-x¨Cà® ³Jêç#Ù-ûÝ $ÂaÒìéWMÐŒtW鹉„€XØ}è"wM’…±«…¿µ_¸H™MðZÁn¿Þ'ø¸„ï¶Aæôy¾ã æ6 2 ¾Ég#̨ýfŽû[+6&$SšXS —o_pƒÞ©U ½³ÐÌQ±ÐáSÁü@Ps5¶À/Šüê¤Nñ×›ø.‰Áê endstream endobj 37 0 obj<>stream xÚ4; Ã@ D¯¢ècï‚Ù*lm’tÆUpCØ"ÇÏØ+Wzæ“œ„¦‰ëþiÇ1%MÚƒk"ï8x 6Ê!ëH*²R¾ut#5 5u†ow;’WáŽM‡nWÍ ø\-…çïþ~nmáù^ùµýÚZÊ_€6ß*÷ endstream endobj 38 0 obj<> endobj 39 0 obj<>stream xÚÍiÛÆõûþ Á( °&sñÚ€›¬ƒvÖ[¤…ë´4Z±ÖŠŠòz[ô¿÷3$ER²‘õÃXsH>¾y÷5R3 ÿÔL©LÈl–Z)ò<›-o/äìÞüp¡<ă,z0¾¾øö¹Ñ³\䉙]¯‡h®Wo¢Ÿë¹ŠªùBgÑÒÍ*r«rnöó…16ªÖx5Ñ÷¯ááwüLKiæo¯º¸ºn÷¨M*l’âî¿^¼y+g+ ô§ ) ìwk)TžÏn/”’BëÄßo/^_üu‚—ñ’u¬Ø$J¥G¼(;¤Ê¦Ÿ”›É-‹M&B霶z¶›/lœFÕ»ù"Ž£»%Ê®ñ×xÍ¢D¶›ƒdø~¹-ö{^6›Â—» €‘èQeã!Ö¤˜[¾¹ú¸twMYù]—¡m R•ÿ Ü­ñ‹ú¶è OA‡% ƒhEÇÄCã7¶FF®¦íj¸ÓyT Ú¯ï[ò'ìZ6ü¢"ÔÄ÷ò€_×n%æ 3…Ò€†»‚W YÀ]v—]À¿ôˆ—…`âßµu…|ß÷¨9°@pdµ=X‡,ûl¤Uäÿz9÷ÿ’±„?Åôo6ð‚ß‘„šý”X-bоŠ6nÇ7ÕÞ‚"Š-\·ü´ã(I€ÏÃÍÕ„—ÞT`íÊfãê1Z‘¨Ø“ÔÔ€|‰\ 9Árs’›ŠÄ¦þÃjµ2"VÉæ“È´6T€Ò3“G?®ÉÆÆjòluB ¤Q™“#w€Ü[)<-Ñ‚•D…°~Q•Oƒ*¿ßixE>ã£"™øGlO°è¤7Õ;ï>„nÅ”´*@L¤N^“…5í´œp¥ ÛÉŒ)N‚|o\ó‚Ô¶o®ˆR¢›£hSɘÀÌOê ‹…Ô…i0F ‡ftu$¦ ÙmÅ ­ë.¢d*2T[ìÅrS€›è¨X’…¹úœ]$VÄyzÆaÆ5†\ n§ÓHbÈ=°•ÌD’[Ü O“ôA† V䙆€Ì~…L“Æô¢]Àó*g‰Iüy+7±v:oAJ³€mõiLôL¼òÐDÚ(ƒï,kz*+i„M%èÙ&%‘¿…ÔËQJ”±P³ÞßNeÅfYçf“–eVÁž''ù,1Z¤JÓmPáˆKIwšéóã˜6È4~–ƒaî>—*†>FÔnò(,-o©ˆSýÅXKGTgJ “MVh ÅÔpâXä)Çä=Æë%W¬n1Ô¶eTÃ.!Â[;ˆ”œP¦¨£âq‚fÏy¼î{’–A ç$ÁïuHA/%¶}qCÔ†u‘Tb„mL©¸Âå¢dB,ÝÞ_›Xâ,PåŸKœk!“8Èå(ãPl&Ê ãg¸}…mÐÿ`«";¹%›™Joç¯N()¤O}ÖVâ 0© “×MAÖðþzž™¨.–nàAÛrßœC·×W'¬X’ó¶flIwÔ¢qó…–@2I£÷°lÅräIÓòè6ýêäkè/ΛEœ&Š±®´ŸA¤¢_PEÙÌ?)€n—/%€/•db+¡LÏ j'mm×Cûvã6n·Ú{Ôï+€ŒoÆÎl¹à(÷ÍD‰ý ¿‚¸@£²0WÁÑOŠU7å!(îŽ ?À¡t‚ÀØÇãë~#¬ßãUËDÃüœ {½éö*†&ÍÍÙ9bæ„öm®„Ií‰ÆH®±ß–þJóÿsu]"_+œ˜Xµ-8‚µ\Âz<:@èþ0¸~¼rë‖âÉêÇqFÄi¼W™ë ‹(¼šæZ<ëá›b ÁñbMS¹Ë±6Œà—6ÁqʹNv@,iÅêYjIúja$õO Ó\…¢Ó“ïËåžÅçïøúWWâI]Ä®vÇU]Wõ%¾ÑRjx¹Ð’(y©í¥Lßò-Õ×<¿¨vþ›3[òøਿƒ½u*²Œ÷NÈUBŸ|ÇÞž ^¼)w7 ÜÔöÆAÃ.ÕÆ |  üGÜ(Ò’f8Ì@9dPë3-×›‰i‰VB%úü4ΑS9©²sÃEéCOÏÂMÓnØ:O„¥W ¡Ñyt øÚ²@:QÜœRd/IÕmºK@w‡0}=q&ÓÎrù”eå5pÙí7. E{ÀG&*i"¬yt}èÅ |I9 ®nÌ/~êë Ñòù`wêâ'È–ŽÀׄæéÅ}Ùl˜†]qëcQ§NcžýåŸ#—R¹P&„×ûr»t8•(š–¸-ÂiÞ¼/ñ8\†Gâ6îŸá­wár·$%øÓÎ1u*‡¥ÚáˆÄXŠX…#¢‰3*¤Ä—4£-l&t¶Ø7ÕÝéƒ(¨´ZH„@ÏÇêÎ\@:×)2žÒ1< :–‰O+ó{æG»Š¯xÂx8v~#C îfkqÑzf2!ŠâF©¨é0Žd‘ ºï¬Ó*ÿô)WS¸ìYŒ—tÜRɧv …2R’a?)ÖŒ®ØÏ¢¤¡D¸&eÒ!ëvËœ„CG|±ô‰ÛÃÁæxðÇ77nçjðM¾k%kÍÀÁü[z3*JË»lÙ”Gi¢ ØðY#+ט®Êîú•‘èÓDä&Èò„{J¬‚äaO4?e´Üç}ð…HA\¶ w•Ò<£¦“‘þm´g½iÈÓû~õg€Tn×g~ä¼WÇ´Ú_üƒS£Ü5xv}¢<×Y&’L^}Þ>U ¡Aÿ—”˜ «b_sgý‘Kæ?,øº­nZ£ýÿ~¢`˜R<é>Xô7á¯þ÷”ÁAÏ’O"?c÷I˜»ºÜ5HTš7Ð?Os¿eRŒóLNÇ®] ‹ˆoEÝþ”¥q¡ŸÀWT ¡!Öà%# _Ãbeœ ’×)œò6Ð ë¢é_zýŽ„åÖ^¬çÕyïü7Vî ˜VtmZ ‰O’Aä'AXÝæLXò¶å¸³Û7ÅnéøMûƒG•òÖƒ­ùZð…í`Gº¦µ•Š±ç9®ý\ª(çªÐMªÍe»ÉQµ'Ã}ínŠzµíwývÝoÜq>7¦qL”¦+M¯>stream xÚ,Ƚ € @áW¹op²T§p–j‹¦pM‡?E§óqÌ ÎaÈOi6¶¾ ƒ!Õ9Qµ°c³&›Á.J€Eš½Çøæ{Oåĸ<ÒW.ï×ýÙ endstream endobj 41 0 obj<> endobj 42 0 obj<>stream xÚZI“Ûƾϯ`¥r«D¤ÝØ.©8räÄeGŠ$Ÿl0$HÂ5ÿú¼­ɪ©4z}ûûúz£àOo´ÎB•mR«Â<Ï6û˃ڜ`ä»-3v2e7™óÏ÷{e¢Mæ‰Ù¼?Þoóþðsð¦Ûê Ýî¢,Ø—ÛÊCÕ@שßA{ħ ¾}/¹/RÊl}ÿýÿÞûóÝÖ& m’âé¿?üü«Ú€ÒïThà¼'h«Pçùæò µ £(‘÷úáÝÃÿVxw#^²‘›d¡ÖéŒßSeÓ?•›LYÈ-žlhl2œJBåtXÂÒQür*øWã¿ak¢àÄ”ÆÁñÖìè«Zø×ôHÛŒµÙE:Ìà Üï? ¬‚ýŠÃ× U+C+Ï3ô—ØN‚âØvü¦ƒ ýo¶Qà¢òÀÓ¹›±zqÛû^à„t¶ßµØoaʇm {Ÿ¤óPþ¢´mÜ9=÷öíEÆo=õa­æCo"‰w{FŽ‘K­Ã<Ž‰Ëã e±'îFr¬Îƒ§3.2Òà =* Š®”ÆõJ»î‹ÇZºP(øl·»8~+÷Äm/½GYØ0ô²¯‹^ø 9?ÅPÈž4ù ÂJ™ãp»Kb¼AYe@&ÇY¨‡æVD¾‹…äîõÌ~Ã<‚õ¸„çð_¿¨XáðÔ {ÌbãÖT=r%šË'C£¨êRŽ­TMÛ] 6&ì+‰½öF¶JË`{§Û)úHfÑU°8/e¤hð ìœ4'ÀY½£ ÓÔˆ˜¶:W›< Pë 7 zfAIjûˆ{ud' LÔ; RLê•‚ó»r¸¡;°íÃF¬Sl»â"³žªºæÎG± šê„‡²*n Wê&nÈoéТ)6²óíÖ,À‰:7,êlunAÔ¥XB:ªâO‹V/åf?nÁêÊna S“ÈTT S°pø4|>HtšÇh¥ÉþC;~’óŽêCe´ jïÅ’P£ÎþPÄ!ºÔ2®Ù(T,yÞÊ>hŽ‹C… ƒjÑ1ùôÅ~;£aÉLÎh{KúÀ?2wnûø[‰b܃ÁàÖ”K:M›ÔÓIò€(D‘ðŒº‹Yl(²,!Û>—ÜÏ2­oä ðNè#%úEf½™a{p+ï.¹Æžªá|7"Vá]€;°éPÜ+ -XÏT6¯¶ëÓ6Ñó©¸P-—IÛ„ Òoœ›0±³ü¸‚/xîn2™¥6ˆtš'Ý$çïQ 3Ô5¬ &zqWHºqîlÿŒ~§cÈó¢å`'eÓ“oá+h—äÚuª3Yî©1TaRmŠúùRÞ(1s~Õ± þûîõÃáSlæ={Ü)¢ƒx8¬J€Â¿ù–3G ©PËZG+kŒvÅ“ù¶xúêÕVFOW1ø®lÊ7Õ§µµ²C ´§@ò³œÞÜ.evÎŒhä^)Ù!‹²5 ¢á%Z±¯,Ušw¹ŸúéácÁÑ=¨ª!$I ‡òâñ ´Ïεê+vD–’£`ƒLêLÈLÌ@œb±œ…rÁo¯1<3i Cjß—×^ž&â? ÄZ¡“ø4v."$ƒ]¸{[(OAÿN'ØxæŽ@¬¿c‰;%"-‚`é0εD³—ÂÆ‚‰ íçc3à[1Þûxî" å€æÝë‘8‡¨äf¼Å0|h)/éÑ¡Ò.ûAj†ÔîÚÄ¡Íõ,ºMP\”¥À( =ʲàÊ7´­ê0­8 ‘>+†É¢6ÈäžäÕ •xÖï7¯ÚgL›Í‰ûgÆE÷h æpœžbÀžRK ˜.ëƒPT{˜(4³SК¦Ádï«Ã &ð· ô]ÙO“,±0˜ùÂ1!´œN/1n dÇ:$|‡2z¢;cÃln+ãÿòXôå_V,@O´Aøù%ü–{ ÑRˆ@Ò‰ây~›Ë ×Pñý]€;ùRÆMô+|²ÒX•8N¨gÐU ž¿ßÊ#˜²pã®#E<êmfÖÀ·*­Ü0uc#èd@n6¢&ñlÚQ¶†ÛÓVq|W+Bw"ãdª%hrŒ½Ïï)@1¸?[‡&‹8¿ã<Ût§k¾fyY±›,¹¿zßïJ‰V/ÎÎ`–™})xÊÏÊúEÑì,–Wªø¾ÏN]’É‘HÀ¹B´…„b u½=´¤ö=¿’‰Ô…»ƒöÜKγBp¬à³øbp¹V ¨$üÀ |ØXTœ– ŠfŠ Ò¤ùé%§‹ÚŽM8O íTî~l¬a{¶–ÅOÆzhïâIÂœÀjšCyžÌ#µ´_]4'$„ÊJÅr¬¸TMå¨ÄÆ>ÕÙImÚ—‡™ù&£ò,Üioäæ£ ±ØK÷zÈ Wànw¶"`3Nh„ép›§s)-8½o鎸ÏÁ®ýX¡f¬ 8L-ª"ã‘ÏÒ)+/ì¡ðà#¨S!ÁJqZFÑ4#ãÂè?ú禽öÕ2qÃÝËd.3Ÿvhß‚lš% œ™í¸M–r™¹YRcçÕÜCLÂ…,ù†^ܱè¡©$p`ã^OZM äü€TŠÉÀ ®]„ Ùoß^¸Z+¨ u;Ö±¾¬Û,q©‰y`/‰ÆÒ-Ÿë&‹ ìf¬'˜Òsd: ¿•çœ4åè,ÛP)DΨá‘}+õ:´ònX;>†dS_WÒÁB !b=Cĉ+ž,"GœCPÈýÕ‚ª/ü–·ª>,CgÆÆLîÀÔ7rèXÔ¹ËÚÔ3kÇ’#°ÙÝXéQ¦¦w¹ÊE<5‰ˆ @­h$üžHÈ~ÔÕÆ|‡‡ÝÁsŽ~p•!žO ‡$žL];Ñ_¤0XPÃÍt,a1¢MRFÀ‰¸a¢$-/às"!ƒôäc,!!âJ‘›2Öš²ê<Θi@(uŸ72®oKÆZöZ ^ÜŒU6>«°Øvñe}›OÊúQÐÑ@Ñ»©ŒRƒ¨vàI’uÉÑO<,_Еð•Dòü .‚oVg‹OšdIŸ¦¾D4¶+•:yúµG-ÕôG6uøšÃýô§Qbƒëƒêb²sœŽ‘ŸMKÉgPNq'tå±ìʆ ²˜—¸W„î&Kº™ÚCNep™#Y|š,£Bë¿ïØfªuXq«ü»‰1Ã`²;Ý&Ÿýüï*È3:ÿ#‹l’.+%s‡Êú;qIF»ëèK0錛͞K NU¨"r)Á‰—¶stR.èZªpUÅ0½aÚ(xÇqŸŒøðB–ôŽ‡5˜Ì‹±Å~?–@IçV:Ö˜°=)~K*â DÏEö‰¤¼…“t8ýyÕ¤Àùç~¬ n î@âN>Ób qæaŽû9Æô—QFéPWšþëR?X±Ð“ªÇú/4„ ·‰¿Ïˆ›LÑž®+?¡ÊUhÍêo•ôÂs2ðsOÀ endstream endobj 43 0 obj<>stream xÚSU ÖuLÉOJuËÏ+Ñ5Ô3´Rpö Ž44P0Ô3àRUu.JM,ÉÌÏsI,IµR0´´4Tp,MW04U00·22°25çRUpÎ/¨,ÊLÏ(QÐpÖ)2WpÌM-ÊLNÌSðM,ÉHÍš‘œ˜£œŸœ™ZR©§à˜“£ÒQ¬”ZœZT–š¢Çeh¨’™\¢”šž™Ç¥r‘g^Z¾‚9D8¥´&U–ZT t”‚Бš @'¦äçåT*¤¤¦qéûåíJº„ŽB7Ü­4'Ç/1d<8”0äs3s*¡*òs JKR‹|óSR‹òЕ†§B盚’Yš‹.ëY’˜“™ì˜—ž“ª kh¢g`l ‘È,vˬHM È,IÎPHKÌ)N‹§æ¥ ;|`‡èû…z„øûiCã,˜™WRYª`€P æ"øÀP*ʬPˆ6Ð300*B+Í2×¼äü”̼t#S3…Ä¢¢ÄJ.` òLª 2óRR+R+€.Ö×ËË/jQM­BZ~(Z îÒOJLÎ.ÎI,ÎÉqazÆÉ)¿¢Z×ÈRA×Ò h¸¡¡™‚¹¹i-ªÂмÌÂÒTOS #ˆï’K‹ŠRóJÀ©P0~Z&0pSS+R“¹n^ËO¶nÉš¾­meëâ «Xõ9žXûò&ûˆu³3SjƒMç*¦—,yµðÑÖ¾ÃâÙ%¼’­§ m‘ìõë‰û²HxÍÖ®Ë"&4˜î×»,^ÙÜ5÷Ÿ¶ú+ÏÃ…a3æ´>’¶Ú_ôxV§²ÎÍ/Êõ'x楼pŠZ¼ïû½kÜBZA“´”¤Ìo®`¿Ë(&^y÷ùeùO;꧷M~wö–g€x±[—úÅ4;î¤/‰ßžpŦ•]¼¨øÌñà•Ê%Rþø÷ì®x#Û¡Ô®úñH𲊯]uÒÕ×O°‹_êxÝ»ðk?'×~Y§£w/n9þH¿¿Á}Ÿ¬Ì‰ÇÆ¿¥NhûMI7¸gÌ´éÙÉÓYOB7®7lÿÿ‚]jiÝe‰Ùs¶O‘uySU¸|·í÷PñÞZ=ïm3"ß/Ù}˜ûÚnQCaû+7ûÎçô;ÃÖeä[ºõÛ´}¯õÅŸ¾59sí‚û’Ç ¹ <’skc·sõú'ºýcë=øô^÷ÑsÁ[œÌB»ìpq >ÆyL}ž›—½ÜnÆ Õ1q40ªý©aÝwú÷>ÝÐx£O1O…zèVîÊøº÷„Óã.ñ—±¦¯Ew¾ùZzÌiƒÅi†Å¯¾ví¹ýhûܨy›U”¨D4ý:çèÞ´ÿ€ÞIñs©³w›gå°uª]|“óÊzÙëŽéòì’BÛ0ðDgäI˾ Ì°.JßRþ·™Í ïÉî¦×Xl,JoVäïJb˜¾ÿ­Ló,_ÓY[Žø>¾­uèCÀV>ÏBåÿ2ºÇ­öEܸ8UgêÞÔÙ†[·˘¬œd_Ó»¹n}‡…€kÔ€aa@rNjbQI~nbQ6dP‚Q endstream endobj 44 0 obj<>stream xÚìUÛrÛ6ý<¶Óq—Ô•šÉhÆ—¨vÛ8®í¤I=~€À%…1ШËßgA€’ÝèS$œƒw±»@1c+æ,ÏYQ°|>[°bÁòÅdÌ>|€•Ñ> 9™Š)-½‡Õ('¼ˆ¸`£lá8#> endobj 46 0 obj<>stream xÚ•Z[oä¶~÷¯0(:žBoN–Ôäó1»“Nï-›“è1.†œ>¢çSh§œ´UQdF¯ò ´U„žÑ×$=QDÈc"öµŸI^G‘UN2F»¨øQ³JR7M0Ú „çpg’<Ð&vÝ-˜™`ÁòÖy R1T©zpjœ³ëÀç¡Þu–Íxì¼ýy(,a»¯Yiw•0"c¢ÕŒA¨{£±Ÿq qsŽ¡â Šä#ØF¤ƒƒ½ôhïÄ<ª}•Ñ€“Ûã@1¸~fó1ÔDñuN6Ï;mêÇÎv/ï—à,Ò<õXn¶ièJ‡éÌå•Œå9×$ø§ÏD™/ðÓ‚ÁiD¯D.@8¡ßPÏóÖŽ#»oòõøb®×:Ë9 ¥W. Mà~â3EOcP&C”Ç ó”„ä+æ®Lè‘õ6̓D%3¦°ý ƒ/fb°FpÉÓ±ßë®E?¸.Έ fü¸…®v僅T€ið.SæÍ|( Çì,†g'_/Á€sŒ²õŒ›k;™Œ«IS-K50"÷ â®þñ݇û…Tu†¨F»AŽÜ{x±¢¾qz4rtÁ]u$æ­š{¦ƒP9½z¢ÔXº’PPZ`T::d#HdËÒÕ™"ÿ=/»ad.1Ì!x탞ƒõ% azÜ ¾¤ !|l!IBÛïÝÌ”ÙB«d Sõs… ÇF5'ýh 6"W#„ÆJ61b§ŒÎÁ… 3 SHC\”9Ÿp”`ðvÕH –5ÆÏeb†ù'丙äg|V¥%?û¦¥\«9÷èžéGÿ•ôìa/•Î R2øYõ «œPj,‘ùQò)N£E«î¸¾{Ëýõ Ã\þª]ê[ï|òT í §w@ceÚëHfZGÚ¶]-%Ι58Š;MåÇŽS¶k Iãæ;¸©dq¨É5ñ¥`:¡!£"’pš®æ::2üÍ)âa·ü!q^‡ @Œ._ô* â8óµ .CU¼!Ô¡/'¿&Ò4}D{çÌ&ý2ÇjV}`”r‹°"$q"a-(ZC˜7y:CÒ _- Ç„£4 ]»*úIÂDB2©Ã/_Ê”™¸vƒ?<žÒ·Š{hbÊ‚;I‘£81md…ÓHfnùy£¢š˜#•[ɇÁvE{h‹|© \@ŠT.~õ±h;Wv´T»¥íÀ+*0ÃÓòã‰ê‡çÎ%-!¤÷ÇÅÆtôgd–ÔÐ$§¡äÍpÙî<ïª'-«cÁ‰t`ž$•û²ÄòX–à5„ÇI¹ªöŒ¦ÝK9G­Ú]áà.:p{ â-·©PSx³ª:ªëñ²„–uÀ¸=7®âë6½ÛMžŽ5ZÄÔOBÏwLûªãß<º!Ùr©êvåèÄK ~fZl/zð]²ùt¨v„ýGÙ3 §OÐüô=ÍS*n+±¥þCXÅ$ QÊSªÃ[.át“M”\Ä)y·É¦›fRÓz,ƒ w´<ïZR¯½1©“ :MŠõ• WI|˜Ãù•÷ œÎKå :Æ>KN¡ñEJ¤˜£9ì9ÓmM'¹¶ï´º[Z™-•Ä~ñßÛiü¼ú„Û˜T·Ü:ÆÅ(šd-²ÈEñüî¶$õêàÓ4íÉ%BøÖò£øöÇ¿rëP]Klé¬+ZGR¶ÍKO™tœ¹rÄÕwQ:d ¤¶GÑd:åÁþy‰€U&úZCž¦úM˜Gl'C–x>ëÛ° "Íw³€ÀLóêúó¬–Ö(kȼ3•¾ËåûdÄÀ·£ø«íÿ €Ln¶ø3Í«ë]Ì3…À ?ÿBÛ¤Ô=!?;O“2q-gwÝ‘™ÉEbf\nm4ÁšÔiœ«‡ö¤¬Œ?Wë8™ñºØ¾HÖ çXM-··%7غ›êààDzòÂ7¿ÒÖ³`ejç ‡žgé¦yÖC?BÞž;¯ŸÞ­УѲ" ™ÏßÁÀñlñ8Üû@¤¸<±?Þ¸zÁá[ -ìà±›:wÞŸm% ›DD“3ù vÕE=ø[>LóéRï½C½„IÜÕNÏoæu+™u¼š½~`ûP÷ƒýìnN˜Ž8H/ìÏðoËÄ^>}ÕºPN–l9 .¯ç9§Ì²ÔHýˆtÔ]âÒë£=T·ËkÛ, rûjø¡`Çò>"¼½š¯™À„î"©èOµ1 8`#òé ~>0Izp+çžìÓŒö™®Ù'tNQ)M:7Øtz)it6?Ó‰»ÒéèâJ ±¤Ö,­'—Wš¯¡+o ÓGʵdZ|Ã?:ÁöÁJíƪrÉÎHÖsÛ+3…:äGÉ»’ŸÂ¹f¼=Òµš} ´b çJòÍü~ :8wO²M É$N唋Ùëà5¼fÍÍǪ%´÷®œÅŸÔ€öWŒ ¥ê‹4c=Vu:eîû£?ÉqS ÉÁ§Ó’D.OÅ©BþÒ—xí±xá^ºUhŠ…ó`&<’ÀW¥¥+0ÿQÆe/!â+l¨ÉO%Ü}Yyáž.lÕäîSq}@±mÃãh9g]^É@•™ÉÇ´w®'°ä(ík Ý$&Š­|OÒÊ”IËV2âOL_³È]àÇï‰kØ{ÈX 5òa– p3œì‘Ðv2ÖOhûïsÈ]c]’Âþ\í¢*†Õ¯§öÄ£ÞŠãV³•TÜýgII순ñí<Ðà:’Œ¸eÇ/ðŒX¾Q#H- yçlÔ¤P¯¿üј­1bλóa,ê_p!¿%¡ š²~¾ª£›¼–ŸWI¢ ò¤|sœ²®Ó¹K„3®ŒÆÌòõ—ûj†.ËùØ iðW7.k‘¶WH7#¬ju9®o…´©ìqÕ)Ù£|T2:‹Šï–νßÇÖík^¥øGüÚfE{ù+æ´ŸàÉzëÀ¯Õ>R9¿cÚñ¶,Ùôìqä[¶Ûó'9£Z!å~‘8ÀŽ•%¹RDIúØ®*Ä"Kûó£×ìßΕ¿þÑé<û!ೞF‘z ‚·RªÁø³óÚ2-Ëu‡ª¬í0JÎ}"(†w¿¹ðK\N!ŸNÉ÷ËÃŽÕgW¹¢BU)°HUÖ}qfç W\ƒû’˜”¼&€I™ Òx›2áÂ/ÃQ¶’¹ lìªY0h™¶º*^5Ʀ•\*ƒ8Zýš°<'/þñŒùp endstream endobj 47 0 obj<>stream xÚ,Ƚ € @áW¹op’T;…³T[4…kB8ôø:ã BÀXîúGØùöVŒ„LçDÍvXÀ͘hl?wù­Šé)×–ëi‰¸ç·žªŸÖ*Õ endstream endobj 48 0 obj<> endobj 49 0 obj<>stream xÚµZYsÛ8~÷¯ÐËVÑU!ŒƒgÞ’x&;);ÉÊÎÎÃÌ<Ð-)#‰^QŽ'5~ûDðRœh·R“`£Ñh|}Bj"៚(• ™MÒHŠ<Ï&³Í™œ,àËÛ3e)BKz4¯oÏ.~6z’‹<1“Ûû.›ÛùoÁÇݹ ªóPgÁ¬<UPÎW[ZÔç¡1QPÝã_\ÞÀàÓRšó?nßýt{Xß±6©ˆ’WÿÏÙoÈÉ$}w&…õžàY •ç“Í™RRhØ÷õÙÍÙ¿öÒp£½dÍV¢$J¥­½¨´+U”~So–¤§·¬¯6™¥sZ ÕEIP=‚Zvøœ›ÕlW¨Ï]qúüÊ$Åì\§ÁŸçq‹’ië²ìʪãDD¦Y†„E…e“Ýb⧞ènFèMéÊÞåŠÂ¿¦ƒ¦SÞ×øXWÛ®4FJ‘dy[šŽêͱõŒ…2ikýße,ûëåB*õ»w3Ž¯Þ披zõ]oy‰(UÇ·kiŽ.Øác·«Äy˜f&¸=‡ÿ*†À ô¿­÷ÅzÍ8Ù/K~˜á‘TqÇH 7ŸáñQÔ›冃W ŠÈã˜V!˜eÌÐRétûPS©:É'I •FÏP¶›zSzfÒáú\¨i‹X·…é¨Þ’[]ƒ‘f‘j­>4­µHUü{w3Ž®Þáê€Vô–R‘èoìÖÒ]°Ã§,xñ³†CŽ„‰¤ ‰"Ž€¡Ñ"c_9-ïéhvå–ý~Ý•47ÀØL“¢Í  ¤A>Œ9"¦a0âXÊõÏr»CËø, àg À!äTˆ"°#“›`VmpHÀÈ™H|FO &‚ãNÖAÈ<ª;&€ï´ÓÙ>$~è©Wå­f_Îy MïûqüTl‹õ×sÅ6µªyb%ýURþƒW›¾ å=úJphâ&ø4½êÙdž#K'‰NE¬8V‰”>".ícË&íŒÐ›Â!_y*î°EI–ûýÃË‹‹§§'±)öËZ¬÷KTe]^,ËõÃÅô¢ç£ÐÖ®ç-MOß=vø 4b x2)øÇ×0ž¥è/Jâ!àe&n—Œ"$õÓ$உðzIŒ‡üÇR ¥øWäÕ¹nÀC¹ Žˆîœv%òäwkå IàÈœ'ÌËzµ°“H ËpWÞ;«²ŽG¿œSÚɪ¸[;‚úÈ/cŽ¿ ÎDÅCvËu6‰óX¤ã¾mnFèMéÙA—íÁ8¢mÀ3Æ-ýu-„Ìv3h!:‰„„ã ™dد[šÐ#êùõŸc#mý¸…x F,ÄQt-$•ƒËà#¸ZàéäM7\Oð¤§Õ~‰0Î:%aa*6†œŒèfìÆ­!•¾vŽÃÄÍèéÇI—í Ll©((DÚ¥ÂÁ™ {2‰i|:‰5Tí™öd–&ôˆzž¬Ãç(z°’T'€ç0 ;LÐ…Nšf˜± nè¨KÈøˆj¶+‹ý70€ß ?.Êm¹[Íøãá#Ò‘ÛãBŒ!øöXûj‚Úþ­‹ÛC$EàÑtZ‘ç—e„¸RŒ¸´¡¼Œ×äÉ$Ê2‘Ù3òJ;#ô¦ôóÊÛôTP¤Ä¦-\ÏSYšž8¾§êð9†5ìeÙ Ç`mŽ¢5ÑS DM™5y%Lþú¾Õ¶@£¯w`óµ¥G€LÅ¡Wñ¨KÓ"ÈÅîI‚ÊæµÅS”%ÔÌ#!ÒcÙ˜¯´gfc]5 ec¾¢þÙ(‚Ö9šyDcÙ˜#9Š+“ ŸP¯x Æpe)PŒwBfËÙʵà¿o–sî 家í•6¼r85ÁÚ¶ý#pà?HÙb¨r7¯-Ðf6YçËb_0'_(4Ž“Í•n0«Ú±Ÿ+w6™RyžªM¥NHb=cj³-µiˆø×l€ø8 9ðÒ ³d‚¹³ ß¥ŠÅÊ&üÂf6Áï1GÝÎö+2õš‹íœI);.)ceËc‰¤!‡~WPBòH5ÔWžfÛßï÷e,"—ßo¦Œû}Kãùýyù¥\WåNì ™‡m<ÐÝV—¢Ú-.6°×j~YÞ¯@w ±ÜoÖ=‡£#‘¥º%v¯eoiz‚ú÷>Ç,óÜ$>!wõŒ@ÐQ|å²=ñç5¹óÅ㡳KÊätÖÞÔêr  ^is7ª‹$×{‚óŒéÂR´u¡gŽøØSöÏ—l\ÔËP1·ÖiŸ›ÛsÀ¤üŠ‡Ú¢Ø0t=J¿ÂÊ6í?´>` ƒx±ÇHÅ&.º` Vvéé—õl”· …ˆIÒà}ùth·v®D"•õ¦xTQ(Œí˜ª—*ý[ÁÚ9}I(5$1ÑßîË –±w„›C•Æ£Æ«‡(ÕƒÕ dæ ؈‰ÈŸÛÝ„°™Ñ¯MÚL=ÿðfú꽘:×€~E'×0¯fúU®Eöê{·é¶|ª/ú.ËŽ'&Êt8wt4¡GÔCe‡ÏQO¡µÐò„ÜÑc0f–¢¬Œ:+x°vÖÏžuà+XGt°Ž’ÇÓÐi|øð‡åàqƪ‘Æ5Zðù†ÿx>êXüH <ÍE,á$ðn8zV Üν)ýÕaÛ)UªM¹(–ä¿EôëÓ|ÉzuŠ¥éÉâÛx‡Ï1¬iHÔ¢ôOì1Áš£ #«ZîN^#¼µíàu¹!0EÜ—£$&’0­¶Å ~ùeYP©ƒý_ÄU®ƒ«ò¯Õ¬Xó÷zV=0f-'‡Xü¶‡ »Þ7ijjó€(¶u÷€“5:Yî|æ»êqÇņ¹­$'î>é' q¼Aþ¸hµÅ%q¨Ø:ÏIï[ºÚ‡Ì¸xXBF‡É1‡U"½™Î>Pê¾CW™¦_4‚oþ2ÊÕ߱̚`,Ggbر=‡ùcçÏ(Þ‡Þ%ß´]óý÷F7.LæýüvG¿€xÀ~¾VÁ§ë+Ÿ–\âÒÏ#ø^ ¢ÖpÓedæüMˆOy± öõðød'twÞŠOm¦=g°p³T‰8Ó­Ž¡êq³î‡¢$§zUG‰HóáK]GzD½céð9êt*¤>!y Æàa)PŒW[,€v˜¼DÒÒ%ÝJQ „g ¹Ê%ÝZ}YaÏAëàš³Ójk?úðíÃnVX>hßÅŽš¶¯‚KGQ4dlK·üS \â…,Æz›¢±âµÚj¹Ñ+?˜¾t¿ €’Pæ­Ó½…ÏK{ÝåbpYb©‡µÊ;òἚ۷}…cþἧÉOüòáîs‰àÕš‚S–IîeOãs»È×m±Yq¿™]‘ÃÙr¦ßKÁZr­šŠ;K|5Ç“YÕÕ6´>ÏRù>ï×Cü¯×åW.ÐQóëU½<äµX‹ðí:Ýlù*f¿àYPËÃxBQ< ~Á¤îû{ž+±7 Ÿ´Rt¥˜ŒáWeF˜Êþfþz-K½ñ7l¤nóC¡ ’s nó~»÷­°¸ (66_™òèU»sL›¦w|ùfï_”H±9'­ÃŸï ì»KzÅ=“õ!"˜bTk‰q’Ÿ ¶†Á˜Þ,ÅÿJq¿â+õ´ t¤²¬ú‹êך¬]H¥¦9Ò‘aÕ(*íιŽ!½E<ê %¾Ç`Lo–‚ÌM¼·Ù:„½lBéÝc#~àNDË×âRðÓt…ÛZ5YÝ€/Ä… ?²^àššwóÒ¦>P>€jÖ\ÔZ?c7.»BµB¸µ½=xº ?âjWŸnúL*E–d¿1iÖîð¹dñ…s=‘PQÒr=fGM íªj5Äšî`n±ò‹»õxýžO_‚SLÃ<ËtLî$#?<ÅLÖ &æ&‘íÃý/êm³Î endstream endobj 50 0 obj<>stream xÚ²4T0P°±ÑwËÏ+QF† †–@± }7 #ÓØHÁÊ44W040€ *Xš˜vvúEùÉÁ©%Ñú.nú!©%±vvÑ:1 endstream endobj 51 0 obj<> endobj 52 0 obj<>stream xÚ…SËnÔ0Ýç+¼Œ¥ÆøÇa-¨*0aUº’Ì$"‘¤þ¾÷Ú¡“ÉŒ„"9×ö9Ç÷)‡O!,ã–$š³4µ$oNpó!3"š!Ñs¯Þ+IR–E²ýZ&+îÃÏaO#iü¤‘Ë¢îàè0ÒH)ö{ü«ðÝoü™ä\чì6Ød/ïÿ“V Ó&Á×÷œàémÀ™‚÷žÀæL¤)i!8“ÒÌû&Ø_.ÄrTs±Øc(ÚX&Dr‹°k¯tò߼ͳ¼IŒ‰¥q¼L7LÈÔ=öö;rÒÔ°ì&Xê–]8ñ”C<–)ëiËn@ÆOŸÖk—òî0c﨎ïÿ䔫²EÜnBfîÌÆó±*œS'üØño\M;*ÓpJ_¾=V|ð|Я`ëP-èä/Ây]v¾#.éÞ=b“û íú7…rl© tw¢2 ÿR«Ã«9äOþøð5[©o7@Œ¤ÞaÎ=øî\\CB©²(» "›¨ÝÕÍë³F5´\LŒL BÚõKÜå­1›_—“53¢Å–XŒÖJ=¨~¼œV#k¦ŠåÚ©$3§ŽœµfqB¢!†i¹€Qÿ‹‹gB·ð{ endstream endobj 53 0 obj<>stream xÚ²4R0P°±ÑwËÏ+QF† †–@± }7 #ÓØHÁÆ4T°41íìôŠò“ƒSK¢õ\ÜôCR+Jbíì ùâ endstream endobj 54 0 obj<>stream xÚí“i<”}ÛÇm‘ADÖÄ e 3²&j¬‘É2{Æf˜1Cdß •%»,‘-ɾï»ì$¤ìdÍš=suÝ÷uõ\÷Ëçyõ|žó|s~å÷ÿ}Žÿq òéÂÄ 6xk”:Þ‘(ߪ@aÚ`, ªP"見 ¢nÁòò` ÄÅ(IÊËÜÝ$UðNRþ£HÁ¡$ÂEÑ(I‰Àax$EtB°X þÎ@}”3ŠàŠ²€Á@ ’´FÙa8Òt´Åeÿ Û¸8ý;åŠ"8“L…H&…$‹6xG¬;Ðe ¸‡'…"9ùß0õOqu,ö÷‡ü¯)ýGÃ`ÝÿUÇ9¹Q oƒ"8þ³ŽúÓeƒqÁý3«ID`1Hˆ£“—’ù3ŒqVǸ¡lt1D$h‹À:£~ÅQŽ6ÿ4BÞ/P#]ÑÝꯤ.ãH4pwBAWÿbðßLšã4‰ƒ@`R!éý÷—Å?SsDâm0Ž¤µ–"„;€´$’z€G”åFr,!îˆ'’Z€¤ÁxmñÀ—z](aƒÇb„?â¿BRr@‰G(þ¯€4(A|øƒIŒ& PEdd*I@õ/’#uëþM×°¿H^(ü‹À R©ÍoH:õJ%lC’’Ýo( ”Àü¤qK8þ†$)üo(” ü†¤^ç_øŸ©¬Œwó“‘ŠI’æK^ÊJƒ¼þ{¡¡#æ JS•4*HV^îWéB  ‰¿þÒ’ü›m1¤µB¡ÜPHÀÄ©h_œç­ör0ÿŒ°3wbN`oCPY¢‚øÚgæQB倊gç|Ðy{LSÜÆÝB [éÎ ˆg§L"hü|'ÃáŒ$ÍWäš¹%EWZG #.5ly‚wÁ©Rôë¤Àþ´kÙ"í°l&çÆcª¼c'»Þ>}3t 6‹q‹´Zíç(£/ÓÏÞ­kà_â'²»ØÍ“öYN'8[> ;L1$ʇ§A)ß'*þ  »ÙÎöÀɼƱÂÕ£´—§ÎÄNŒöRªîÆç½À6ÙÙI¯õ¡M_G)Ÿ<í /ãú!ÁÍ—ÈT¿wÉÚ]èÞ7²Šx×ÖºÇRRž ·›úE¯”¤•Dæ BÊÚówºv¦—˜ÏB¾¶Lô´bo?²ãeZ *|W¾pKÇëtI¥F¡>¼z~G«nÀ0žMfMïG©ô&âÞNóçíí.Û¥µxZE7æ*Q»Ÿé!EpQ~ÐáËß㜉’.þŸT ØÁK*%=NÆÕ°oåc+<ïòÍ?Ÿ7y»˜ð±0n¬««¦XöÞ7ý!zF¥e&UBwä\¤HL-‡î€ú‚ÆÏ|k£À´|ËP©™rŸ~|CƒC·ŽgjÇO‡·ŽÁèt‚úîÈB9׃âaϬÅü—|}—&ËÁ4ç7¿{ÞJË“.~~ùM²y_ÿSUòêé´W‰W«EØ1·¥ŠE:"É<´¨S!,sÚÒÕÓ æÐÉö(@/YÏ€.%y1ø%µâw%ž=ÖuÚ¨%#ÊÎëÒ$N[F´Éȶh#ÍVÒÄ«›[ÚTOžëN¥'äÝUØvÝ?ß?«XùõhÃS£¼p Rƒlß·n‰½‰Ö¶:Ó?ÔßZ©á£±/eæ#.;íwÉ®»«í4Ç{c¢¨µÊÊ”lÌûpƒÊò)?šA­ìæ -¤‘}àÌpåÃæKÐ@­z꘡O[tW'fóŲұ#Ê…Omt4B*°9ãˆå~–“AÍo»oÓº>ÉM[ËtãØ;käY^RvÆ‘Ôû%îd»„ùg™AÝIµ­óÚø²Gúm¯£>;kYÁç-ó‘oøSUὫ!=C€mwú Â:£a„ùé-¶nôÛå¬Æ°øºÅ@6>¾ä67€QÀ¡%"J%­¸öiõÖ¢ÖmÎ>~K†0¢P4;1«ï3ÁrrÈɬ6–(qßBA–öæ\)Òfp'oª—†¡Î­¬“C÷Z”Úf\w}ª½`ýÕr6Gå¥k1±µá¡î7Ú´c36=M·_i~Q*cg|÷ ÿ–àÉd«žx “ýnL”ByÐ{… -êØM'u…fäZåž|â´Â{?ŒÏ3@"›¶LÊåÂ[1pï=É|*ŽÅÞ]är™«ó×€¡ õ¹5Ÿ“Ç…iv[dÀJýn-ê‚ýÖã_¾í8¸(¤ç­üšÏÈ¿¬÷jŠàÞf­¥Xim1yÝ bFUs³e·ƒÆ·Ðy>híBà^J‡,xÐVé_qdž—0áJš=Ý Ë/d}ùèuÔódûÈmö ‚óM&=Ý[U§ŸÃtTîç[ z¿^dõSzÑÜ0ÃkîÍx0óLÆÑW2·u2tl¯{!uR9?#zŠìnfUb+¸#7‹ó61-êÖýr2‚ÏR˜>þñí\®a³‰WS U²»-ƒ*yR蓯ñק¦¶AǬ^Ι%*d7!|Ç%iå^•~Ø÷Ì - S‹<û~ Ay¼qÇ’iHøÓ:f.˜'×OŸD)`¡²á÷©£Å´Ækõrþ#¬ªÚvËSÙ–<ú0…góFY1AÁmr‹k¡KCîKKù¹¹À;h²5)’˜¿G£c4žDË®÷ñ T,î|ÏU×]/ÈY”»Ö´×Úd5w™c(úâÌÌó12ÝÔ}ÊÀ:êælSýfÔœ'¦r£qï~™·tOd䤅½–Ž£'a„<ËúÙÊïc™–‹tUE@Ã'Æ•3ÚVê¯EuéÌžJ÷ŽèñöB|í™(!toBä‰ô ÔוÂë³BF7±õ~þ4ð©ÏÐBÕ£«øl[clE‹¨ÀÊTniô M¯âI½%µ¢Jµ¦tòãÔ­§KC¯–¾õ¨83vÆЯÎù´ÛB<¬[Ö„qâ¾Nþ×th˜bÎX,,#DkBÈ_m«4^A”%^È¿%I춤ƒ%¾Ì~>F5«–_w­&¸Q¤matiÄÒ•1¸ÊX8÷ÒY^JÑî!b5ý[Ç¿˜q¢Ÿ{’ÏÊ<ïûà¬ùà¦*¢¯ûÝÓ,{§±D¥iwÆæ’k XxõŸ{ÃàF{‘jÙM…¹pžÏûùx!Ë.8·”¿±ñ•÷”ß6w÷ãræïÓ)óDœÄöU ïòœÃÏœ°Ä[ffU^:sKÍÈV¾Â“Ïþu ~ÀÎV¼«u"xm!SÎ^ýùçÈõ{íª!µ w9‰ÔÐ Kõô¶³~þöl3ImÙâ溽± iÒÙ)rÝj‡¼ ÷scT¨¶KLæçlGÐ&&‰èmä»û¤Çbûèý¹ãÛeoÚQ9hÓj4¡[ÿá ;׸)–M~æx¯Ù›é<Úáˆè¥j½{¥#uøAÍ·3vOUû?g¤Pø›Ò‚Òj˜•œjNÎ:)kLN•ò­oï À÷«œk¢à\‹ àw¬ir×i?«ˆ•¾]µ—y&…jÓôÜ«ö拶\/^Ô-;”ÌÙŒûšÈ|½c±›£mÐY÷Bàœ.ïeU³…Õ€nv¿½Ê2Z…Ýø4ûý ÷ŽÁq¬S_™¤Ñ7³Ñ/|¯k}¥1FÑôLòIpÛ"ö‘g³£ Bù÷b„ì^˜µD]´'²œ$?¦²'[«xš 7-ç´¥‘™-äy?kn]‚íõ°ÙÆ”`9ý4¤)D¯Ò W…ÙãZÜå^fæÔ”|þ´tškýƒYãî¼{Œ^¤Û[„ËEÅdÔû¦ûuÝ÷íÅÜM_·(M†H0Ìa?¶LWfl;>½@[‰%o¬÷ëP Ð\Áµ{¥¡4GžœÐ½Rè³øU'(!ªR£ZÙp/¹¸{N7Gß+/„C6+&-æœýZW˜ºÌRàÐVVq¥Î`'ŽƒTªã/yš7ú}rFºì³wÅ^×âóGæfð;ŒQ¯Ž•æY*9RËT˜]ª²´iªzšØbüh2kr zíJ€šô›*Ì€Ì0^àÕÈTg߃[e”I‘ è—'Àâô¦ÛO§¤:šä7‰Ó÷ez¾æœðj¤]‘ é–m!W¯óõžÕ× ÙÓµ’ìÒF`œzp—¦^Ò¼¨GD¶]Ø zJwÇÛ0{u&”ïkÀåï~²†éð¬$&ŸÑ¥%Ö¸Ònò­T ˜ Fg<žPoÜ»A‘ûñ¹–öÕË„s 3|Û¨qo™v;ÇJA±ÅVÑv"¦`¹X}e úbÒ E[“¨¥7 Qáaòªi0±Qö•+»4 ;/aé;ã ³_Ùo¾Åm~ˆ^JŸ­œŒ$gC‡õêö. FW_¸z±’ç礽¹(sÇ)íÝ‹>üÜHeù;IU“öQKáù£:eÈRˆkÎO1À7]Û›ØåÜCk;ŒY³fQ»\E‡.£ÃWøH_ñ—ƒé`¹-j¢¢ÀÏ"¥ò……tØÛ»œÍ3”³?výO }? *¡æ¯Šv¾c~Úp9Îs¬·oƒÜ€ÿN53ÿ›ÛE±¯ UáŸþÀÔhéQîŒ=3ÌÙ[1ºk‚|4,þWæövý›×}<ý?½¯‚/«l@Sº~µôØõ…wOÍf’Ö»`«ó­ áÚíƒ—Ó \¬o~TzTmëóÆZ©NÓ [3jÕ-NX#= ¾mÚäÔdlµ+¢4i#%‡×á¸ñà>ûŽ”hà\lî9EÇç\?&ëé ·h¯?YB$wÐZÕ1K6ß*™ÑÛê?—©Ó3„kGÍr .󀊎{%çKÓФ7g_1üîkë•ž†å%@Ïv¿ƒÉ…·Ý|{6âxt@ÛqêßnëqªqÛFÈ÷G^0½üñL³YËÐF”ùýxŽUSoÇ×’£¶0†^:Ö"=ǦÙÑØ0O¡C»¶Á0H¥²ÿcê½…ÝÄzÝÑnxÏ¥(ƒ@æ<È–×–Ÿ}ËÒx¥î@êýåɽbs7:é’Œ¨ÃÁXíÆõ7rŽ'#˯ê"ž.³JÜM> ¶Ù?žtÒX(‰ÛBr6JPr1ìù>‰ìç\6Üÿ!h"~KIdòš‹¢NÙV¦‚yÍòÒä%¶«B#Ÿ*˜ÓÃ=£Õ¸×&ä—û LºÙSe¹=«ó 'À0Þ Xo óCŸQ_ÏôUîŒ;ʯ‚·6®êí¡}²–Àíã\Úƒðmã´ô„˜·Z+ r?‚~‚ê¿û&~oêÑ|Ìn¾RáˆGàKïô¾QêK†Þ™?êÏBÝuv?ɸïm(Z8,aðZu-„OîôäŠ?Ž¦ TÌÕZmNÚ^ݳɴ®Ü‘¨ äþPVB…þ4ÁåUû¡Å5źÁÑà¦p+ÓÜ&€ƒ_W„—~sðñPý­òÆ«©¥¥Ð.)ÞŽÔL,]S°‘}QÀ±Iÿ7ê¥e Ì)”IãÅ<£A<‘–LÜÈkS.PÑ~aqÄ÷öt±áiq)óq„~Ã9k:ñ³P÷ƒ”ûÝw;ÕTN(6w·Ã\Î"ÅèñóGs!þdÒêËc]þMŒ•›œ”m”.ó¹%ÎzÖ—BŸ"Ðkðô5üðW›[GÅ™Yr½Ï¾\ùº?™n–È‹Dû²\{-L âp8ÜÊ{”„{fë³þÁ#G…mfèp[áÅ áÊàt¯Kö—¼J¿˜Éð!ºP„:Bx h!Y;Ãóº@f0ÕêÐÇFÏkyˆØ‰àéÜC¬šé½¹.Yéyø?2{2&¦ð„óT¿Ÿª_@4äc¯£¯ €ÿø?!€Ä¢"‡ 8þ ñ%T endstream endobj 55 0 obj<>stream xÚí–UX\˺®qw hÜÝ58× Á‡†ÆÝ5¸‡àîÜ]‚‚wÁ|÷œkíIöÚ—ç\çÐ\ð~U£þ÷¯QcÐ4ª,âæ S  ÈÁ……ƒ•C ©¤©ÉÁà`eg—@¡¡‘M\¬AR&.@A‡€'@Ü àäp° rsB~Qh’ GO°µ¥• €^’á¯I|q{ ØÚÌÄ dâb´‡¬afbЙY]Ælož¿:áV™]/KÖ-Ì>:ÎS¥—ÒÜG\¥€êÕwkìÍ áåÓ‘É°Ó ­§å¢PÇJs*‹à_sÇJN„[ûìgŽô™iå'¨Ãç®éSÒ“Ô­‡ N‰œ¥–/6"á,DükR–·kÑï‰P ÅÝl4¦™Õ½éÕæÛ¾µÿZîžÞÔh«ëõ„šØB6eœ$ÚV¤GœpÖ>E¬AW‡;”n©T²u†­ – eç,‘¾"H~“©r d Ö+L¥+mÄöz~­0LÖ„ÕJðqºË:¨Å0.¼ÑÇ\¹&t!Õ«|‚¡ç#?@•ø›ºCBû §†ëªû(éûK*žÒ×ÇüÞKú¼cšš{²W=~ô<Ù7䶾âG6h!kft)E°å‡H›#,ü¹3ŒÖéž9þÔeɲ¬yÕîÈ–È]èØå³òìßð‹^ƒQî…°f7*czó `C¨Åí2PºGŸ#÷7$4É„]Ï~•Û*Ïqì\2ý®2â-Lnas@Ó´™-ÜÃêô¾{‹sûzj~izÊñ£sÑãR8:‡žoŒþ­½ð+lò¾÷E ¯5aŽÇ¼*Ðëqc÷5@_«þO8 Ú¼SåŠz*i胭߿íŒ$¯8;°Î@Ù> mŒ§¤ÌÁ7åJÙÿÆã,¿¼ì…gÚ‹=/¿ Z ¯½;Ýô€*GØá¤\‰}X˜ÃÀ¿mcW)õ`ÝèèÙ,&siÈ{!€!\¤–.GzOäB^ôŠî6¦A™ “VèFJSˆÏ .²§„«Ÿ*zn†»©à†çÜ庅^\Ãø蹫‡7`¬×••´qö§¹äˆ5ò™J4™(œaãÙ¿Ð/µ i},kdâÚÿF™,ÏïćEʳ²‡òÅÑÝøÓaÒªÃV£*7ÊÞC>ÄFÃÁªbI¿uéÇ?oØ7%i…€?ÞŸ{}ßê+¿d,¶§ÅˆjÒ°‘RÐU‰“weˆ€}ý\,é‘K•9¡ò%²£ÈX;לw´: n&븸ú–*dÃ`«£a€å®®mù×ÊcÃÌ6BêOC?ï _½î?ñ{°ß7ëÞ\úä)8ñä*•‹­ñë¦ ý#Y»*ÁVEbM“-®ä!Š@ÛPö±LK.„XhÊ}t’Ûæ©ø''ÕÞû•ø¸_=…_­ m´KâcWÄ݆Èòͦ~6±Ìõ»%²¬!]€¯í®ylÊè0þZt_—D ›¬T–š÷]¦óÆYyˆ~-d2È@-zŒÓ¢‹>SHòC†ô6eaŸäµ:hâ@^”J1Ù…N!?&Y/-ÙeÔ žXà÷¾Oa@Û˜¶çëÒÔçÂÄÛ–odmÈ>ó!z AÚr¶Í«³Ù5òÄÅo‡P¼|3›Ï }¢Þ焾À˜“,®ïÌ• 6˜Cj˜±E.V´m"XùSVÈ4û2;’¼y·CL€É¹vy€~¦xH±§ã“ g|àÎTEíש­nZÏqê·C¹;ïm²<ºËO¾+ a.o„ðL-NÐç)0‰ƒ³×IçóeðÄEù|ðÕ~èí&ßý%m{ó0’s»ÁÖ¤¡þÛŸ2F¢6µI¡mqóºóßÉñ ïYzÚ[2¹Õ;•nE‰ 5¹¶µÅ»Ká #Ø1»ì›PlðÜm)_æ~µs$päµ_(¹P"K?rc”®ÈäÌ$4Ý«–&swû@£‚¯v+©¶Ó|õ>~³Z¥š ©ï&ëûZy»í.êŽþ‘WÈ“}öåìv¯yà¤uQNTôh~gÐlÚÁGIC‘#"%±ƒËScú¡P]þqŠXu,í³¶ÃÎ~fê׉ó«#Ê3ì‡F ó­H¼@á®öùm…dV43»å×Æjž´«êT öÖ[Ö=”:ï1c [ƒ áß?2“^\œO*êv^“žG–V\l©ë)Ñÿ>r–Y8ŽÚø|Æœ5Â&$vƒaîƒCb€ ¿'½Yg.ç%1”×Ã4M2õV[!ü1ø‡óHWêª}QXô÷Å®f'Ù¯E+¼W‚Ah|o¦g=JSe¶ K5rÓ+‚=çΓxõ~ö–¯]ªöã&§Çûa[Ý0èõñ3ºƒYåtŸUÒâk*0¬ ê…ª>w×U­µ0|¤(bR¶Ö°.UŸ3Ÿ)%ì(´C¨–)»Dø>^ é~Ø­£è#…ÐÚ+lŽÅþÉè7®˜“¾”XòWXʸÀ…†u¿€ÎÔŒt²~†Œþ?l¾FK?ûñ§ªft·{BUkgˆRQùÞuÙþ×Üâ‡*s}ðfxÝfêO3—p¿äãzBnÚ/mÕ>Ö--›j&ÁaúSt +ÇÖ“i9:à’„ Õ¦ù; íðíB¥GXº ïõ¿‚æŸ9÷Ò¨t¦8c©4›àŒ:ïêO”¥\ÉT«ÃÕ²–†c 'SÓ»½’%i!åû´Ð|ó!.ÞrkЬn£m.ÍÜ€³£þh˜ÛBsí!8‘:Ïiôè$Þéº-¿Z7VÞ¿§k%…íáòÞŠµWà¾çN0àˆgYœò:6ý`“4 ˜¦€úL‘‚³éUÊ(û¦—l‡/g‡ý O^•¸ü8õÍɱîo$Kµ!Þ4…èZÐA]Ä^>‹Ž€nò'kòqùøÐ…Ÿt6®O¶øúÓ~PŸp~ߣŸ»bT·µnìxx]³(^׫NOYŸÎU—¯-´ÓlÅç¹ZS‡ïzDÇÙj Ï°MrÍ-‚“Ø~Do«Qú D~Aý˜üXÝ—ïèr“äò j…aóÌÍÐçgóöò¼ Ùî›â„ Ó Î6ïzp÷[Rñ$Õ7"Z4«ë¶4P‡dÒr^“5.Ö…‚jV2J ™f¾ð ª\ðRÒ4+„¿VU.MhI·ü±0lÒÉc®’ç±O+vŠ/  ÷÷ +lE‹a«1Â7YFÚk¬Ñ¼ ן Ò™î°~N ¨+ä°Œݘ~$¥78ž^\s8 óéá+‰R"9ºú¸R!q¯am?&Û[ Õ–úýÉHuˆ_0£ièŠNÖ8!ËJ-™Žz×™ýWYŒé}²² «Ä»y ‹”hžOuV¡:©Ÿ„h>;ªTP$oq SLX„f²òUfwÔL‡YD¿ë1ÎlðÎQ–øMÇ®št¶°QìoBn£êÔè¡YXÉ$V•”Ä~3Fó åëTý¡4ÔÕ™2 ™u\é–î0>Å,ím&GÝsgâûæh¡™ñSû`3öŽ’¦PByOÛ[/±ðFÕ˜È%áå™™ùBÔ–ŽÁK¥ÓãÜ „M† øÒ¡ùI ÊŽÉ÷¨¹úD Uc2¥µÐD=ôÕ½(3A1ßÎõaâL&Þ Ø¼ùhÈ£—Óú©gd6µûu‚W°E'‹âPä.&¦Ý©lºÇ!Ç«:%-#Uç%¼™8ë£Pƒyö@LjAꔜî·ðϳGdb¶ô¡[‘‡t‹ƒ¿¯ WJÖ4#€‹}t§‰{Ca3ñªçUfõ1G%†&[µ(¹]2ûûÕ—…}JÍ&¹Åý[Ì7Æ¢¯…Á=)ï™f[|It3pÔÎQ%µ¦,z_Po¹: eŸüóú×7d1§ïù®’ú‚dÞw#XK&’^Ný,ÅȹÏÁž-Xút:w¤.¬+búY-ßéFRwÇùxliØBo~F« —~³ÒïL3Eñ”Lä¨Á¯”„˜«ÅÞ8’êS‚‚eÝûñ9'*›ºMÕÆ {q¸ì7wÏùe"Ý°§6Î%H¯l´òÛ˜Eðò³[¤ Í ÅéÎåq¶¾Û/\9öæ'otŸ]WœC˜»Cæm½ËÍÎÔ_yÄ5^.!ÈOŸuòÕî#³ç?.Ã[Û&”±ÓÈÉ ’4Ù¿¬ÑhoCï]lÖ©‚f}™Ûó^‘É!ì6–•½Rë(½„ rYC¥ò½'îÂâ+/“Љú²Inòœ:N‹»€E^—û1¹£l m1°³4¨COÀì]ŸM¨Ë¡ kÓàñ[  Äš ô¼`µÇ8árƒ¾‡ÓÍX6/lÞa|»°;ª\нsiÍðo›Sâ×É×È<å<¼¥Aþ@Û4Rñƒ›µhêöë$~úÒHŸRÁ“¥»­wØò°_aÖ_‡Ð°÷&Ìj¯XÓµãÈÙ¸ Ç#Nt‘zmà¤*(Üï=qª±°ÖlOÑïaœ&áùŽÖ˜æu[šGq&>Ô» ¸#¾ ëN‘ýü{PÒªè '"¨-±È9ÂvknPGŒ*u ¥9¶Kõ —”u¤5ó#A‘}nJ¡/¹nlÂÎU¹sGb›&r²\ûbÈ[¥œoFžXôÏn T†î<ŠÈ¶zß2>À?‹Id ·\dÙ¤§ÜñȾó;ÝvÄëâý&J°Ô‘ô½•‰LF™-5¦ž\óÛ÷ÓÌý9ªØÓ5?=ÿz”“»«ÛI>arËE ýH{kMþ9*|‚cc¿3‘ŽOOœt£Â\rR f ¹2´ù:yÃF‚¶Ð¨É Ó¥)ãèªÝï–(Øn&¯zeÉ“t^¹£w0:ÌÇqˆÉÒ…<~h i¾1-¢Kù`™`)S{:Aér«z–™Ì…ç£øq…¹ „)”&|5ÐïÛÁÑCÈ/ãŸè8ÛiR—Й”±Sùíç»'Õ,ê[™•Ÿl…œôw?÷Pç5ÜXÜ>ÆY[E<¿²íÖÇk‰¦9ö&15ècüˆ`ž¯’Ã8–TP£¹‘(Sû%Š}WÝ ËqPŸ!`DF±ÄCìuhбćéI MêÆù&gLb‰Ò*‡O´Zò-‡­J:ç¾<ç -PÏæéJø‰’ €sz±”ç¬+Ìí°eîñkì2*ˆôööàÙÕØft§àâkkØ8yr…¶žÏ]Ï7„íÇÊú¤6»›üÕÜ#ˆ äþ“é „Рߌ#*® –0»{¯ñg]¤¨ú•Äõá”Mü”ÏB^Q!ÜCUXH¿ÿÞAf©-×!+ÀOŠ|Z†N¡7\É©¤ ×áKJ¸ºw°Q¯ÙˆÄ1OCqÌw™ñÉ©¿#KæÞµfÞŽ4‹€jÎ_=7­%Ô,I<ÝŽ­®÷µ²Æ'à¥MÔE«ôiÂDwýW’"þ“ªë#²ß´”Oûnצ‰ú7Ç£qOw¯—‚p«1½ëˆí«T⦉IåÄÔ[FÚ`´ìÄ>¦ùøvó¸Ê0/gØÖÕºœj•$/€åØàᑲšNe`O» zQ´"P”˜}—QÌ$ðž)]6yˆ²9û’52|eIY‘ (hýt„6ZW•úl^½µ¶ê§?©êÑ%å¹yýþüðu—fwï ­Äáü(0jHð×O/!Fƒã<+G ¾îˆc(!jæ‘ó»Çç#\Ž›²;G QŽE©væ´MÞ°ö×þU›³yRøâ[‚êë6­FòpÆ·YùÁ§Mx'£òE¡Ãïì8b粓êO°¯Z•?9_£hÚ”d=YÓ`=®)Ö¶[jkÓn4²m ÑY×¹• ;ºÏÓw§‰*Uîƒàw7yHÒÕ½˜>̯Œå£=r\Êìu&}áSXÛKª0¿âßëi³ ©>„úéU÷ýZÕ¨˜ct“1Æp"Î@J_´NåÊÐA’áƒbÏ‹(ªhbawDêƒNú§(«¬ÉNOû pqkCH éèBË“¥º~…•4½^#%“ŒUÉ^6ñWî§sèUÿq‰ýâ{ µ¼K-émmºÐ·ÙêëNó‰ìMG¯¯i˜ã_«æ‹î¾ ¹vî­Êaƒç•œv?›ÿp’r, ×W†"•k°~ŒÖÄQýgåVßȹ{®J½DLdÍ"Ñú½aêæ®-£/¾+R H]ÑöüןrþÊ„;Sý¦µƒ8!V&ÆëîäÇö‡‚dŸÊ˜2T”ÈΉ—˜¤s`q)\xû¡&kÂœ%<.r²³»){òù7o=UÉšQdÓ$Úõ³4Öò1—ç\ ÁŸ±Í²®Sß*ÌZ¿c¥‹â”üîhSêz?*ž-?µtʆMnE BN家ˆ˜› Ü{ i‹¹P-­Å#å‚+ãH¸z‡–º¼³04–Àj´ÆÊ©«’g?¹rzÙ±dÚ{ÓïiQéµ-Ps†PÈ8ú¹Xv1ÄjBWU»}‘­aPY7mî5àŽjSsyøq oÈ—¡Ü//Ž~䷨߹u”õK7’ÆÄu•zÁΘOºÃÏæš@7׃Ôò€sÞd°ßgÔFUCñ©¾œñäs¢3¨\9‡öE¿gq×U°Dê0ݨ5ð”)Ýd&UfE0[Ž0y™é„“ uVeÚ—‰“vCÙ'Å52(ÅX°á±:Içf;Y͇Ŭ·’”p¿3³ôøóÍ[î±…¾á¸?(ÓçóÏ º3^W§Q‰¯¶K_ÑÕ5?ÌŸ!ÃÚ¯^(Z¹ÃÜ­»TÌ´˜û$7t2úÚ!vJ_Í%Hª[Ÿ!Nê¯éAmRʦçñúø?òÕ䎰ð´¸ÈëlMä5̬ EÌÔû›+7~ ž”´©ëåܢߋ” =dЀèöàæ¡Ïy¹™6—.eºqÌüƒ¼ái‹mQ~¢@£"—þ I¦-²0ô˜Mþ²lš›nÍ“¡„GèWX™.““ëæñ°>ƒ;.ÄÃDÎÀ‘/ñJ1%_QX¼%&c~Ý `­¢’‘k ?ìafK Ö^†:Ó÷´Q·{.ej¾[%u]hà…+.„›`(•æP“Š¿ö„™cïýp¿TÀË׫xÄFh®¿Ø1Í”wºtŒ 0å€5óÂ4óó¢ìéù„ÑŠ´äQ[У—Bú%ŠÖ¤ïøxg3‡zäøôÕÁ±B›@ÄéC‹BÒ€aJʈ,›Æ"Ûzy¦Îp·@9 *P{·}ì1¯$Kie­—x¾¥¾àÙ–e›òoË›±W0¸:s2Ñ)ø*§`‘W>¼öðø 7iWaŸ©^\àOúxï… rS¯ÖÜíÄó}ꤵ8˶žqÙŸ²^sÝÏvïöç´Æ¼çÜ»D·ÄÙ$L>?W> ™Þ¯ yBAÄ8ÛÆ^ÔK¾û""&›™¯Û³ƒGµÈ¡µTCÛU0.k_Ž……î&ÐçV9CG¥³rÂu©Ùº¨Rœ‚XJF@´j³køÆŠ;:œä™&L¯ˆ¾<šl»>çÝ"AȽø`pª»©Ý[', ?3$Uîgj3œf-‹Î~GÝêç;u0¶M¥%›GàºõðCwBLl¦áãö«|ë9oNÕƒò;‚ÁTš®oa'•ga}õ\“6wê*+ q­Á¥I`n´¹‹/×iBÈ. Nº½.ü¬ìÁx+2óƒoõ¦ ì“r3/ª¸wy i„)•E°ÛküG«Ô{ùqÚüsÐZ+£RC'ÇÅw›ü0÷ƒÑÊ“=‚HËAöA <©çû=UÕ‘@<À‘œes«@þœV`ÏÂâ 3‚†­Ûhÿ[W#â Œ¿ËÁñÚ¨o”ŽO†ê÷*x§Á_xBí2§Ä›{×5Õµ“›„2¡¦…eŠäKhF¾ ¦„ þ4qIZ&òk¾ ÷§*ߎµ«¦$åðöV3®ÉAÙ…‘'mj \èk[‘7~Lñl<1­ð_‡r{ øËJôéÕgÅšÂÄãkáFmòߤävwsÙAèÄs¬µTHØ@MSãSÃCdc^/ì :J„¤ë<ÍóÐx 7i¶Á)4p±éØš~»¥o¶ eÏçSÑ«©ÈY%„<Š°cã²Üæ3“ç/úȧp‚ç$Ïlùo _ù;¨»À´Ž8¥~ß>vB9 3ð …íÈ(’€‘5] š*Ìf`÷vW2ûU}D¯=@Tð"ûš|7]®ÆÝJ6ž~h|´ãô‰YÔp[w“¶GÈJX¥ëñÔ½‘<6žãýuÓ>%IC¢VdAÿ.àìªÆÃÒ•‘µÙžUGi¨@4úµãЊ’iî’ÀgE¦ºæ8éŸ×ýœÌ?˜ؗcSI¼ù}†—áep¬-Uâ±—¥µ†ã•)p²Œa˜IíqÄO›ô%N/[‰‰y¯MŠ\‹ÒúËNÜè:N{Vˆöçhþò½²¡_ïR—ù~’Ȧ¸i¸ƒb1ëýŠmÅÒ ‰b|žÏaö]Ý=¥Þùuû÷_YEÄ~Õ•îQù­Ú¼o·9˜—:†?[ŽÌb´ruî3/Š0˜™t©˜ËYf~8”©VÓY4°02ž‹ð7ÞoSZ™4VçQ_j_¸v9ãGI~Úˆ4-Ðv¬0Ÿ ýQã¯Yç½!WÑ®– ¯¸ïGu"j¡ >•™þSkå•ÐkªèTÇûÛö2«ý:ùïD-Œ©Q èiÛ?Q‰¦EJe¢É—¯ŒqD3Ï›âáS}xtJv©²4Ûì âå( {’iL†QEaúŒõGo•Ï»ÐjGÅD.-gÒRÓÓâÒÂï˲1Gp«8Õ5JqêI;žÜKßµ÷ºU­à a¨SÂmŒs©²ÒÚîVHýZkP*‰{¿Ìdz‘n•“r €Q]_ÂØ%¸O¤YàëÞ…¹×’Aè-ÛH&êÄU£Œ®`§ŒxKnÇêÝ)Üétgð…!õìÊj5o¤uåY 7Á¦X:œ¼œiA‡ß“Ó$ ŠyÖ±‡6’ ÏÝÕEÝÃaËoÕ×U=2ìÕ€.š/Vt­>+ZXFJ}¶’½ó‰µÝ¦ÏÜëåŽÂï//2ñzg };¦$´‚îðË]®ðIûŽÂ±Àî÷Ǫ±ÏÇó§WUw¢Î+VC‹¦×¥‘yÝÜ“éøw«sø¸á§x 爺¤øžY•>à‡¶h“‰°ònëŒFÔ?À“[³å¦¤Þ!ÀC–ÕÿÕ*% L½¯¯ÇÏš¤žËáp5\IÝÁ1\"êÂoq¤ÝKÅ[:™½yð;Ü’îö4ƒóÀŠÐ©þ>9Ñ,ž¹ ”IP#Ì*Ÿ®*Œr;¿—€ˆ²Ý€ÙŸ6±H%0ÍMk¯C q«Æ.aúuÅÕ Ü‡ÇÍô4B·£årŽ'8ñ¸$Ò>Hâ¹ÛtʤïÏãk0l.[øÑ=˜±ÏÁCë1Ø·Ûø…ù·^µ8bz/Ô*ö1®Øô#KôÕè&íÑHĚ〺Î9™õv«‹µ ®Ygø~wÛ0^Q]¨†î‘ÖÞ çu¡Ò’EEp4èwós'éÈbΤ+ðÔäýòz·íËãA'X{™ÕH*ÔÑ•HŽ2;ýú¯³{‰6Íۼǰ;ÎןƘ»tiÇŒÙüFXNÍ3«ŽBLËK¦þêŽÀÒRÛÓÎäëo=Ød˜-åú˜ ¦…àŠ­~£g^ÃZ™®cÙbÜ– þXÞ¸[ö±Ö+íEp¤†ž˜d8̦¶T Oí“xñX¦÷°ÞÉ™AþAÏ%~î“Óñ«¼!v1áp¤Œ Zh9KN¸Šºßä^˜¾R û*(Î)úæŽgq-%?Æ~Ö ïu˜®FêŠR>uE“hWéHx劼‡"¢¨52#2¶}â»»ó?C?†­ßÆ•X Y£óVßÍz 7žOKðNÎsÝÈQ ‹&Ç•Æ$ÿp=îmƸhudŸj$Ì´ˆô»k„§Ç°¶¡K •´3”"~m:ªƒIA?³;.‡ÃÃüvAC'_y™ÖùËEFzˆñ}ͨ̈́vðÛæèÛ9(|>j7xP>Òh ÜÖ¡¦-Ì·éâ8r…,sú%×#~;XmoO+ã6 W×cJˆù’åI&gÉsŒ\uaðv ¾å‰iagjÆä¡ïz2tºèâÛVŒ£š–«¸„àÖÚài¡v÷H9OÎÊ1šÒì`†¯\â³Ö}̽“$õûû5ÜìQ§GH;ò=Õ‚¾°‘Ô’ôXX,RÏT¸h lMc{1'^¹²?t\š}gJ  z†¿Vu/¶æ5YŽ<å­"~ífEÃV<¥ówYyd•ï +7Ê'ÆÙg®T#Ù¬^xçG­0tj¹­’Hà]nJ+tJ<±„uûuC—ã?†/ѵ‰ìÓ`•"+Ÿœ‰r;ÀPøN›ÖE#n›ˆTÆ—Q9H>”dis+HhÄ–âÑÈÏÓÎñçpìX«áÙ°ÜšÐcƒ9ÓJÙòÅîmñ¿cxu³ñHZFÕW ìM"1aW&€`Ç„0”Ï÷Ž±.|¹·vȤ¬Ÿ¸Èø‰Úzð{viŸI¶ä»¦ (’/MIÉnaM¬\ÚñÖ;èŸÜN@³ë¨´Fk¼±lT}µK?aتIRÕ#Æ·¤T €âí•‚PŸèâ~7áKR˜3ìEv ±m ¢*â”SK›¯¸é´óùÜA~dä9¢Cõ¹Š3kþªá®Þ苯fW=¢G„ žæ1sÀžA½Ó#+g øóvƒTî,ñsãit{¡5NšÎéo¤A¶zNX>‹¥YA²6ƒµPórÿ’dæmô+åà,¨@—byßœŸÂ)ËõX??Þ! ]K$~Rï¹qoR;.HZ$ýÓÃ\øNÂ]@…ˇ­'dA[f¦“ö +æ}¨1†Gm¥â} i§ªmïýAÄ¡Ýq1k®´ÖЧ®Ž„ôÛÝâ3¬Å ÇRx…OƸ†ž¡7•xÒt¢­;½@{b¿ÃþYcù(λ‚„añ´Êý\=x}¿é¹¼á%±bUþ0c¤H§ ÍÍ±Ô’ä ¡‰«;Ù²söÿÓ”ÿ¿Àÿ ˜ÙMÀ. {°-Ê}@d endstream endobj 56 0 obj<>stream xÚí·UX\Ͷ¨»;iÜÝÝݷƵq·àÜ înÁ îî\ƒËa}{ï•œu.ÿÿê<§»/æ;ªjŒ·GÍYO75¹š³¸¹£)HÆÑÁ•™…] ©¬)ÏÎ`gac“@¢¦–ƒL\­¤L\Av~~€ Èôíâí#ÀÍ#À΃D ttò[[Z¹è$éÿ5‰ n[›™8”M\­@öo9ÌLìŽfÖ W/€¸ø¯. Èv™³ ±³Ì­Í\¦ Kk$Ö9É;X8xÿ+lîæô?Cî °Ë›€îMzÀ›¤¹£ƒÀdĪâøV ôæòÿ‡Ö&—q³³S1±ÿWú:õŒ›Ø[Ûyý÷ G{'7W ìh;üçTmÐÉ)ƒÌ­ÝìÿsTÞÕÄÎÚLÜÁÒ`fçbaãú¯¸µ‹Œµ'È\ÍÚÕÌ `abçú'r0ÿO“·þýãÁ*¥ª¤ 2þ÷Öþ3¨fbíàªéå°ý™ý³ÿá·&­=zlo]f›øöþŸ+ƒÿ(&í`æhní` àà昀Á&^Ho7Ñq|ØÖæ OÈó͘•ÅÁÑõm à­3~ G0Ò¿ö•Àjaý¯Ø?ÈÅ`u2ƒì@®¢ìÿý¯Mýw˜Àjåådrøây›ù¶ÓŽæÿq¿-vµƒ@"|V3G;Ç?ËxÞ2‰ÿ¡·$ˆÀ*ù‡ÞÖJý!~«ô¿‰÷M^æ½Õ•ýC\V…?ôVAé½UPþCoTþÐ[Õß[µ?ôÖ;àâ°jü¡·zšèíûiý›øßÌLÁ&f¶ ×ÿ­Ío «Ézó0ýCofÿ&v¶7ó¿ð-#è/üצþ…of–ᛚÕ_øæfý¾µÆæ/|s²ý ߤìþÂ7+û?øv³:ü…oVŽᛕÓ_øfåü¾YÿÂ7+—¿ðÍÊõ/|³rû ߬ÜÿÂ7+?Èñfåù¾Yyý…oVÞÿàÿùKH8zú0³óp˜9¸ÙþåÈàçá÷ûßgj9X;»ä¥Ülll||ÿDÍÜÀoÏ‹ë?ççÛ ñ?laýv¨€@ž 3¤Õ%G3Á6i-aåþÒ…3°ô.Ä¥'ºC›2YN6±À­Óš Ò+ÌPLëJŒÔ3ÅjVs îï„-â¾Ã>¬¡+˜Ã¨8ôù™ðf'ú†P#yC}èö9‘«d?œZ/Ö(o·Ü»ak•ŽØy Ï¢`Ê——^®ým&¿¯"§›Sî¥"äu(¥€Þn%Œ?žÊ::®àëgÞb¿®ö}›³Ý@ÍàÎS†^Ì~Fd£÷´ØžDbϲ%[ÕÉå—û]×t€NÎ2꾤–±¢‚Ê[ZêÜAb3g‹ÍO~Ê# Ÿ{ú}´R³ÉƒÅ`,xf¡jø†µ)©¦°GáÝÜév»AwöË84ôáü!í¤Àc<ò‚EÙáš³ù´V#ÇãW°kìBþ¸¨Ø8™¡%!c0Þç•W¶_—z—x·ÍØHŠð©çpš)¬íZÝG=«902ÊéÞs¼}aȘ,ZS>¼Á…Š},»øZ«µ?såQâ$¿âŸ”µá„†àQÍ©òögýJcvÝ?•ýöîEÎV˜_#¦è²6ñGZ»Õ¤¸b3TžTþõ<^lÑúdAË&­Œº44ˆäÍç64þpêa}Í@&ðµܾ9ꑼp„ÁMÇ€Åí ›½Z¹‚4ÀÅ ù¡SJ“¼Ñ$î06æ.*sÚ#&ÆeÏVÒT‡œrY†Õ0 Ìù°a : d}åÈ›¯F©5pwõ˜{&Ó3ãFŸ?¡o梆Iû:UÕ½?ù…N¥Ü[ܱ µmàÀÈNœV«ëñC 0¿Î&E:ëdñ©i–%QGˆÁåÍúÙ¼¸dH¬ÂÌ(‰²EöH9Ñ`¢¯¼ÊŽädËÔ ëÊäHŸÂ¡ù¨¹V³¶àîGØ9—Ùì^wŒäül¼,(¤}¯Ù 2ÚãöΑC:'ƒÏ¤u n5F‚³{êÞQåmì<,bw¦±këÂiÆ|iUsùê÷¤Í/¸VÄ_RÔŸú`ÌQˆx¼Måãw((øÃþ*24ý·¡]I ;­$Cª¿êñ7ã¥Ø°™:Z×lŸ<›}ñJͦG»Oi­¥ºŽ©µ#/TH'·%Ï×S´°oX¾Mó×Hú6€¢0§Jc;Ú‰­P}.¬zØ͇-ùùëaõÇ|"rÅ(ÏV;’þíÏ=ýñéâ7k†~§"t2:æ¹¢M0»êm¬ÈgÑ—"¿'ã|÷ïlá–èrn²J®K×°8ÃÛÔ'è­S~(™›‘Ü­×å¢f¬£Y B7¨ïôtÞ eªŒ·{Ÿ W˜ óŠá#U„Éî%ï!IX2ßÀÒ˜WΧìËïÅô',ƒBÕ+â‡oÍtý»v²á?¾"ÝdïÝHÐ\]"E#7—¸û—a í™²cm»âj­û¯2'Š·È.cš¦§™·d^&²…û¥ÇYm Î+SkéPÉ…—$ééKo´>iÈ&3PºÉLKâW¦Š]+\Œ#^¯i¨X&˜œÖ}4x†©`/t‰Æ¡]XhàÃëö‰ILr,·[qç3* y×@ÛË¥ÀŽ ¡þíåÛ†P<ÄøQ¹@Ÿ†Â-ß­É>÷„‰+e¯šßõI¢L:C뙶ªöNCÃXLçÊj0·ú”^,êi¹÷.i@$Pˆø\ä5pq³sCVH-)´Êœ]¨mñïk<ì&å0æöÂÝ ðJ“Ò8JÚÕ¤¤ÌC"ò‚¦¼t/¡^ø7Ô ”š¢¦(‘^ÅoªÜêÌÐ5Ë ­zR÷ú# tLÔJB3¹ÜmÃ1ýšMXŸÕ míä²0±NîÛ}úßðß”JÑKq¢ù~õô~«ˆ%¥l²5ÃczêÑÂJ¾›Úì|Ægh»ªúÚ¦Úh^¤§:ÓŠŽŠÌKò)%Ý͹ŸJ»oä£ëîñó¸Äµª©@ñ—}^[ßV:w¸¢Ø‡…óWèŽuäJ`‰)œÖ_Ô´K%[ XUò‹j‰<ù¢ «œètÖàÈÃz‚}¯5Õ q&zvQ 1ôéÌ0±wŽü#¹¬± <ôƒï>®›w²?TËç@è!ÇN7ÔðƒŠô‰êð¡jÂ@¶¸¿|ݬÎMz0ô°¯74˜°§dgý Sv"†.òlÖgz*PÄÇ[?ƒNøÜâz93g_†ÄÄÖËö`{ÅÜy? ߤL!¯ÍmýXÈoÝ„XGZä~ªT„óU垯Eêƒj*á|ÒftýÁbû½)äóe®PL¯'ʲøüë•>¥V®ÞÌiú°Og!ÉXÿæŽåm—²Ç-ìÍVwíC?@ºqžXª \Š‰KË(úF ÷=jÍð‰SÔ{øp·p.Ÿ&%÷AÚ £h?KƒÎ¤”Ô~øÚÛ¶$~Cö9»Ü3ZGàçÍ )*)›†r`t|¯¸C=ð\ðnp†7ó¡u©á%”:§¼áaÙ«“{9À5ô—|#:Ü*EˆáçÌËŒÊH´‚µ8Èk¶Xni«&¹ÉIEh,^T‚»ÝëëJ¨ -Óusé´h‘8β¸š *à®+»b]ñ…ß5^< ÕZvu÷îSŽÐožÏ­Z{,Zv\ÞÁÑžƒ¬tï4MÏæ0øk< GÐA8Æ‘Ô,#•RU>f‘xá0Ù˜ððtF|$Ù´¨{r”ʨæìœn¶e5,Ü, ÐÆ22-}¨ùÔ?Üì̼°PN Ôóêÿyæåu)UWAu®ë­õC«ÛbÎÞ„r¹òÏp<ýà$vèDãï½ß§O‰LÁ`•®.qÍ£Scj¼åª³Òvr7¾& M‹ï9™±BûY|ý ¿6þÁ,Ó£³1Ö‡õI<ÿåÒ§bÚQ˜ÿ¨7„K†T±„=ðáã–<\7©Èï'F€Úrßmy†:µ‹./qÇš¶¿¦&Ün5µÕ7Òa‘\È¥´ Q\‰™ø3Ûw,Ã-!i=on&ùgòßÈ%ä@Ýmj€O.óU§•šá” ëîãÖïG'&D'ó˜ÑÅâÏþü(9ê·–PGÚ鬱#YÇwSÚúzºT‡áú µ“;Rú£!r`á­8]•Cˆ5ÈSŒ3çpÛ$ ÎÃ5ÓÎÊ>íkÂr<î÷„4}϶U~Ök ãÖ‘hÌâhRÀÈêÙtX"ŽOqWNa˜&d ¢æÇñÞ7Æ™<¨“þ}ë¯>ŸBÏ Âç_·^;ë®^Ñì^#$ðàjF‰+Ní"öµO_{ÓåüçÈò”€2à\ÃïÈö'ÁBYß;Ô±Î3M¼?MA€ÎlìÃÔB2àieQ¥[ž™­†—}þ]³ž¥íŠâ¶Æ¼Z#Ù$m)å ‰Íg‹®ð £éYÛfÛ;Šì¦\RN·x̘¸ ¥i3áϵ¨ë[ˆ:…bØê¼Ù}ªYC®î[õZÔ°ŸG a£¹³¿ôÊi¹¯ÊÁÜÄ÷DÊòΫý|‰f$+WI*Ë–åÀ©EÑö¶}Ïp?[MšhBNèCb™Ö4¿Õðvጠ%`=•Lz}$âÊà«_®^«ƒØøÝ ! ?’J8a–¼–´'êwó„\EÎ20ÑAqë2A·ô s`c¬œ&b@rQÍ?za ‚¥Ðâ(wW”¸oÓ£%žpPЮö¤ Jél9ð¾ýò"غÈû¢²”‹Qä9I© £îŽ-¯é0ÎUa&ølàOË"{´×ø½=û’òÀãðKzJ“`ïãgx.3Ûs‘Š¸ÄNê2êV£:²4ÿJZQR3CÞ`—)I7ç¨r9é2!)!å> ‘3sñ»W5–r ‡DïB_KqEf P¿»žù³Ëѹ,·˜°/°uìÉÍØ)å*ÏÉïô{[Û`trf_é² ÏÇÄýrQ„;i2$d¸ðì§ÃEs3ðde›=”ìC@S_âdÿPÿþÜW<‡ÁJ¸ÐbI2ßûý+¹êõü¬,P "ÖɹýWeŽ¬‰âÒl}¥ûï#˜‚ÆFð#,Æs…èÙUyš~¤$9ŸD “I~ïpg©ÖЪI¼_€ic骤ñ-ß—ä>ø Á¦ÕUùÂE/a (îK›Æ†Jm‡^ðˆ3×û.ß/šs¹q›öÌGf€&„å5ÂVF³(àËUÚü:»R\Éb ‰ÁÜKΨƒJVÂzû£W³¦ë–éݥȴ¹Òéƒô|¸3‰–p×Æ·Ç3}Ûîóò÷ƒ«9þh¢„«—äT“fÝLJ.’œÍ£\}Z“†Ó'TBzA”ø{Æq¨”„H%ç; j“öì¶ë*ïÏb5@~"j]¯Z_1Y‹ö*õ`'HÅ-ü½ŽžþY‡´Òàª(°•ß9é{„-Ãqµa×Æ'ÖX‰ø˜é™ž£…ê®Ë454´i¬½Œ#¡šÑ¬Î åÛØD:óÈwQ=¶g²ù!J1¹ç;àSý¹îòeüHíj‰ÈVq4X8J{¿±W‹‡öÁçšW•|#}¤j²b!«.VHZæú.Ä*¾ô»¦~ñZ`Á•™ ªGŠÛ€âûúµ©.ô‰ªâJå­ô³ '< qƒl][’[c)žÏŒáíJ~Ôàó4àL¤â±™LOS÷yp5|²Uc@Ä]ìxÈÂÇÀM~Ck÷°AÞJÂw]ÉÛîCȵ¢$²M½Ð–[Ç ›Q Ãï agKX^Ø‚{= Yß[{‘ÕµôüÈJÞªSuX[ŒS=£4N)åÙ«Zˆ0‹õw8–žï•<Ž¥CÖ`Ô/Œå,=û)µï•ÓGØ#@HŸãë¹û\·]ÇŸº Ãiò3[YØ"œ§­×s"ä[• ò³\vüºP.#Ñæ#Š?TtÍúîÃQ]_˹ù³aZ˵m{Nåè3“Ò¹ÚRˆ÷µY>uZ×ôu*Î;ãg§ Ùµ¥…qÎkb“9ñÕþ§mAñkÍŽªÒø^y˜ý©ô0­õ“ƒwµìÚn5ŸNKZžÊú)S¨g§y¤Yi™ó¥3•E>?mÛL¸’E!ùR|µ‡^o‡½Žr™Úª¢=J`M%Ùégat¶ Š¬ú’ÜŒYR¦!Óó[„“ËYÉ<êî4¿ÎÍ…| âhÕ¤ S§…éÚ;s°Ø¶K:Wvâ¡*ÜF2ÏçÞN•¹…ˆpoò‹¾ ZØjËÆí+¼¼ÂbguŒˆ¶:²U ›™µ•i8¬ëÄÅúœú„fèalu7–àž‚c,)vg®}´ #Àˆ¶´»ì„™“5|&°& mÿf¶éûý‘eoÂx˜·’Õ¸¾´&æÉ{Ú¶)’C» jÐþŠ’VÀ£<…½ÝQ8ŠÁF‹Œ3œ«LM”ÇL×EåÇ­ùÎOƒ° Âæ’øìkëÉÞÊL[¥ÆûîÙsæ‹ê’ýEìãÛC®—X·ÀF8Ùt0j†ó ó±e&{Ð(±z£laĪ \·®í¤‡áfW¦äSŠ·v¬ÅJ¿c7¾²Ê\õ}ÔL4:ò*tá–ë6’o(Vwê°+ˆT]uò‡ãÆÚvmµÎÕ!Sm`¯Ñ× þ"ݧtC‹VbSÊJh-™Ü\¦9ûCýlÙ¦%7 ÙS1¬°ÊíÍW‡1V1ž_§7BkžgÛ/ÄÆôJ×ij»“ Mã ™}xª#7Øýi^sA¿ãÁ‚÷©É׋ßU„ûïÓ€ª Yõ`/¼TŒÄÍÕz—ûSÕ'"îŒd¦yf›Ð¥‹ù§D\“é1ÈùC%´)á#„‘ݼÅѽûžñìÄÝžâáRXùµ¢ÉÅ{3³§; (ádBÑy5‚ðP&“ž¬[T%R ÏnšnÜü~c<@Ñ…ÓP5ÉÂxì QYèy†» Ù®U|tk )Ü}ËJz"‹gd†™aãí  NÆX•”yÎ˵•}ê Z‹oý†Ž+Έim33N‘„püQ ÃÝ~ö¨j*NöY¬ªÜ½%­pst” PŒTå¢ã¿WÉIIá¶Ýx; -ÙØí¸6è_ ù™9Ý„¨š[cˈJ˜˜f\,ŒXˆJišºTšâ­£ì“Íj%D\6Óª‚å º.Vt¥‚Ê­$•¦”¬ûdÑø¹‰h+5ï![Qwļ¾Ttº]ÙÈ–•ä+Ö0CÈa†ñ¸¶W½‘^EÌRáºR0J€Ëä¶Âýt#îo|×ý«êR%6¤å]|bñÐ6l Ùi,%÷yâìÝæÝ6.Qº`c>oÐ7<×µG½þÉ,ò&Ö¢}Ç „ÈSˆâø­—è9¿Oymm*q<ÚE„>‡CYçÞï/32 +—<‰–'Cׯ‚c½àºkU$òÑ»ÇwƉÛÈ&÷׫xèù¥àÆÅôuQ¿G–šÖ(íoЩ‡ãcÔDìŒ\²8¢Î¢KKn~3ÊZæ4h¾Ú'y¿‚ÚUºÈ¨uð˜áySÛÆ:É7p(>:¦~I3€y•åM°HHÔØZ¤‚L?ÑPg‘*û²äºO"}öÐ({i±BÈeŠé¡/Õ¢9›ñÒÇ‚N™=n]÷Œzzaù€±®}ØÔAÖÚ¬Ú°ô®zíA^´Rd_Ÿ ÍÕ>ùâ÷§ÍöZý_Qñ‡`xM…#ÃõÂYÞ|o¬ê°Ÿ½ÇmÔ »sïQÓeS™+0GËZ,ãˆ?½/A;Ãwª¾ë©¦CóÉD` •€š¶±±-.V8£óðÈ.™n$_ƪ±©oqYíU>W~®DÊÅo) ˜Ë½‡Q-WÂêÅr”!µ¨?9È4ñA«D¾µìd¿B ¾Ñ fˆv¦©‚m*q@ ÿÝí—òapõþä«6¨Þ?QÞ0…A•ênêfa4±&?èÖ"q¢•žÍ$Õ¡o6‰¬ú]âRÀnÏMâ:g6ѶŒ¢›{íkJfÈÜkÌ»ý1zOI^®Ôj¬yžbY@,ÙImÒÈ&LÝŒaOªåºÓê šm‡ÉÃǦžÓ¥µòG˜7É7'$/Á§ýø{0¾OÀžS,iy½Ëä’È$¹¢ìH`#&é9Îvù`»È7œŽ|3ë‚ž;wy–ë­ë”Fü‰ƒ4tìd!m´èÂCŽYÍõäþE®ÖãšmµRld~ºÚ“$´‹¢ÒiŠ ˜(­ÂXÙűcKÜs²í¤ûú¼Ö\fìüë¶L‰q¨k9FE§Þµ“Ê\­,ŒuI/Þk1hË—¦p¾õm=ÈA8Uވɰà@ý¬äõ6…% òæ}‰äï[¨š¶cîfb¯Í_×®æãèÂiÏ÷*dóÆbç3‰Vúvf#ƒP¾Ùï<ç)Iâ´Ó‚ÊHñÿ+ãÙøôž–!ˆ+Ô¸dÄ:ËÃLO&X–­Y3¸|k1€J^¶ÁÒ?áQÑã&Q·w¡Ú=ü1¡³ø}úá$¾Ñ±ÆåB¿‡67[§+CFó«líª7frâË—%½Ç”ž¦ =|aˆRâ>G<ò­Ÿ/McèCÚnl8â?91#p«ª[®<•S²¦à½äé!Á_~hŠšîNJb ì%iÊ¡Ž¯¬Hù¡œœ uœaâGùM6áv[îE,I^‚©ç¸/c%¢Ô¶¶­ò)lx¡SãœP°®ãORyÓ”úîœùfb]pÝÇ&K®†4¨8^Ϩ½1¨‚•ýßõ¢¹üi ½màeºòíù•7¥ex½˜ì’^T®|ðKg ¹kÎYÄBkeÐãP ÐÙ!½2K±Åç8þìüåWv!*²«{·Ž³°7ëÇŒødÜ¢3[»£5͈:ÁGµþ,"•˜‚Äô¨à¼å× ún_x‹Ý$4»ƒÆØŒ‚þ0îÏS­‰%3o?” ¦Vhn,µP ™õ=­Sˆ ˜ üVÐÇ!ø•êDGaøš,C=ò ½Žè¨XÈá(ž²Êè?YóäWóºÊŽj„y ŠCé Æ84p›zŽ딆qóÐ\O‹£’í5%Žkg®¶Ú?´Du ó.Cülß­ ïÏ.þ%­R­FÒhÍpý0׈I¢õ¬cΤJ™5þôóBß¾ê–Ì+’êfü¨ˆ°Hß·¨ÝxÇ[IÝpl #‹X哯yj£ó~ÆE‚)hº\뱘ù˜r¤RZâ ~Ö¦BBY®:^0•AnÔ°»Qµ抦‡õ°`nÌlÄÜ>ˆ–þÞø4mó „\SNFÀ=_Žšû¾R–ßñ£¡¨wtK5bÀÚœ]Ì¥ÆÏ«¯/® çv`‘L?i³£ák\€ ç“3º-0[2¡âô“ÊRë´p6„¢ õ´ŒÔ¸˜Øé¼|Üÿ7d®§(µT™¯ úHng™îié˜mDr^—fXCÚdkö·nD‹ßÆàô)¬õK˜e±î‹ß0©°;²DüÒB­ýLO°Z5֢ض¤\ dVï‚?õ'¨ìÜæÁ«£D‹ÌoJPÍØÝ+}å 7x6¬Lkņ”ü¥ÙéÂòµ–Q-þ™³7†ߦsá®=/è4Šgöv¹p°–ë1óG´Ê¥ýöã’« °2­f§zÝ-gZQUêï€Ç†kWµT¡ NŠÒÁ“S+¼"w¨8Uj£Àá{ªe©3Ÿ>|–åÞ ÷v71ðbR&ù.ñFìÍÀRp}eú·¯‹‡õÅ[%>4‹B_klK^Œ~¶K£ò°g¬f ê%ww¢È:¨åí^ˆŠDÛDWyPJEn«×êl6 ^–þE´,âÄRwÒŸ¦#í‘Fæ®$¯z™ìéq ¾Ñ`L¢¢5®m+MùÁVg‡=L 7:³~ÝÈýmz;÷%ãJ\zhIr!ü=ž§©‹‚Šo™FBUøï6F‚]r˜ qgž¯@…0Þm%0“è ÅÑ×ÕßéäýË< B¿_ðE-#G)*"nK;Ò}dIˆp}·{ýZ9K•§öYÌä™!kÛšwÌÛŽÈGoÚáЈMï›Þ5\»»“]gk^=3aÉu›±ïÙ]T­u)ëE§œLËGºÓÎ>6`´³]Áî²_Eé7cc†#ÞÕ |ÙYÆÅ~¯§“È}£‰¶cÍ‘Wm~&£Ñø¼Àà"õók¼™ì"€iÓ''‹ }ß>¦WËh|I6 ¸ßÔýÝþ©uöP”@ǦŽpèü`}ãÃË•Efz·Ӝ~ »ï¢Z¸Š‚Xšå{ú­ëOõKX"áÌŒ¨¾UŠƒ38›IÎô–ukEö­õ8©kó½*™.Í|µžb-B×|‚ŒÞÅÄÉ ˜©”¨yuÖX:fv7¯÷u/ß…Í%gA¨!5dñDÊ©{â¾Øƒ¶²õç¦1ÌzfÖ^ˆ˜yë¬VÔùhë(fû¥E¦äÍN=Óe‘¦|hƒ´ÂQ`··Rî[ £ì}Ìåðšrøýž6H¥C1ÓéòÎ)ñÝwvpY¥ù?í…žÐsÅ_ý´+Pÿ˜[Ùjqÿé ªkî6/Ê„*Q~ƒÇËkè†,eäÏÙdÇéDÃ~Ê·¬Vi š/YÓäß)gRr¿ÜÍ7¿ QqÁE­½_ø}zþLì73ðc»ÇèžR×#Óïà¡:†ŠŸ†ôl )¶òöâÔ)·ôõÁg±«+×N§÷­w«6sŽjÁ'%Y©uŠ½©›¤3Mk‚ïrn˜GUyâMi]º¬R_k›‰™º w›0,¹PŒ5 ô 7%S8 wq÷œ>?¯ q~YqsåW•å@ã ñMçeKÑZLj×P&†Ž"ÓÁ¦L ßÉÚE›úÜw®yÍþTÞpS¢Ó¯’îA":Ù©ç°Á!êà³3’Š´§ySA7‚c"Wlk°Nʾi&7L[5UŠ¾©eé”Õ“_çìYÆÜRê°jÚî;Q­A¢ø ƒ›ÅàhÖdŸÙôS_b¦|‚øIȧÉ…]û–»[ÄRà ÷öˆm©÷»™Éàeê2—øòÊ¥Ù™+“âZ‡5/.ÝXS Ó/”¹˜žNRG—O£N”N£fÓŽžºà7=n*\ðR´œpÎ~G.5ßÕ&‰î w$€îxW.=7Yмƒ5¢SôøÖP¹²f¤UßT€iI2ýbãT¦1!A°*ôF•h—̵næÖdtmýˆ™m)ß²O]põžÀŽF‚ n×F=å[’‡Ž3…—³ûa©ZbyJ#Øj%dŸ¹}*úädM0õõsé_M]k·×ßcÉé"”%ŸxÏž&÷5ãFAìF¬³TÕ*˜ÖÀä*µqÔLÖ€íE™ýŠD×°k3 ­í’ÉA3ÞŽCÓ‰RÞ}‚I%o··û¡¡cëå%²LzVùœ¼‰S8¾la¹Ëwq~†?}·ÑJaòbÄ3é¹òÒ¤S~P7GêæDÇe™òº¥‚ȉyKJý½)-ƒOa íc=×mÌOzxêæGx_&@¼W—E% à(á#.f·\Ua}^è_B‰4z<Å%97q‰,/g)¨ ÛmvôçtÉ/›-Fµ=ý›,‚ˆbÛ¹Kˆü£P£MCš¡£ybñ‡SŽÃýZÚªK¬ëžM^±!?ò#•ÞËÐâ3¾ÄïÜ»(󶚹LŒß\>Çù£vU±äµÃçæÖøœ ªÇåîOÎäÄ‹¢zµ–Í¿ŒWV§ÊÙ pÎ â4|ÏR[DR;ar ñ­p¦¹ºä­iŠ0‚J]ã ûJ‚èàS²àÊJ«Á‚¡8œbW0wýžkîØHkíûÒþ‰Žçˆ@¿`Œà^ry¢õâ#öt×1ñ‹lN±ÛåÜ œ¸I"IˆÄL¬Ò×ñô9^Øß †yÓ¬¢]3Ærs?µŽ,½ø˜ ú\§ìMWÎ+YÅ|§Ò@{ `A?&kDF`¡ÕÊK³ {>~šÉ_¬ no…27F¦£÷žP„\Œ¥±3èºÇþNéü„¹a½íYdú¡æÅ:ÏAÉúNå€Ãeӹ뱜kí¢È4E˜ãÚ Cn£-ÜG±ùDe϶̴{ä4Õê/ÚRõýH.þ2dceæq¥©!Bƒ°u–®fÎ Ü2UD·+EUßÊpËóçµûêdfŠ†©ÁpTV4sÈ( ¢Y4Ø¢†ñ‹Î ¦‰,Se8®/œ ¿dvñCFf3ÒX}[óx£RAâcÛÜ¥_W«¦}"ëÒVœë²¢".{¹€ò¾fSÖyœšKµ¶!,K͇n']ü ¶?±š­¥V8¾ÈÊH9­~¢€‘ÔùUÔæ×ót /CÔ€°.¢g—Å µwÂ÷ë´t[õ\7i(Åg¾ÛF¯…Î5-âçà‹ß6=lîNêñ~J‘Ýz“•µ(8¬ÙG "¡ù9bùŽÆŠ Aâ®–ÕìWƒU^ ýl¿fš&µ(.ÜÄÙ™ƒ?—çÒ »q§1òBôª|tŒ˜qÎ×yî‡UÉ­‹i6û;)­½h ›¥Û|Þ9­ñ•"-¬è¹+Øä¤Íˆ7ö¹Œ©¡õLšè„,¦TtáÎ äÆuouh™R©mê_½‘§ç/)Žva”gí¨šÊY_µfÖãÝwÕ ¢XÉt>ˆ~d»/Ôwgñû:Áºds@u³`,ÛêÖí7Þ¦¨hä^X1 ô¡àC …Or^²HÊs¦v{â:«ŸPó@$?a¿Ìò¥Û:õ  ƒ!X`ûÿøBú þ¯H`f2»:Ú›€m‘þž½H¼ endstream endobj 57 0 obj<>stream xÚíRi<”mߦȚ%)wÂE #Ì c_Ǿ˾Œ3×0Ó˜aÌÈRö܈Ù*k¡ Y²†î"ûS‘]¡FïTÏ}ßÏÛóñy>½¿÷:¿\Çñ?Îã<Îÿÿ”·±“ÓÃ’½@#2‰*“‡©ú–¶*LÊ))©OÑT<™d€¦‚êLM èѼ8€)«+ª©Ãaœ’€>Ù/˜‚÷ö¡Òú2ßE*€ž/HÁcÐ$ÀMõ}4°#cð 5XÐ#Ûï;[0¤‚XyN Àâ1TÀ ôÆ“8¾ç1%áÈ€ÊOKóû³R¡iFH€K&ƒ,ˆãT°"3ÎIþ¡~57¢‰VhßïöŒý[í‹'ÿ³Nöõ£QA `IÆ‚Ò¯R'ðg4K‹§ùþZ5¥¢‰xŒÉ›П>ÀbmðTŒ€CÀ1î¡ÚùgX—çгøðþhÔS_£ç'ŒS}à´ãŸFI­ªNC¶[J¼åyS†„AsR©Ú«œ»¬HÃkqL-Ø­’¸wÕQݦtz-+!^mÝÛ3în¤(*Û,ŒkÃZ[Ò1Z±ÍË5Q®1{UOp¡ðQ3”ûyƒËŠü‰J¼×΄“Œ–…½Þ$·Ä%{h)½õ/=zíó„Äésk¹©«ýn“;9ÿ8Ñ(`ÊV¦âô÷áBîeÎ<ïn“V”éšCü£H”2PŸïR³íuQc©óâµ¢±äùú>cˆU¾Fûö$—bËÑÄç,¨°ô«Ú‡–ѺC˜ß—£ ãXé¹ùTwÓwõܱ+K§Á‹YQü[ZáÕYꪡÁimF2†æ÷g$EnÖógšÐ¯w,£W{žfìù ä{'w¯ ð ¿è¾"ßÍ™DàM:¹¶ ÇzTCò¦V›\äÆ9/Í7/M£µM¥Cš¯vºÉé~ævv}!Ö¼+vJB¥uªžÇU饗}‘WÔ“VF‘„Êå¦Ú̬v•7ñƒ%ù­ÝƃNOD—¨tKðþ WŽ²×›39œ ÕžqìLšÂü~»K½4[Sþ•*«†Â¼W¦¾PŽ G‘…Àcez×î´™‘aû d#Vu5ö¦iÃõ^¼ÔšÝ¬o(aRh¼Žwô8•Eó^„áð]vµK÷?œmvýêÄFzCÞv•OUwAË©" ·’ÇŸÔ†ÑÚ3‡»—¸Om×g¤ÂC¯%¶Ûv×AÒ£'ÙseßI€ó탖 %" žPáýg~ß_Q•¸h;$k5¶rSdìÚÅÊ6“Α«t‡ªßSÎËú,ÞãS=Þá¾ïhH¬‰ËPqeB^f!\ùLq`ÙÉ8 q¼o°õºVvÓÔæ$Ó9Ô¡wÇœ1ÏYÕÌr‘Ca"=X¾sO W{'_²+ÛÔpúãT-Ä}©Ðmˆb»s/B=JBMø7­Ñ¹#Ê6MîM%Ýýã„´Ô£Ðb~JQ¢]¡B°fAØ*Ñ…ïÝû!ô“Ñ©9æ­‹g¤èÅ‘G,¸EÔJZBf»-‡¯tS±õx½Z‰•5cô¦ÎýÉðÂ&‘ÁÖƒÓÖ+×…kö§Ýä GΙÄÌjhÀ$:ÙÕÇ7⥠©ðÄ-‹w=nR§:Q³µ¹$Ï·$só{U·V E9Œß¦ Þ”’97Úž-£ÈoØP=ßFÚ˜Ko –ôÅNæøjT*úhäB>qŒf†º,‹öÅÃØŒ£FÙ‡·Ÿ®eYº8œÏÛöPÙ ½d’—뻶Y”™ó[V¨t'vt~»lze­xé‹¢VÑê ¯«WÁcîýi®s V@©¤²ï!ñÓy¬n Ýä¼yäøô^ÈW”µ}’ëëz`ø“~»¶öt‚5ý”Jm8«Ž…B@ºHF_8±m¾þÕ×_ßð5²xqkïiÏ›¬Û@W¥ÑÔ´0GÀ£ª‘®îÖgž,šÐÃöËŃÂ{¬2Zé`3Î$|Zï3÷=ˆ4¹aPn°Çv£8»Ísÿ¸bSçYfœò<2º5/i»~@š¾®¿‚ äxuM¢¤´(°”6ávu½Wmf¨°ü·CóÈ$®ò@g®‰ÿ¯32¹6c!=)—¦·nìÔ6~îÐLê,e‡ CT+dÆ‘‹;]s¹édý¾“4ËXŠ¤œl'UØÃ'W1}æ7fÁ ÞW«8)¦ ÎoûêCÈùQÊ6e­ˆoƒÃLOÞ¤¬ÛZIûGúcØ¥ñú6˜P±ÁƒÉñ…îçß4¶à¾X¡î™>Kúr˜h™§_§òÆeiýý–¥‚nlbCÕ¾¥¶¼ÛïïmG¨b»äv:–$ )Ò\š3çŒÌÏz\Nu¿pgLípænŸÚiv×Ëqaì<BÓ¢ãfYg2°IÇt *Û©.¸N¿p©DWHFªÕÑñ 9ºÀMF¬^äNf岆n˘Ýadô¢K ADPJˆ¦â¨é#u²éÃèÈ ö¢©Fˆ§[sùÃúBÅã~âÇ÷}*ø%?*‡¸÷"³F'ùA°Ì”ꌷÍ{Ùð/t˜»‘§9·¦%ªbÇAè…d2ûíãŠÌ7F‘Æwb~žÖ×GuM> f eqw bôƒ½–ï団Qj3]†õ¦PÄxZ9Vi¾udI;pWN$b÷YÅÖu1‘›ÙG¦BË$ø &¤wVT8èÝfkœüæu!ª‹¤%îK؉vXaS¶™˜ÊFûÑ s©â7´ÚË[{Q_q§å T·ÌøkИ’¡?v¾x!Œ®Vˆ9ABæzS¸>stream xÚíSi<”íŽ"FY“²ä)”3–±WÖ";•%cæÁŒ1Ã,áµïBÔ#k¶¢(Jö,ÙwQÙw½…ìgªó¾ï9ç|:¿ó<_žëú_÷u_÷ÿ?b'MÌ¥4Px{P#IÁ¤a*€–¡€IC!bbZABãqÚ¨À”•a€Ù…0¸Šœ² T"há])´£ ×:û]¤h¸€4 $'Ð…îD`s< ’(Ò€ ˜}_AÌ@"HpQÒ @¡‘$ÀtDã 2ßóèáð€âOEvý£äˆôP€8=äY€…Ça) t€Èáé{ô$ÿP¿šë’±X#„Ëw{zþ­ŠpAc)ÿ¨ã]\É$âQ ÷«ÔüÍD¡É.¿VõH,©sÄ‚ô'…&ê¢=A” š„tX"øƒq¨_CÐÛö#‚ŒÖe=#}ÉÓüQ2A q$ ŠëŸ¦ßµ?0ì/Lï í XA¥¡P]Hÿø²ùe+Bãè×A B¿t¤Ü‚h ô@Oz^ižD_Ð[â8à ïÔWd¼@þ;û“Pdð8ðO¬dHÕ`tìDÿI! È8àÉ„¿9:vÿ'…< C¤ŸçO¬@Ç ;ˆû‹2?§ñ'£ÈàÐÿòïÝÕÔÄ{Þ’¢ÿR²ô„0˜² ¨õùWáUÚ êiÓ…**)ÿ`‘dÄ‘~\gúäþÀhúœAÐDB†ðHÕ µ4$ÏW'³+ŸI‚AÓ±,Ö¨¤¦·’-p0Žû°åŠ›ÄHñµÍ‚$ö¦ambD…·i»î’¿[lbÿÝL’×Kk+I†”i×Së9^•ö}ý]Á¸g¤5/ázVísãÇtqm‹ÙƒNrV›W¼¦›„½\|Zî¤g¢[^˜|è°gÂþ˜P–’ï—ñdîÍL–´ø]ë¯ó=­Ž¦ôÃmpýo\°NˆÈ¨Ë’òÂQ™·“_–oo>N‘¹Ð%Wz:6קž€ë¼¹Óß2ÎïýŒæ+ð¡/¸5݇o㦦h§oÇ”uuÙ›&ïSi‚ò&ž=Ñç[¿h¯Û5Û<ÌÔÖ°TSÿÍ·õÏðhŒüÔ¯nÃÒZrBÄ¹ä ·Ùê°öñ” K7š‡ï|–ô‚¸Æ]ÖZχiót*”U"²iB|i‡V»&ŒMŽ˜n´ÿ>Y7^¶6æþ²å3Ô®æµÍkÊà#Â#Èú‰Ó€ °0ctÊÚTC*•c— Ô'ËWÎâ&ôì=Æ…öìÜwQor_k<È!]RGžº°©ÑZh—¢NuŽ}v0郷Ñgâþ %–á¼5Ó5¶õ»W™’´[‹‚r¸\YÔ–®‰¶x|KªÏ°ÜvUéŒ 8Þ•MÍ^ó+ežZJxü­:.›ãçRjÔìÏ ¤öHâ¥Ëä1)WlçÍ[Õüò‘W¶Åóã£\¯¼‹®ïV0mÛ•<T¹ªÃø1¯¨/™"r+åo0&“ è8í¯/ZÏ4M3eMˆ ÍSÝ,ßå6ˆ¾öi4f·z?ÈÛ%{V>¹Ò#ÎÄ*=_£æŒ=»êêÕ/±:ÞËsÌ…´ÔnyKŸ´ùq@Y˜å‚¾ÀTVRX-õzVmVߩㆠCHµ‰™¯œ'ÛECGr;¿]—þYøB=ŽfY|Æ“·w¡µ’ö>yœ£”!(ÙÚ™w, ;nçvüÒJÍáuíÉ šc`ïòá» ³KÅ=òUÂ)ZN½!hN d|݉â7}‘ðL>Û6^¥ÔŽC]/N¦Ôìò´ŒºZŸè´RÕé±pœÝoÎÓ×ÜõNy7ç³ú[$ŸkÓ*-°/hâ ¯Pq¶¨x ³db2bÓHé¤F«Í d‰sœ{œµó·cù¥-\T£åôªvòÙnhØÜÓ:qóuX9•zÜ]·RÖ'T]rŠûRÊ1ž¾‘çóM3"À6Çÿcæ·zýw#ÙŸÌXìov•ME°H[5Æ™íÆ)ª•x¨å…’ÄBf>EA2ð‰N®žÆ´ù#2gØ<Üo OŽ¹Y f”,1âMÌŽ`~‡$Wqˆá$Ù^¾½ïÌ7™j);/=+”P”ëlÅnSh­>}ã(Y{è ïÛwBµ#‘ûÆ5P/5–á~üþ;å‰-I÷ý儯èì);[¬W~e Q·ÿ’TÐj¥óÞVhKã·TÊ&ó)íL© ïCcyò‚ö§»£9UÔ,tî½G¹_º#¦Ôy×h 6£ï™£š ¬Xb/]$OÙŸ¶Ry²™Ùzêmƒoš~aj±ÄPƒeAI¹‹kÁQñ˜6F¿‘ hÐØ몜ðÁéN?UÂÊ<¦×0Á§¨)Ôç EyGy­½’.ïÍóiÀx˜QªgvoðI6oËC²5ËØ#§ž«`|•¨¬¼Î]ÒŠ¨Ë¹õ3pŒ˜qiïù—9󘥴ù§×Ù鹯c3´N²‹1-sO5K–Þúj8ñî´ÄϹ€Ô·´0õ¾qØT gxܾ3Œâ3reÎÄíäìâµÁ Ù£SH$Ù® ¶`KÕò®E3.JÙÍ“ú_q؉õÜeº}[mÑY‡ãú¬þý!Oㆾ¼ë×›]EΟ…Æù«HL¶v98kL9h647S©ñzÁÔh¿Ej°›K`F‚Â÷°Úû95æiÄveµãS[CL§Ûún,J#GâÚ_Êæ䶦×Ú8ºÎ1†oº`—uñò{ñéœêTÄUzal*g ]?ŸËV;¡„µ°ú¹E"ÕÏ%¥ú ³´œ(˜{óp\%þ¹OnÉY±€m0¦‹z¯¦3”çáäâ쮕F %OÃiÞ¯Ÿjµ×LEg³uCïSì ¸~öS>nnw…5Y,u΃$ý½†@Íó±§*ÚÆK²Ðš©7´BM$Ú®…Kß±ÓÞ÷Î úL³„Ü)Ô p_|££½bÀñ¾ð¢jÙ€VcF8«×ùÐ)T÷Ä{vÏàÂÈ{Ú51õç¦Íü+b…ll‹’mž†é î]pÍËx{È•ª[Ör“3,qˆ¶[ –»=$ú¥ ³Vý~nÿåŒØÚô¥³Ñ5Ï㶜à™Mi)yƒ%®Z—‚•5ñöè…:aÛþë (³cís ø>Ý–~å±¢&%˜R“¨²{ÏÖ9Õñ3W¥]ïZ”;ϚМÐÒºwµšýã±)[—ÕJr¯€-÷àçï¯{Ò/¸†—)ÐקZÝß Ørꉕ]€d ˆs®áعuå™ìa…’*ÐE¬Cú¨‹&q ³Éú»`Z•/¾¢Ÿ1Þ £9åP|0D¹P\¶ZЈ·"ºq©<‡/Õiºã½×{®áÈœ¶aõ·Wmdkn/ݦäO|hœ(ý¼„Ë^m?Ö}GføŒ¢ “né2iâÖ>ëénèífÞû©öSºJ/¹0è Fe‰ dûiµc¶b-{½2Æ d‰3!Ò+Õ ›WÌg-Ÿà6×ROÞÀ„iÈqÅnˆ¶&ªoQÅŸ¼¸š<¢r˜ÅûÄÑŠø·òdYoXvæ©Í€m-ºM2åæâ´Òô‹½êÞªàí´Ô,=As¥oú>ÿüO ± ‚@» ο[Æ¶Ò endstream endobj 59 0 obj<>stream xÚí—UX\˶¨q—à¤q îîîn4Ð4 4î‚“à‚»Ü!8Á‚[îN èíµöÙ+¹û<Þût¾Ó¼ô?ªæªYýÁ@£¥ûBÚÚɤàäèþ‚›ƒ[ «®#àæàÂ``uÝ!NŽr@w€[X˜ íðp¸Dx…Eø`“²NÎ>®°­;€Y–å¯I‚i(Èbt¨ÝmAPX+ @×É r÷áH;8tþz  r¹z‚¬90¸¹Ö+w€% qÄàüËGÙÑÆ ø¯°µ‡ó¿‡°s#~€7âh ò€¼a¾œŽNî°G°–¼Ø8¹büµ™°ýæ´ù;ö/ä!ä7òÂÐáäpºx8Á:úwãþæãp:]AŽ ›?¢ÜÿýÉ°”În¿|N+'(ø;Âà´õq¶9þ Àž‚•u²þpú‚\þ ðÃ4ܽþ`˜€»­+ô;ò×êœ<\ÿ À*Iÿ&X™ß$à”ýM°jr¿ ÖùHVXá7ÁŠ(ý&Ør•¬‚Úo‚åÔøM°œšÿ,§Öo‚åÔùM°œº¿ Ö?½ß[‘þo‚­Áð‚½}œ¿», «nù›`Õ­~ï;¬¼õk%èü« Ìü„lÿ@˜Ñ'Š Ö»?ædÿ¤þ@˜ô7rìÿ@˜•Ó³rþaV. ÌÊõ„Y¹ý0+÷?fåñ¬<ÿ@˜•×¯ ÌÊû„YùüÿýN‘qòö{Á+xÁ;­°Åsù¹^ÿßõ!. e9Øæâþ×µ`åá {•Üÿ¾„a÷Í¿Ù»@ oƬ“•h¨]JCxi€|ÁD2+¼ ¸1^£®ë[;fÈ|¼Cñ°ª ëj­Ñmy:Î6ò6µ×ýs·È6í¯ 'A.ñ©3Ûž¯¶Ó}›Ÿ§«ûl9Ó^‡à¶6L_òÃkN­Ž”&öeöäi1Ëéí .ÓÀu›z~îÎ4RHwЫeä¥Ñy–êRú–/bÅëYÒ{¤•ñ»´&¶¥3§6üÛ´ÜÄG³Ë½))SâÌ—Žc3s¶³P[`T´utAlFsËýme&§äoc|ªã´xf"P@¾‰îýÌðrÿÏYÁËÓa#y^ì›´­”®!•`SRÉ>äcÈ!e™uö˜Gøì8~ôŒáÀÖ\™Di@Ë·d²ÉÎq¨µg„ôÑ>†)Î]'ŸÿrâœA²/qÁî‹ün,…¢$›rt£§ã/(ðMÂæ:^/1îç–"ëHx¹ŸéR™ÉŽ¨š|5$'•ŒI´©•i¾O¸Â‹»xZŠ%§Äþ*ôŠGrÊO‰üí`$ ÈÈÛCÎæö™”8}k «r“Lwàæ”ÑÐtÍ„¡÷‹xKnâÌ‚4„º¾óóxYQlç´®×íë¶OGÚ¶ q¥ÚS£JËyp´%t àB‡ˆ=­%Yâ—Eä$eÓ§oÚ4$›=}&óÙ Ò®‰/Å©ÇǽDÚÉvîB'’Ç2ìP d^OÀLÅ@=ÛQªêm¥ÀIÀ= yÂoSZÅ*E›aÊõv^ÒsûÙÓa‡ÔÍ­¯Íù6j  ‚|&ò¨€àvB‘Ø4Êbócy_ëÁpÑ,`QîýQ¶`®^"GŸzsè}aùkŽ¼à¶3F‘|¹O]û ¬l£ÅÏLY¤W:ªß®êK·Nñ¦øÊù)äÀ‹‡ñ—Î!ˆuÝù)—šM5œ½ãï}£¼W"‘òñ»ã1Á\® iˆÀ}¹ÚêÝjV äìî¼BÝ5K»A@ˆ¼¥ÌWN¿S¥YÓ&ÓdÍaæ/e8ÅÑmÍ‹Kq;:£dj,ˆ˜‘ ³É,]‘2,Ñ]L£ÌQ™©2ÂåÍövï(^MÄeÒ˜›cÂQgJïx ?¹Ú`´ kj6|¯ñ'ȸ­üd§=ûòÇÏS­‰„mãVE¶ ‘ÛÓOº¹SÞ 2wp ×Ì‘‰ØxdÞƒhg1øº/µ·,^Pà3603O#‘£˜¹“‡è[¦Ë'¼sf˜5“£|Hh­µ‘Jo_`¼ „ßm†,s±ËÙ¢ð¡ÒÑ–ÖÍVK¹KÛ™}ânÉo;DBÅT¨­*¬ê)|SÓ©qWµ8¡g5`¦0zÂøÉpï@–&¯#UQ§a‚´Uj¶ NcðqG˜ Œ³ôtÎw«åç’à\ñ¶t…Çx iܘ¬3¶U·q°ãf`(Cqø ×µ5<1;íÑ£Ð_pŽ±J-ì—•6]I¿§Î¬¾±[yM7¦¨ v¬«d‹£Cfn¯0É Ô2mßbÅ7§6o^ë£e@£¦=[9“*L³§Ùà,ÔW¥ n;g¬íÁj3‡'¨kË!€+¥CÍ^wQ #ê`xÄ'3–jŒ¢I•‰Mú`ÃО+[OT€hl8õ‹;úu~T¼e¢œ› $¿/x1²[éÝ—Œ‘ã|&1%Û|ËÎÒpÚ?Я¦ôá|@hЖZ²@›áæ™Î>`)‡[¥ÇpCØdìŽî{Òyn|÷Y‘—íâfÇ1IÙt¹ZN+¸¯€ùs‰k9éó”©Ñaîf{p­ÔbÒÎÔ%—ç]Ýÿ«¡tÒƒ±…1µ†<83¸÷‰YŒæ$[™ñX¿ðßrK{ßË#§ÚNš/¶ öòHOO½³,#øYgEF¬“æüöæ¬ÌÐSŽ)u¼—F³áã´'”÷•;VJœ,*›Æ‚¾Lô {l )Äò:Ž–&FÁœ!´8 Èy>z™Ò@C\K}°äögà4’]ý ™Sb¯àиê%€ºÑ¿V˜èúãG¸ÒrzŠʯ¦¨¿|YæâUƒºù‰  B3ëf[Ë|ïí7u7*Þ ÑÍ+?5¡šÛŽlðB[C¤›0Šýty×û"ì—ó3Zö|ɤFÖ ŒìO£Ì‡çð¤çm¦~㺈ùÜžZ¯°Ì€ 7Ÿz0TÍÍd‹‹’—K”vÍÓ½:/JïyõÔ²®ÏúómŸ¡ÕàÑ‹|†Wç _t£ÓÎÔwm—¯‰h•eOóŠÏIÐÄ|Ç7ò Däý?Fµé+CH.-«=¥;µpï…ÅŽs¬)Ü⹪ {æž±•“•³|2åý–×™U²Ç- ÉÜѾü‰úÕ=:*•Óyâ‹·xØ?ï<=Ñ”AÞxÂ{ü±¢GÏ$Ö>gP.k…· ÷¡51°Ïâ}ß¾|¤©ò:X®ÛÏ ³ÚT¤Z°çX·–ÒeÚ:FÓ7q3Ç»-qãEóÞýyòÆ,1•ìÕñô/N‰U­ÝæÊ÷~E‡ñåó¥Ž×/6 õâ9öBõpLÜ©¯'«Vå+oIÖ3g~>§ºXÈ®‰2(Ÿ¹/{ÎHM î•Æ„98¹µ\ˆ -´ë+w^dÙeõÝ5š‘O ã * cyÉvþú¬H¼*¯täµÎÝËÖƒé§W<ß¼L3}£¨\§0¡w‰¯îƒÖFÕVV.¬ ±úºòS܈¥»*d0Ï+µ¯£‚Ñ>æTš9% p¨ ¾™¦”ŠãsÇ8˜ÆüËðç„Ï"‰D dû¹õÅœæd®ö½ªÖžÅs¤ª1×›øI¶=3úáF2bª%0j¾6eÛ…ôàÇŒþyãËÌ‚ª]…e0r\ö$FX>:kŸ<®x°Ÿq{ÇiònQˆzþ/À¤¬ha…YW’DJy}×TÇ¡ìä É"Ñ:ivÞ•¢ÌX¶MðÙ8Ä#;˜«Æ;¥gæ®#WäÆ%Ù˜ùVYt’Â~]~^ ´&5ÖfÎo}èTÅœÆbXWâ-YP@R£÷üʼnû¹.äÈB› ýtîKvK —ŒU\B^Vųˆ³‚³ˆXZÃáG;O-²ŸDý`õÑ©ejL«Ù³‡d#{›àü‹aúÍ°®ïµýõD¿bãé•KM[ß5çóèaIL˜íá$5z÷s32>,,ˆ|iû~ãÕmçGËãM’؃»3˜E€kÔÈsüØ7LÓ‚,"Duà—¾¦ÉņvÇ÷¬ç­¶ÿs¢og"¦³mof:‡®mŸœWÄc@”SQ&Ï`Ÿ_Ü œ&ãõã+÷ÕwZàwfĈ]Èb.š‘“xp¦y©ˆü‹·Í{¯ †Âò.-õ®¶u»Òm¤uïÇÒ¸èOÅ‹°wÞ¾ÝÆbUd±l9íÌ`á}ä{¶%ìh²¿(Ip>Ý›ÖíÑ»ÇSÚŒbüð1ãÙivÙÞ,q›ÜAP‰nqg:°¯¼TÑv?jpu¶ M¥ ûj³:󺟉R€ ¿6ɤº&l.3iÚ³T„pÐh a&Ygܵšè?úFØ”½;Ç-¼ã¼¾{£\2¡pŸ”šü<Ügê2 Å0¿îRçØrH`÷C×™kZÝ«‹INe„Þº\Mí±[«VFúýÈB—s¯õ¾Ðn{:_l!ÌŠE'•e—VÿbuaîN” >ÁTÐ_7wù|Ø'õ#…¡k÷Tû, ˆúË6C¶ÔçR;âÂïÚPa¤ŒIžé¤òvqkÿš¾Ïâ#I(5 (µNÊ“Þê‡~ôµIº 6š-uVáèÚIi¡\ÐÃòªt¦]#{LÙç¿>Î+½ YäßÿRoËv5ò1ö¿Nh¦@àiëb‰¢7Ô¸“²øÂö3o®ÿ¡íÙƒ'&íÓVý(×}©ú‹ôÃü?ýÆVUŒñùu¼Æ×ËÎøÖC[º‚›¶ç£…‡¬%ÃV @Ù(AHsß‚}c¬}BcHDÝã4æÒÔˆ1aƒ(ÙÀ*p‡Ü+rv«ß&‘vŒ‹“zœ;Ì¥f±ìKÌÇ•¶Ù½I"@ÌÔc!ÒšWBù%„ÿBT@¿9jÑ$Éê£Mr¬?¯ÿqÇ{Ô}‚77?ACý#¨€2Ö)qò0*Hñò™¬BÙ5'yŸd˪‡Eᮚ߄ݞ@>«f¥“–eðS-A¼ÛRžš˜‘añ±@8 i{±Qã™vÌ(Šö2£¢:ÚºvK[¥8ä.£¡#.5ëâ”U# ¹G¤Gæ§DLþç°L‚h¸íù#;1YJBë’µ`ÞݯFz›z÷ñ£ bu#O@E$'–âóNRIn–VEø·{EÝ]µSé>ñ©aÚ'²Ï9dz‚×Ñ·Q/oB‘ý·¥ÊOQ‚›r„¿åÅàØ ‰çzö}›VóîIi¼Crš±NÜÜ‹Š/ ¦©Il‰”É»"™QÔѳњ|ÂTÓóì¥7rð¨Ó,c·b0b°Ù+Õ5‹]ý½›4¶ù„?O “Ÿ ñ&EÝÒ?hhÐMöU𸯑¡q0€D‰E-$”½Ÿr£3°H_ÕúÈYý%éQ뼤ÂÚø«±%º‹Y˜PÄ7°Õ§’K¯Ô›t¥Ð&Ç‘ñÝWb„há7 Rh“´êGq7Z —e,IhI,_ý_r„‘´³‰?JR¿öY¢žù®jeÅ› *«RÉQ=¿•®ª{1€àú [žÿ L“ÓÒ)z墽£È™‡ƒ¬~K'.#|ÿ¢—HOˆDwwâ|+§:!6ð+—:kÇWŠ=h!#7 Æ5<ùê)»Qßeh}¶èT‚ Ûu@žâæ+K:zætÛµLDTדGàá‰2KuÈRi§7ñ!cdyP?+æYù]pw,›"ÁÛ𜨳^çÃ.~HF-ép'ÅRâ¹Çl?¿¼Õ‹³‹lpéך'0VͲS,ûƒoN 5>j$MðL‹ï-ížt]0âxú§³Àù…Þ“2Ä<n‚^ l[Ë•™‚8- ‚&Cà Ë⟠ìžó¤'4¹uõì’<*%fxöU?ˆÄs2ß™HSÛ©WWª0\®ª~aCÛŸ[¼mÌ‹{®Ó¡åÁ'&R DÂÂUz‡eƒÐr[K-°ÜºÃÑE~„‚¼?£O†v~g«º·UšOë»vr|8OŒȘȉ}ØM-mä|™¡¸Ý€ºäª†²‰œÙÃ7§ß0ú ë¾Ro }·8Q—ÁÏÖá±P4|x­oCÿð‰BjÖk\š+©Ð|›NèVç!(:u-°xÉÖF±­–ÀS›á~öiVóh›ú­Ý`PðP$™_ä›ä§ŽS³€CôQ›BçÈ;¡ÅׯuÌh ¾}m™)ëw[xå:ò<;h<2V­ëˆ!ÿ"–k;xÚÇ…jÞ3¢©Óœ‘jZ>ø$€7÷âHÓÆZ<åÂÙ/Ç—P³,¡|ÆÏ¿1ñ+•(iB¢Ûœa‹«Û Â=¼Dh¡ÜŒ©5Ì$vV}2ìã̱µ1v‰ÊéàøS\¢ô1«©€=lúµ/ÉÕ>7e eü5{ª YJ¸saE‚RHÅukoßÛïÚÀ‰ ÿï6ì¼öl™tû Îú,Ž÷ÉAÆ¥dp¹÷MQjlbðáy-Çê̪ºß\ö[KÑE-÷WW?,æ‚X?'¼=›,5UÄ€F•ÓÇlPÃŽ_Ò¼,¾Äõa/ô9¨áFÀû¼º2r‡QÉ{«§«ŒO±Wª6GFz6,Ü+Ѷ¼~KÄüÃdÚk¬nx?BÈ2™G ¾ÈÉûðº‚Öy:µ>õ`HÒ QëKt†˜îëo$uûmˆÜ—Rñp2êß`õÁ-V” Ç ­ê;ñá„mÄ«2ÓOnÞÜåG °ã#+?²» L[B\䔉ÛYŒÒ® šÒMßÛG ’Ütvâ&©ežïkCÍUb­G{†E¢&3þ@Eç"Èþ.e8ŽÝËŠOŒŸ9Ò¦/»ÑœppW]ÚÛ¯)!‹’7t27æ·ÊZ#ÜšjX–|¤ô(šò@šòFîhâ÷ÌgE@éÓºQ@aï¾ÊèŠëE¸¬Õ‚æ¬Éb¡ œFþÒúC³e+}BÏV]ä›ëj2¯Û“ì±FÈEQ¥\èPœ‹¦¥™Jeìd# )HG‡í(ø¿$ܪ&~´@étŹþž`— tv."KYûÈðv9Øœõk[aÍŒuYÓM–øˆwQèR+*{ïçó\ ãÖ-ë}ž;ª8¦Ô}8–.‰Ïîðhª#|ç¸Ñn¸!ÔèžO2õFŠ}ã 2øŸ÷ƒßÔƒVÜ´D'ÑÞ€ëWr['’„T¦®Ñe·Ï¾ þlÂ7~âo!ezÈŽŠEX®¤^B«ƒœµ|Æ~ø D[—l$w\Ê·+€tÀ/³UŠ,E—Y1¨äñy@…°j¤Þ•±Ð›ê¦"{„Y0Hß&÷Uñ¤ØÝSI¦TÆüÈùìòöYؾqG×Ot ÒúâañèôÿǕѤùgð ºLÂqý£$ªÁÁbe×—B‘´äƒ1Õ/›„~)$_>„î±~#å=®ÿEe{6µq|÷ùcx]Ê»!GñÈ£ÔeúÈFÈç4ðJ´_¼¬4·H7ÑQ$¹kâ÷ò™; 4\€Ï¹V…Æ9Îñ¸>žÀÜÅ;_¸¬MyRÉR¡‰‹œDzÈž7´òz;JyýÄ9ëyœ(Ru^/_ôfcµßyŒÑKÆu|«éhºÊLŸ1»$˜ÌÃ5(£u+ú׃è“ Ú®Ó4ù°Ç-Ty•4õÍæpKÙ%9e¨÷Ë>xS €R¦X}¢§†ýKn ÆÔ1«úWò5 ,ßÎÄO+{]Ip»õ˜|ißÕÄy®C®‚‡ð9ÓBð –õ«åÛåÛš‚³Å,‚=µ‰D¹´,*ÂËËä¿3·<^•hŸUý5pIn¥(«“_‚c2æf1P2 ÇmG4á$‰QàãDHIÔPMÍY6vù|ö®aC6ï“ÿÎwܼK“¯ÃpëZwqÜu¯B/<½ÄjÀÀ×?¶?%;xÜO$7‰Ì{±6/š"¨¥PPS5é9Àk¾‘^©¬Ëo¶¶7ˆË8è»Yq¯ëÒYKh ÀjElÞŽ%L Q투;A(û‘nžUÆKׂU·Pà›aúŒ4!°Ú7ÂíД¸»ieK>\±”Ùe{æsVÊ„Öú—8 O¶µIYé« MsóÊÐ)%Oy äwÖ²9+%ŽŽj—_yçÅ)9cxÆÑáI±ÉêjPñuŠÑÕ‰öøJ¡ëõ ꣪>.PÄaÞyÞ{0…~¸.&“‹pP,ØñM(ôÁLóãb¢à4]ȺwÙà*w\EnL#kÔ˜øúˆ½f½ÄÙu@”hœ!$~–ñ EÄ"b0ÈóÝa„@SFÈýž6º1i|K¨B¡”X;#þ‹Áâ»ãàzúÃÜê¶8ôÑïÎƦœuz¡mŽiþ±bK79¤QÀ„åÁñªÛnmQ4-`èú‘•Dlæýcµ†ROÚ }Z\WÛŒxdÿõ"·%7̶˜Vƒ»ÐǦÛ÷ô¯fk|Òá?}­S|rzµ µ%i4?ÚA5Uìx¯S8mM„ ìaM‘ÓE,ëæc/…Ã5 Ô°.à@òÖR3 !RÜh)/Î8¡}zÆ{0p'H}Ø{µõÒ ^TÈ#á2Ï3Úó,صßy‰Øë— ArOÿ>q$ëâñmŒ`ACKÕûêÏpc³úÔK8‰Æ’‰ÄüÊJ‹:8Ôo©0þZö¢ì5·¶¤yY×ò›LgKª­–(Ú±¶ëÍr ŸõÍŒ1ù ò³´‡Á_¡«lñrD艧Gëʪ®BF"óT¢µÞ„—qäÄ 6ËÕµsÄä¨$µ¥UÚöþ¿²àÖ/ß$yD…#a^“?}!Õ„Ã .—åJ9󮦘±ÐÙùRwë&Ixœw“=t:NéºêØŽšµØÚÇ•UZ–ˆ¤äšª×bö­ˆ©ºññ‡Ûòær—óÏ! g`ôÎá„$ºŒ%iƒ%íGN¯0hsõ„;I¬NÂÕG™˜¨±ì&ËbùµæN]p8X¥æ "‹^™uøÀê<Ëï{ Ìlxó®ü-»ËßFZ ÀÅ6C¡7fû•_@÷ž@à™uQÜ•/ðz•ø…’)£C÷•Öùq8¯ÓQi{⓶Ÿ &3´ì¹æÙiêâòËhz6¾NWr¿Îð›ö|qèfC)}¥ÑþTµšœßb`k‹¥rìùÌF„›xë©=Ü;;êo¾+t`o$=&*Aä{bICQ¹d&-¼]xzâ3;ÝRCxýö*Ø?ÆM'å")™“X…XR|U– VeŽ»V Œqœ´âBõFB‡-%“Ï..tƒ¤xN¾DÄ@KZÑh™ëØ7{ìa ³œŽ•…HqŸ_L}¥?öj ú—ån–6Ñ&‚ÀcœLt›ØmtZ»y6#tíúÉŸ_~’Õé¾ "&³¥ÂËPæµùbÙw§)FÊ#€³½f9_ìÛËÒƒép¿…D±×Ÿ {ž‡ÁƪG T„cz+»Ruà›FBÉ«ïÜ6â}*Lã`^=Ue‹½Y&â"°ÈÀ²KÕÉ(?6¡Ëç¥Wÿáf­u¸ÑyŒy«`¡¹tSruŠóv®X¾ÕÌ'$ À<‡¿×så:æN¯cPmvOÈè†ò†çÆ3„Ý/åhDK"þ£¥1qÖµ>\K&Ýë—¥Ç"”3J’·Ø5ÒÄ`Ì…±¸–ÓÆ*"ÀåÊba£@…k"2`ñûs\®“”‹äAcò¶œÁË÷Èú-s!Ñ;Û~dï›É‚Íf—¹.{&Ò(wJ\ÛÇÛ³wºT‰qZbɺùœÁ•\~Ý…S¹Cu(ŸÊl%nýFƒZUx9¼ñ¥PQž á²B½Ü&œ­2áÞä£,Mé*K ¦û~enòÝ(ÏY!1ß9ñgDîËWИ¦ü¼osý9^cøfKÚ'¿ÒVŸÑ蜷¨i±}SÀßy·T1u“?˜.0W¦4—gH³ìµÅ€²ô¨x¯A¼’sì‘ëiƒζá-¶`¿ðÉÿC¸$>ÂP4Ñ’MZˆŒB¨ñ?‹Yå2J’;yåcÁ¹/Fo0 ž„´Šâœ4ÉÏLø^.;5‡QrGž¾\š¸'$#[õ„ʪÖß´Ü ÛD).™~-¡qÎÓ:®ã¼Wó_±ßŽ«äq2­C»¾c1šúĆ~~ïm@Àwvxe€í›ùþúò¢ûÀ™T5|¤f]•BS‹¡KôˆKãÊC à‹-q?ÌëÓ¼K[ïêË®^"2ûó€ >§Ñ[<Ð2goW§ÓX$ëÚà­¥r4¥BŠì»‰ïÍV»I;åH#¶¹ŠVo²KgIÅtšIµjœd«U¸ªS±‚cR›Pm0G§æåø+ïzU œdîÐÙO8“¼÷Á©j–ÝøuVfU;\1ÎçvýW[Wç›{P"c<.„ý|TÅÒÒ>žVú^h´Ha–A’#?r²v2¾æÞä~X¯žC|®6VK£Ä³­õSZ¥Mj`z5þ÷¥áám‰|9l/Vš1üsøñ§‹QhÖk¤FŽ&žÔBÿ-S®“W“èb&»4q¿H9G»‹÷žIÉøxëÒ*¨¡maäÞ”ìUý¼ÛÒÑéU@ÛÀaè_}«NôèFï‡r|#¿LœY-‘ûðhRÿ±™PVCÅèàƒVûÝt‘·gì=¿7f%i4Z4ÝMŒU}‡ñÔÈžÑr¿hc<ùǦ¯PK×—ÐÌÉ‘IøÉ›^%IüC3g¦,^Á³Þó6È?«y×zˆÂ)ŸÂŠ/Þ‡• ‚} “>Øä»±Y=‚'xÐ:×z}™bÎØà¼Û ù)vLÏÙ ç#&u«}()„FH ÖžÁw0¤Æ½Q*ëñÎñècî–[ßÆÜ\ˆè Js…˜àÞ¹è0£¬À‰:MŠÈšxã5Ö¾Ló¾/',”U@͈k®mÜÙ÷³²óßÌûªXû]>‰Ÿ^Ö:òŠ?,([ÛrB~L ·lõé›+ÜæùâÈ­c;ᢜ{H¬m/–}ÇÈÅbûÎááÏO™Qê¬p}懅Íï½Ä+$6_ÇŸ‡M`ÔM駴ädoÂfáåëňÁp;QBøüüÂ0VF,•›ž'¨ëâß8²xKS} ¢üQì–ú‰§t>õÍV þ‹ÆJ3½ Ø—ïÔ- uð´n´2Ý#åcuŸ¨e˜Ö·f°ØOÍœ˜Þgzž£ QxAåg­G ;üÁ’t*ež9*O‘™Îv¦+Õ©V-Ø ù%ÞU¥ó-pµ˜•Ìgd{5crwÙU©é7SYWD¯^¼;æ:7»Vk4á ‡B¤{° 䱩 ׶:šgpÉ“G¡Q ƒàËÊùc—èËï|úÄí—ñ½z&¡>˜¼Ï½>e ë7 âIWb6&òtFØYKßÖ\=Û7–‡ %ãý>ÿ*SZü´e¯ALk:fóÔç ÇÄ9–[½—Êx‰»;ª’>|°ÜxÄ.ï’‰(áa¢Åíí2Ô[sÜFxãÃÌ µ®Ú*ùñMc¬ÚxMÅÏv×/vT`—Ä.§ôÛÇ!3'©#í_àzŽ× Œ”Æ0(MWI€¢V½ˆÍè“^Ò5O½ÈR7¯ŠI%–¶ˆ‘]“/³â³9UÔС4/\ˆŠ8Û!®’5%+ðÂé!6m“ñK¾~€ ¼Çw°È8Š;ÃÉ7–êˆýd Œ# „ý n÷vIRȼSÎ[ï³ï®WЭ¶ž—Þ–9G…ê MØË(u!Ñj 78d`ëC÷°’¼Ý“g_«Ñ0Tª“tÒ/Q¨&({cHau}ã"ßzU~"’Ú8YܘK¨G…=p¢ÙÏRmëCk”©ç 0RÅÅW®¢Ï(± ×?¨ Í(¯n Ø€ÖSì·oܨŠŽG¨·šé„òÉÈ¥º'¨Ö²7 Ú³Á8 Ë„:È®cFÕÛÃŽìçRU5ác¶Íî~xô(Ö®Áïìš4X3óæö¹xò7 »ƒ²P¬Î¾ªÿj’KZy•A€ÙªŸÑîü#s-<’ ^d¿~7êgÚÆ1tdô<§5øPÀ™ËñRãêÑ!aíW-5å$\J—k2%Ó]¤AXì§×ÔÃÇ͹T¦Ózìo,ó1ʵû”q¦zúš;Ûê´ù×5ºBË=ÇKD5d«ƒZéñ*:½ÐHZdÂ5Ú LFâyÈ(jÚÉ6¯P6Z&Ÿ}léEFð –çþvé ÁoB«á¯ÝPr#ncðZf®\ÅŸåuýjŸD2Ÿ®ñÐ_E¸ŸFdGFº=Åj 6¦½¬n?´ÈÿšÈ“ù͇•/h+%ºž¡·Å gO¶¬ uªûP5’܇¹N?µaê“Ehô¼Ís6£¨@¿öttû½dmè¯4%ÄŸ–8©ïyÌüã-¬ð0ܘ†½}t›ªÅþ¤`"rl~²Þ#Ÿ~•Xð&Kèóʆ’–Q芜Êäµ)a•â}ÔWGûø¢w§b‡Þ߸ÏÝèEˆÍºeH²ž÷|fŸaNñ¦Tß éo¿êxiHþÙ6‡¥åéš!H¬Ôö{N ÅôµZìÍó¸ÞOxèÅIÓÖ÷&Aå5–ÞX ð°TÿF’×.ƒ³çµ7¾m¡t$Ûž]Z粈¼J.ü€N{ÖÝž#ÉVò{ø4¬ŒKE¹½6ä]äÎ=O˵Õvo#Ü{°²K+Á¡'QÓV!"Ñl…6^|acÒZáïjh?LaÍÁ°TܦŠ‘G»TJ©dGí…4j@$çUÓ%­üø¬BÃ)<ƘZkc꘡aðjôR$¸ÉtíÉÀ²Ñ„tûÕª‚ÛoH/m61Ž0­¯ÑSs¤ãÉÚÍ* ¸‡¨”ÜLÏJÐIj|˜Ñ" ‡ÅÅO4&rfm ³s¡L¶-{¤NmŒ‰ï£Ã¹þ?ÿ›àD+ÐÕÝ tµÇø?Õ endstream endobj 60 0 obj<>stream xÚí“e\”k·ÆEºK@zh˜¡[º¤»Af€‘a†º¤C‘’–F@,Bº¤Dén%”Né>£û}·žý~<çÓùg¾<ÿë^÷Z׳Ö.6cA%0âDG ËTtML¤ÂB "..$ÄEÀUíP€°´´0@ í„%dÄ$d@âD\„«7êè„ðªðý ’(¹@P{;8@×åqÁä°·ƒŒöPÊ[ ƒŒ~ÞpAÜ!HXˆHX†Ú£ ŽP8ð§!-¸ ù— F»þûÈ‚tǘðbLò0Á8̆8õ˜ZŒ“ÿ SÿL®Ž†Áôì\~¦ÿÙ¤ÿ8¶s¼ÿ€pqE£ H€. AÂÿjùË›. E»üóT eƒÚ+Áaè/ ê®õ‚€  ({' ‰†ü’!pð?=`ÚöËPGUÇØD‹ÿ¯qþ:3°ƒÂQ&Þ®'ýü‹…3¦9H¨À$ c1¿¿ÝûG-5¸= …cöA\`‡DÚyaCâ_a†x ^¿@!8…¹À´Äà€@ýœ¦¨FÀ`vÈŸú/I ºÚ!!pÄõ[þ—ú×@ÿ–E12 íþ[¼] ðߦ†+fìðoIDÀ!³8¦&Êñ›1ÕPNHÈ" ýÛ¦æ âþ»²„$¨ò7av h÷›¤À¿ SÝþoÆ4ùVúÅ0ôb¾úbÃ~£0ÆüĤrý1© &•ûˆiÓïÆ ‹`\yÿÂÿ\.ee„—¯ 8@PDT Ži¹„´´ÿ3…CÝÐ-ULkA )Ñ¿–ÍÄLõë¿ŒYÛ³³ãˆÄžhr a/ú0¥*¼$@-à%î-,eÇê8½Š–áFâ‰x,Ø‹ÏÚn·¾”[œ–¦S“-á.±zž3ºG7øöªo?r‹K½\ò°]J÷©e´ø‘®ëýÝ•ý(d¼¾jdCKèKwI’eAÇóÎõ\^U“eü¶k¬=*?d„JHZ¨§ÃL#ÂʹEÙŒ(RÝJ"Å"f=)’pfûCFÔðOï"ÐT§ù9‰—÷±"„!³‹ C½‡}úϪ¶Déã«XAÒ³â—ù£ýU«3¡¼öTø’Î_Á­6•rÖó èž6¯«%©Qº3óÐúOµJC 5ÓL<Û¡ ¨ÄwÕ”_c¹ýåͨ+ °èÙœ 5(•ð>ip5_º¨ðßÒk0,ÆLŽª:M ÍàsM¶“ñD÷¨jÇ27gŸHN<¨OÖpü¹rªRÒÈ®W Xµlw¥Ò©`ö~uŸÝ—Ú‹ÿåȨ€§ºàÎÍv2JªLZX–Z}6Ö¦ÃèDå8ÿÜ<ôíZÜ宫­Üt|7§°{Yº.ŸlP¾zŸñ(Ww&u?÷ê A]>IËöLØùûŽ´íIÙêîžÀMHàbä.Î?>Íù3·Û~Ž\¶Ý5!V$y—xŽÎ²šï»Ë[:dv:*%žŒÍ£À3ו—Xx9 ·˜G¶ï>öàØHäÌë–Uö°ö5w9£¥Gw+™R–ûÄæ¶F³$]óYó×1LLÛ­.Ñ<õŸv¤päÔ'lÍ~6kë̱oÝX\Ön´ *ÙÛSêg¶\‹Pžxüe9(tï”FÈ–—¹–Ënq5 <âmïê«Dë‘LŠÔµ›6G [}Ö`î[ÃëÀ'ïÍÞð(UÜÞ^–Ó+ŒùmßüÁúØ°= {ç±)ó@®<å¨k´²®fó9‚yyÚçBJ:¼]ô‰LSúšœgw/±Õv]RRË Íf¹‹º’´w«àǬK›zfv‹`kÒ/Ïׇdñ4 ñeÄ ¬œkÁº‡J„r›ÕÝë…—ú›)gEÆGaîg.ÛdùËIjólâ¢>RsÒ&gà÷™¼ÕK9ú¬9|,Oœü±cE}®5÷©…è Kh /w»ýFRyÌ‘ö—¾×àl Ʀ£fSúį%7G†å;*‰¯vª?4Ó|¨­|Ë‚×媥ü†;nÈ'\–ØÞü-þB+È•ØD1“WO³¼ÔÀ±w&ËýJ@¹%Ä5ÓI‘ítJ€}†`àHI§¢mk òu$(|{[#4~¼Ç‰îšš¿ Håm×½îŽ*êŠR Ù||ßÝLéTͨw%Õu´[pí§7¸î9ûuì\GÖ­…Éù„øV”ƒ¸îñB¸Õeæ¾™g^F¹qàB˜¨ÇLüØøÖ}Õ¸ž‚—ÀHøtç §ÿu"ÅÎS…Ó wòòËwzÁwªáB ô|…î[·0I+Ye\v=Š ô¢'nŒôäÄ&ˆz ÔÞÇ*xm¤<ºhHnI‹5Ô€s¥0|Éôꌵ9MôºŽx¦]–fzáWÔXeO0[+Ÿ\Ãuߤ.TÚÞn[\|;ãEƧJÚ±‹ŠÍg}W’Ñ·¡ù!>zè^¬íœ›º41<¨ŒôÃlÈИ†„Áõ”<È„ðúÝ|¸KökbO:xëèèÅLî¨ho4 \0˜ã[2È–v¥Ñ~$¤ ¡©“çÄë0·¨Óíqâ2–Œ ½ÈuëÕÖ¾]ì-Öuv­Í6‘éÎç¹â,Gj{#sˆRÖ)Dm‘³§¢5ž§žc<2xŠa«Ñ¯is/‹íÓ¬M¶L×n›7 Q˜3xMV¶rL7Ѻ -Å+܉VPÈ{‡ÎZ}¼f[¹Œí¸:=À2' £ž•çÚ­ îA|~û¾[§rãøµ‹Üˆ„¢GL¨¶kýš\8Ú¼`:×Ñ&†jñ-†T¿îhtŒ–„ÌPÛ/Ë°A¹÷b‚ÏqãõÏ’íŒÔ[)<ÖO‡QÔrk2™bstÉÛd›t6Ù¥žc3ÐþÁžòtö»[óòŒ·éßo×jøYMu™ÉÅèóENt…ŠRÆ5Èï͇,íæÖa)\ÁCX]ÜR%°2“JfëšîüÈ ×;É¥€—b¶,dzô‡É÷¤Ñc¿#%F‹Ž)˜·>K-ëíª*6Õ¾.â²é½¸NÂJ¯€JÇ ©²ð4¥SêÚžâ D-¹SÑêûtzÚËþ¢³Ú'P‘‡G§*¨›!Òt™”²×YAñµÅLxÊØÙF5T-·Ù^.&•r¶Z¼“:žÐÞDǤòM{ýóâ·]Î{¸¶q¦Ì>?R:²3Ñ£^´6¾"ш\_‘"p\,?J5ÎÓÿ¤¢0ЕdI¿z»ùåÜHÈ“8ù‰ízzªPãKŽT-ZÚï¼-R~&aõ<Ø«9W.ƒ– ô-·ßã©œ¾,oÿaÜe(æ€Ý™vä%löÞÏËËù$n#£u/9=Cp<ãºNÅðD½²µèWîs)÷l}€|Ð׊Ï-º2•¹ ·¾8ï7‡Å­j9¨ä¦Sà>Ÿìù«Œã>Lö<¡÷ –ðñæ ‰à:g³¨þ‡„P¥dZäî®wßy®E>›¨¡V/æ{×9±bý•¨Ú^OäØÜ(e¨TFv´CªÝÕÀyµ·Ô¶œÛùAZ»M¹Ð>zâÕ͸PÞŒI8®÷Š,k¼[Uþ•ópÓ‘“tÓýM>RöÞ5=ÝWŒ¼ þ\rƒ‡û’ˆ‚Y½Ì\ç4R³ºîìèvK©nWÅQŠ°ãê®Ï¶4ž KÖŒªOzý°g_És1¼Kï Åæ眱ÚÞ°Ð&æ2|µ,–‰øž“YJYH»ðgÓ’sùõÈÙ„9×éÄÏ•IÞ·ÿzÙSó»N… €†¸„j©œÂœ†|o[„v“Ñ”5•ªjñN­$Ö1QŸYJ±GÏ"'46~Í}kÊâe«²pœbºïñðroé:VÒ‚Ñ'+âÓ¥zª¯ýdÞäž3;¬ß+Äò ˜Ñµ,’¿½™nkë÷¸éSÜ`ó©ž¼ˆ÷{î¡RĈèÐ8®…dÔpæKg§/æê‘Ú}d^7Š’RdjeCVƒ¨[üójgyïàxÖæÄ¥ùR­‹mÔÆ´]÷ë¬Ð‰XyÌ-(ðß8-Ft)îzáMØFzέ^†D›O;ä|B £œÝæÃ’³ñ0‘ª.ÜñlÅlvÿ"ôáøUûPNƒÛoøã&ºñ6É­ka8|H?â.û ä “•¼S$×*Mnù;Qs®iýÕ(Fµ9»ObÅÜÈÙå &¯uï;ÑGYM|“‰M6*çKÛ3›tld‡ µ†œ 5‰¶ËéÝVîC$Þ[yç¯oJìÒ¿QyÆÉ܇sX[w_C^¡@—8j÷“X§É5úàV¦7[ärµ,Ù+[«¤'ê'd¬6P!Û·bó]XkÞÇû÷S7y#RYP7½Y¹©U¤–®èÝ2ªWq+ñ"4³ÉhRαR6ÝØSoì®Ç㸀‡L\»T?2§Ô‘ô( ÅÖ“œ¦U…0n_¿ðj¥P´è1õˆ副åuCiPV~pœìÂÞZ£)«9_˜Ó6Ö+›¡…iHo•ìXÔSUUê×åZà!ì̯è’ƒpíW§î‘cFíà03nž &ò³ð¬ôJª!Àé¹ÏGË:ºiîAŠÍ®ÓŸêíˆüË^øßVÔn Ÿ(³U·DD%2Šâ5kn)¦dÍ3ÀTóÉ;ªÄ·ÛúWVåTîã…àOßNDPQ* T“!I ¼}h‡u>¹„Vc+›0µ/Ì¿Š¼B1°î“¼ `­Eý³ô~ÏÂÞjdSÊõ¬g,’}ŒâU¾èŠF›é6Nõ÷ o•ß®áÑv…åI 36˜Z>¬tR­YFÖ!ð’ãßäu~S¸|´~ÿ^|Zd}“gí=‚ïê&gºó÷:e2*:­RÛ\ ‰j*†9f¾þGMï7¿Ž ¸§Ë"žj~ÎM¢cè&Šú[¼²"‚϶±¤]K-²3] WN47õw”ñ}r›êáʼŸžKÚXïâU±àçïRE{zb†Þ¯S.¥!"Ë<_>téÞAÐÛîÉ4©å$«*ÿZ©#xÓ`ÝŠ7Á­øùüã&êݤ·)í _$ö2ù10 5ÄzjÍùœ Ð˜q¨`W‡íGOãD¼D?÷<è¶Bf !ys¯á{{ø¥ã|bÏzÔ½¶éYSÄ•$îQºÜ¸¼`0¸Ç÷ºôù.doP7~›&nBÀ§ÀòÙ9 y¡•„[—Æ•o» $4[j1'Êš8jª·Dã”oÁMMe;²]YÁbggÛΪJ6ÑŸK÷ƒ ’ªKÓE4¾ÐmÖ¦:"Ý>Cd‘§ÏѼñ¦Eݧ‹´Àí`ê´³ ¿•“OêyÈJ{'¶Néù—ãüq’*çÎ6–ŧ´6b½3}­&¹(BJ}—صgàÒæ'I¤£K¦móÁØèÁë哼S!Æ-;„®Ëoôó“s#àï%½~ATùSlÕÄg”BTô3 Wƒ•}…:¢*‰©½ü–šCcÜt‹ÈüŸ,´˜<[›¼{ðìòÁX›ä'Ž”îTä£YEÖÒe8Ü+¼t¥MÁ­Çú¦DÇ•ÖyõUö¥o¨O+\$oóž‰åŒ49…¨M5sñ¤n]‘"3;w­—´@Å­Ù󣕅ËOœœ·³irF|Îós.«ã {íâ•çÎ;Þ²‚ú”¤Ogïî%k9V‰u~ºy¬%UMð’)Ù±Ô­I¥Íº ©¼_I ŒÒœÖùVpwÂ\]ÓNhâÅÉÒFräñœÙÿÆk?ˆ•7…OY–!hcªü>ÓóÔ;!=ûúíˆ ï~9ý6)'/úQÎW#kïyø‰’U÷ˆ.¿¸IéÚ7…±-^l/Q‰5?þ¢eËòL…¸—:Ì9|\§šóÑX,Âð3PbÓÜîT„üÙ]F³ Õ› ó4¬F¹ÔÁ`ìyî*¡¥Õ)…Ñ®–Éè[Çû«/âû*ë5ï”ZÄÚºìå×ø]_xÿʱöõøplaòcœ4Oˆ‹ÇŒ:pëÙ°x ,°6K3̺†*)fFŸ<—{kÀ&Ô~ðn|n–½¢+Vœõ-/§„ ¯qf>`Ï ›#OAl‘Ž+=n\K÷Pxg]\§îùÌä.lß¼=­kè×[ǶY.ïCôZé7#^¢3-§ÎSëÑ>¥aÖ-O…ƒØ î¤oï9dù^¿ÿÌŒ“>V({„E¥FÇuñ€ËîÐŽù+ø{wTIsåØý)73¾Ô=ôCãa Ûä[Mµöy¸Ç ÿ°;g‹î-¸$Kc%Î|G¢[ócòÆ,­lÒÁÈ~£åÖOj‚¼éãÙ¾,TY_\ùÕ¤’`Q[‚!I»×¨ÝFâBe¢ÏOÒÚ÷Ø%§¦Èêxc+»À+®Ü2ì¢UáÎXGìãBýÜ¡A)kÙç×U'rÌŒ[­ˆcÖš³Ø  ë7ÇžŸœþXžkÇAª…W¹`‡•fºku(L§æ°†‘Ñ+ø3œ“)ÍRî•ÊS"³Ø÷&ƒ"Œûp(‹Ï—ju>kæQzWïUË[¹›ùfø_l¨(c ¯ì¿érÇﯺð@z-2!`ðDGÊc;óÜ-ßÛ–Œ©7¦d{ð6îäb™Ýwû¾ÎÂ窵 M´¸\(õ¢>Àb½ó–ÙC¿NíH€26ñ98uõ¥Y濶¹WTÍ=£é%ã¥ϵ·•ÀœYLXÓÃyŽ•{ÅHJôPE¶OæKð쵶Øù/@ÓœèxõÚS+C(²°…°áQ”¢Ä#$kÓå…ïäø–]\3Ë`— ÿáCôÿ þO$°‡Aì(„‹Ò™è¿EÌÐ& endstream endobj 61 0 obj<>stream xÚí–g8\k¿Æ•h“h!zYˆ½×¢w¢‹23ÆÌ`´hQ½÷^"AˆNˆhQ¢½FNpì½Ïûîœ}>žóé\g­/ë÷o÷½žçY×µX™tôyA6P%$Í#À+ (h¨Š¼ü VV¨5†D(Z£¡’€€„„ðÈÍ$ùÅ$…A¬€åå³³G œ‰œ .0°5дFÛCnf€­á€> ƒ¢½xGp8 ÷G‡+ u…º¸C!¼ £¨ âûÃ* ˆý†¸¡þ•r‡º¸Þ˜8nLr7!HÜ €@mA|ZÈ-è“ÿ Sÿ®ä‡kY;ý1þEúoik'Üë? N(74ÔÐDB .ˆ–Aÿò¦ …ÀÜœþ™UE[ÃaàG;8àæåþ+sU‚yB!:04Ø°µ†»BÿŒC:¹Y¼?}ðk«ê˜(pÿµ©æt¬a´ ðÿ]ü' üÍ7KäóÌøyùùn oî=YüCë1Œ„Àv€ ˆ(`íâbíâ¿%("x 0ê @=o óñ"è›àfa|[¤ è=æøPÖ.Pj‹þ#õWTà?£íá¿Âb7ÅJ“(À§ñ7‰|Zÿ&qA€OïoøôÿM7gÏúoºé³ù›$>ð¿I€ÿFòÞØ‚þ†7"¶¿áŠÝo(ðÁ~÷¿á,ü7¼Ñuúnt¿á.ò7¼ÑEý†ÂŸËox£ëúÞè¢Û—wû ot=þFÁ!¯?ñ¿(yy¤§7À#(ÂÿG'? &Âïû_ Ÿ `ÎnPUE@„ŸŸ_\PôÏ(ØÍåf+Ñ~Ç7‡õ_l »9ßP¨' šC‚¥‚RjCKü ¾Áát¥K{Ü×R“&Å»9+uwÄ¥nÀÊð“4„ÔVJ’¼­^ᙧ®}äÓå­Ï2AÚEHΙ—®· Þ4Šõ%çs±SVØÚ$ã2ªŽ{wŠåhν§BcC@,Ÿz;üVÉøØ埣ÿüäíTËJ2È"§I# j¸>Û{¾¥Œ,@N¾úBiž~Dv5IÝñ}Øq†0M""G{¬xÏL¹"i—£¤Ózz&õ“Ï‘žöÁÔx‚ì{?ß*%Þ¬X¤SŒÙ‰gè<@`¼¹¶?ØEJ²Ê­œjÒ1™µ¯­fúÞš²¨ 6$ëî=l,° ~{°@tÿ…«h¹+}·+NËê4c‚*ÁùñíhCÆf#b3Vy³Ëõ½.ºïÀëç²éüd))OÅóMfhµÛp›è;FÌRŸ1Û¿öYŸÁ2¯ªNyÙ´C‡„«CI—h¹MÆŶˆ[™MŠZÐq-sù|oÈ_‘´¨øƒ'ñGöØ[²¼WdÁúùf»ùÙòïïÐã…GH¢ÛÕ}Kð„_êCÅCceƒßžl¨ ,¥ÔiÞ—}/eXw°qõ¥&jýjZ‰—Z¢ÄS˜|ÎdçÕõ=Î}qØÐ5H1Á\7µÏâÍÂ%åÛÍÃ9½A;áB‚Eøc\Ô'aðØ&¡yÅ×bJ&„9ùòIì—&Q/9G6yØ 4ÚL´W‘<û ÑÚÉ(Lõ*¢Çïé§qÊü­³¾ ´î=¨c'R ¼š³“ý}@)­l.ü¡úØFúi"—GÊÕ÷Á]zƒ úØq<8(ùÅ’p¬óϵÏØâQQ6ŽD¦6u2½ïÝÆ3$ÏÌ~v¿zXCXÅåÓ@¦Ø±²°;­š¦¢¤ÔõtÖq‹Íf½ˆiÅèk5‰Ê`®×èÍAܔȖ­µ‚"eËsür ÷Ò/f?|6ÝZ^leäƒõ$|î4>ºû1ë*Ý›So„By=t¶Ž¾ãÉÜgn¤ß”_Åÿ+ìÈ Ì^9D—¥ »6Y7ÿÊNvú[P%£„Woæ0šü~U0ql)¼b¥K%í  é€bû 0•h|“²åጢ¾#JßÎÊ UŸhB‹©lû‚J:ª£·Ü‚C-ëÛ‡©O¢˜“U.ðF¹U5àV¤ÆM¢L(È¢1Hˆâãûh;Má—·¤î·©ãš÷Á;O+aÒÒyåÚ×T½6ÌÈÀnFêXÌ ªue¦cšUMÅrsç¥Îå7,ˆJ—vh“·[[ÞöVÄJZj3;Ñ$O~ìlì~×ð6ìKM1?}rYSÊó×ûì;ÏŸ:%Ù4¯‰¥ À{/FƽñXŸy{Rü:qßaëGÊN<ú•™á$Ès¸WFN1êª êZò+9ègiN@õJ$vê~·m¿¾­7®ÝˆPÿÈu›quZ š¹µdorÀ%Ã'›µ¬³|&£¶ïwûšïY_´–¼¡Aˆ}¥ù‹4}#°*–,ý8/Ò`· Úoè§ö§€l©Eü±B^ŒÏV‹Ò}£I‘zЗz¸_±¿Ÿù¦¬jì]€3Ü .GH4[Â&ÊúŒ!£MÄŠ`GŠŠù®šÈÕÎÆ?Ût("oE]—%q ‰,íy •š˜.6ûbÙMÄ5Öà­3†•¼aOæ7^ôÈ渦ɛölGY­&(Š¾3T2%}–ÿx,Ó>û§úõø|=RŠ.¿\ÇàÞc—{/¾QNég©ã™ÜÁÓ7Ñ §MÞœsVaú;rÌç¾¹²/ÛUÚÄÙ´D©0 ¤• ;<=MŠæ&´!ûþGO™:%€e¹éý¢ÍÆ¡ÐìK6;ÔŽ«^u(S¸½À€hB9?Pu{›.b=ÒÞ9Q®äõº>ªWú¾ OOdHïvk=Þ˜x@eÏÛAkCé¼µ0ãåq'ËÁî‡IßÙ5;pÞkñ¤¾$Ä4Ÿ o#´çÌp«QÇr­gêIÍ’idåwcúRûÒ£[´[˜ßƦ%X¾WÙä|½l¢ìòm=§¤7a’ï–ý<·®ö~Ž`³Ó½ê~‰Í¥îcÆA%âƒKºs49†Ñ·:BdlÓÖGŸ€…ypöƒÊ”ÚïÕI§i0½‡ºähÝ]³2™f| 6Ñ{Pü·Þ²…«Í”*?n1Fb:~7BtÔœ8Ð)Öqì°ùŠ §Sa-æ9­ xÐáeÞ~øÙž“ó’ÏF‰!Ø?&ÏPÈ×åàÕf|yeõ™w‹TàD >m›() DJYˆ½²2nòVŽÆè•ùsŠjiJ­ª "ä+÷§R8­Ñ¾„‡vA™V_ÙiÜ"Íù5ÍòÆÚŒîÃ-9ÃÏ×ÚþÉO…~Ù,† ² \ï?ªˆ Üg ÿØ'¬zuÿ´½#k±có.5¯Xp ¶È-í¾V¨Íì¯zâWžœgÃau¨€‹Ã%}–s'í'dÙCZY_CÊ÷)IÜGË…çïÑôZÆíy1Ø0óEŽ{"¦ÊGçR^ê Îõ ;26 Í>$sN{ Ÿ+g°iõ^É/˾S {¯ezÔä 3Å’Z\­45;q$dRº+ºZ©æѧåzàkÌ®k;úIý`=”Z¬þpÀ`àžFi•øˆx±/ )¦™A/j éN$YšùœEœô’›{#:og8~§ˆY™6WÏ÷"ÇúŠ/@eÝo÷CÕ.::©®‘뛟jÛ¼DWÑT3£ekH9C¯³ Œ†u\Õ5O÷ÓÆ5æ:ˇuÎ|/Ç•»Š! ×ªº•ÒGìL@¹9uûÎó@ÓÓg½ÄúÃäW-|`Kx›’¿u'î^zLJ‹Ì€ÂèƒÔš»þ–1ð’['@Ü]õ@-3×JyÒˆ§yûÈôµ>÷¹ÝŽàyœg}ꣶ<ú»VqOÍ”Ä*=‰à‡¼ ^Ì(£" Å4Ö`< óÛ¨ Yç_†é:eN¾ŽW›Sfb¾¬F ßY‹M¸3‰¹’ŠO½ÞQ§VŠÊ“‡á$˜9‹Þ…«a SóÇÊpü9ÿ&¬D‘‘0Yÿ-°ŒíÕj I–wóLz§ÖâönkÑ@~ÅT—'-m-¤³´è¡-ê ÇØÛóÓëïÜË•­‡ãôÒÜÒ?#™¶sRù¯”Yn•Èߣ™Z§p}þIá !·QÀ,;Ü¡À ^ }6+¦ØB5åüˆÈÆ­÷È o7;‰fìâfŸ´iQN-Ë€©tkd>Å<”w~AECÞý˜9+#–î–Áç$ük®\öÓïùÚ£öVbU£³%$¶./+°F²æà"Šv¡³2%I 7Ô”£•Ë&&öÅ%¶pÅÞúÎÂP-2K³vûŽÀ‹BŸµÔ㛳ü>QJÙÀÆér~~wûÕW¹½ï.é/_lSxž@›P>Ï~$Ÿ:eÐJykÎEì7-ÊQi’Œªp16;ÝkÓIQ&Ì°¶­u³\™`["Êl<Þh] ⥭ÆxhCÖN,Öê~ôf(MŽŒümO kÜ5y\(ïW ¦’+>åG±<± ºÕ†Ð_9H,k¥;¿”gãoÙ»ñÀ¦Á`> LžäЗÎ8Û³¸ã>…×ך%ÓÛ¡™·Œ úç:Øàj Ê$MýÓuTI6û½õÏ5ø•–ƒÀ„ÙOãKPXqiÞ~I,\Êg¸5Æ«ÔØB½|bA›uÞ½pøS÷”% ƒ*Jô@ΕQ¦¨ŠÝ{13á“Œ×#^–š'Í—U,‡î…¿¥‚à¾ø¤­Ûqè›'Bbž@Ä©÷€õñÜit°Ûq”Qþõìµ g§œ}(+–F%ÃþÖÝžÐ21“Ρ,~Þ%ŽÊ³THúà>[IJ¶‰Ïè8Du›0ôòG6†û@ M@AH•ß«)LñgÔBÞ =†Ó¸±ãF R]ÐLÃLZ «¤ôæ•Uºè!+º½¶É?®÷ ñ‚EÕ«Oš†ìY]lθ«Üó´,¾Ÿ{¬Å£M°”t½nµcŒßU5SËSùRŒ&W£m÷¤÷;¸ð5÷E,WÇbgSgÄñt7«]z5{˜ä Õà¢}á5ùhJŠÐX†•?Hž,»ÜÊœŸ`Þå*úlÕn¥âÖö23”*)Qß)‰~ÜWýšÄâšf@µ´%K|©ªÎ«ÊˆôØgþük¥»Wøέªû9GŒõ+eòùW´U´žº–¤Ã%ÕR^ÅצDw"o³í锎2oáæÎ"‹»8EéQ€L†b}P¹Ò'U4úWí̺Š‘w(u®LI‘pWui6SÌØÊy(9Yu Ï•Ž§€oCpÖr´ì¹{eê5ççá4A…}ÝΤ ¥ØE2ªÌo×ìk.ËïåZÅ­[ÃUß’a´ã¬°*ãñœ8#v'ü ?&T«Ã(–ñ—fãyM0ÃûÃñìGüÛru‡|úP>@`4ÙDÈ:µÈ*¶QM³¹á§kùû¦Åú=®$šÒÞFÐþQséIÿîÈÝãûe­(Qï3ßw¨˜0‰çY«ê{´µÔF-B¹Á#þ½w?‘•6°ЫÊÚwááÎoc’·ØÃÍl=1 8”­6× ÔÎqÏì9£èsƒú.C_’0K+½»î(sþúùÖPPHtGlkèÏ÷o¼ôFÞêÏÞBsÐÌÆZr›ÃÕ®ÊÏÔî¨éª‹g8l˜ð/j ÷ݳëPÖrP©ˆÈÖ¡˜h• Qóm*¯ÒuÉYû–éhbL‚³%ý&T¿¡ÎסûéÝôêÓ¼:B=‡…¡6³›³²G1ž×ÅN¹8í;«)a_ä²Y¯aX\ìÊÝâBÔáSwÜàç7?¬ï­ ßiÐñ™U¯Ù`©P$q[ìhjZÓ8²”SÃÊÀbu1~",¿îçIv;«?èí9÷™Zü8ACÌrBä¤SFŒ]…e²µqF×Ä¢híGÞ%óªÇe,œ?j±¹C]Ãñ¥®Ã–Tº†¢td'z<+êú&Öþ»û KnþϤ|@kkM€¿µÇÀ§¹d}^šˆ‹‰.Mk‚%-ÃîƒPáщ #ºˆ¡ÁK”™Ù7œ8e²ô=.[aõqµ6CÕz{‘ŠZ_ò+_ðw^#ó>£•{|}é±Êù­¥ø›{6í¹\¯ Jß0=´ì^1iÐåÈW—¶xF)šµ\¤=×cà’Ê"¼Ô­ðñ«î9îÌbk6Ç“Ó\gmRz¤.¸ÚðÈ~-" ‡ª·’þró":‘ìl’‡6uŽÐ÷aX?þÜÂh.¾ýÎeÜp̦ki‰i$ËÖ²3,Iƒ €Çˆâ'\˜é·Ë?™P³6¥Ù°»W ΤD×Û,9< ½K?ñé[çš°~ç—”_!P2ôZYv’ßG$!D:˜Žµ`XôZÖG¡µD úH‡É4¥€H‹i{9FqÔú8‚žg(› œNZV ÐUAÅ¡ÏU9uÔ”Ù˜ÞÏÐz“5¿À¦:Ô¡_ÂeÚ]£5ȺSåV*¶ÖE/ÇEñr¦äWü"ŸŽ rž£ªo׿vL´¯ç½úè6Uce\ìyõÌF9ŸñkÞøªö±«è}KKLúå5L6µÛÍmÎù™üê…Úï+’%û9"!ØÝÇ4Ë‚S”[íñªŸ*!Æ"J®fèÊSŸyÒeŠ¼¬£ÑÌg.v]õæÅ¢­QæØ£û—¤ªGÇ–ÃÂá¤`B4«á~Ø]Åôñ ÙâîÍ]ÛKf?W¢™¢BûŽ fK_ñu¯'u¾ÇÚéMeCòHV‰ÕêGñoaùâKn<ÙYjןQqQÿúÒ¼…ž*hõå|3\ä¡´Á‘ïé‘)OiKáѹ–øí~&e˜¹ÆGдR²/(ò3¢ï½%­vÓlÕ£'öckŠÑ®F„ÇW™ [TH‚ÝŽ:^ù$¦?}Š‰åŒà®øXI‰‹Ý^+¿Kò`Q%ª?ÔU]—Iòè#ùüñW,™Ò»Îˆö m•õ§é…N0QNví g#ÙÎëñCyš®X¢¹É£3V|ËŠZ1Omy:¯8e½´-¯;^à.D§ËŒcvŽ_Kì^ÉàŒolL=ìq (`“Î O˜œ‘Ò+Aj\àSÏ8zïúS(¦E0¢€J)bWcé°`jæX0€€+ðó¾Í br“¼Of¥â-d»a*9Zd‘Ä·h¸¨<ÔMŒ*AÓ×™öz¬Y)f†8HaT³ðn×õÊbÓ‡òØÖ¹ÓM !sà e*õûXµ%v;£8ÆÁe}Á#ÖSÔ³~ùØ$§–g¶¿òpó¾w[w)Ë3N3éd—Ýú)c^L«Õ¦1z-M=ùÝZÕèJfë‹âOôU 8"ˆ6 ¹ýô5ÖÄ~é$”u.Ø3)âò’~Ç8ÞèáÈ*™fV=É +ù!ÀÓÙ[çÕ–n+)çÏYÈYk$¦_*ôRŽ$HôË õŠôRg?xM|ù]¿sŒd7ÏÿÃSæññ0Cƒ_L˜¸ôK.ú¨†©†¦v‘_öCå ¬É²æÛçÝeqoÙ‘ %ÆNœQžÎ°‚”óÞª\ßãÀ™š;VÄXq#åZº«íávŒ¨‡­ .QãîüF1$<Åòg÷ƒÆ¾v’ûIÑE)¯Wúôâ¨=·Ñ‰ÝCä‡ç=[幊5ƒ2ÉjLp 3k=.rЕ¹ÇŠE ÒûË>ô´\­ï‹áEù~n‡êØäRÜaÒ¤?Z¯½Ò}g )þÁBn› ¯îöûЉ|xèrð#^Š—ÏíK(-¤Øè¬~N ikçä ·šÀ ûwˆÂ…>:ßsdð²b$KäUL¶Ì*º¬Ú¥4-ˆÙ ½šÒv\“iu|ÒÈyB[ƒïÏh»>…»f)Vù4g$k/»lað¸6i:š­%Ы~úSÜJžHg’žg¬ðìa³xé»x`Ìòàþ5R#)&o㠲ܵ”èzÀÒHy¬Wh`vW‡Þ#nl}f M†~o¥¢V€=aä’PÉíq s>îBö=m5Çøæ×4ċbä,ï#Y˜k ^{eY·“¯¿ÜVÇ°ê~7M»IEœT¶VÛ®½"ÿDÒ;âê /íü(Ì¢@eä‚ž)2Ì‘‰µ èdÿw܃è£}ž]3:…†÷‡õÜJå[¼Ûû[×$ÞrÂcle—·a×ÏQÑí0ì']Sé]ˆ„ÍŠKöºŒTÖaVSÕc:ÊHÕ÷ë3ˆ¯ ‡Ïóœýô+3H³yJL5c`2Lw,)ÐA5{ÈaSŠÝ¤Qà‹8Z,ÊØü­²®F™ñÃÍšs&-‡¹èì®Ñ¯K¨¸²î>Y¨ötØÌFg6É*ÿÿðýÿ€ÿÀp¨µ édíâú®+ýÍ endstream endobj 62 0 obj<>stream xÚíRiTSG¥ŠUZ[IAT£,MòL ¡€#FÙQPžyx’¼—¾¼ÐD6ë®T¥.и¥ŠÄå´°QK nEP”Ô RàЩKÅúÀzzJ¶¿z:óg¾ûݹsçÎp9‘1<9F.…a$Aó„|¡ „(• !˜5‚°¸Ü ¢4N3PÊ€P*•€Y ùÄW&ö‘‰}Y\BêLžœBÏ~’/k!…«P(Q:j ª1¤ ‡´‰ä ˆîß¡ÑP©4ˆñYB!Àp –Âdœ` ú=)5 |_˜A÷ª•)=c x ØôŒIŒ$4&€A5K0‡dNƒŒ—ÃÖ`ñ0ƒF3ÕöË$õ·>ªÅ5¦?¤Vg !”$)b05¾4§„nÐî*hTƒ«äD²žp™öÇõa¸b‘8­JjT£‡8$°ÁN˜ü|fEÆÉQÞ<í@3Å :Ö¤ƒù“=P ÿ¬™(Ü!|2Df¾Z%:,”P‘N$‘XPŠBM,æ1•¤ N`Р‘q,à$ÍlL2™@MR¬þw• @ z}?Êúû5‚ƒIc:ÏGx"1#‹Ló¾b$ó¯Äyþ¾*f1âçëã'@UŠ‚=ð˜ˆ^ÕjœIB#T±l×H•ÿêeùåkK²B‹.æ©w7X}ñäš2³?¿«ÙÌUª¢.N¸ï¼Æy^::¯;â°S‹o±ËåÖôÁš&gëȱž;c†ßQu%,R»ïì™7´{6tÚ&¶ë*¼ï|?©§%íä°£³ú²»7Ú—\¿öü·¬ÔìK·lŽŸ`“:òX‰û¾ž½Îÿ©%÷Bïíp²ˆ´׎KØÙãòÂÆ>s³!õ‡‘fiÎ>åÐFsÀ3ÄÓ¨n½ÄîJh[°W:+F6Â]ruþ~3°{;€c^x¼2Bù눶zOiÇìÔ X™™73N1ï¡Û¡‚1ª7M@x1û5xìÌÂjm qz]û±¨•cR]lê*vp£“ž<çÞŸ¼ÉþAâÓ§ÍúrØÕwTé;×#Câ¼ýv¥yxwy^DØrâÑ”m´u6L XpxJ`5ûè©O≜ձéˆ&Þ{ãk­½\ìx¡Ö2–‹m¯ F“=l®V¥Ë7Š®„õ¸.gmÍýìùEyóYíMÓË$zöãB3EQ®ñ²rÓþñoy®í=Ô‡{®Ìôýrÿf,臂ȅ zZê{ +\Îwo¼tãk¥ZÙ·(fGÒ8uZi…[Õ¨ŽÔÙ5[OÁ©‘ïdÜÖé¢æ-ìI‹*ã“Kt&¦\)™›YV^³¡Œxýƒ+GOÇvîSó°ñœ zS„é€ 9(âºÞpÈD2¹ö›úŠêÏ:÷ƺ±’ÚÜØÝ5¶Ð½'¶³'è§Þji²óŠtwBGoë¾|©æHèÉf‹ôˆi²Ý„`廫øq¥‹£îsf]à][~j™'ϵî^ýD|øòɈ¦-]ãѸPûÉ87§ëw¾µî«Æ» ]•N¼ì”G½õ’GååF‡©–´Ýn–”{§\ݶĒ¿ymA}Ý–¾v³Ó¶‘÷Ÿz9¬ïp¯÷p/Ÿh{·¶«ù‡ƒõ¿ÀB@¥(E“Z”Jeý¼jWø endstream endobj 63 0 obj<>stream xÚí•U\\Ëö qwwšàîÜ!¸;4и[àîÁÝ în îOŸ{îÿ$÷ÎãÌÓü†~á[U{ÕW«Ö®MM¡¤Ê,bfo”´·safgaˆ)¨©ñØYب©Åœ€Æ. {;qc €ŸŸ âjà`°ópñpp!QÄì<@–.:1ú¿&ñDlN Sc;€‚±‹%ÐœÃÔØ jo ºx²Dll*=á P:Ü€f,Hìì3© Àh²CbýKHÆÎÜÀûwØÌÕá†Ü€NÎ`)X’V4³·³ñ˜Í‘XíÁkÁ&ÿ7¤þ;¹¤«¢±í_éÿ*Òÿ6ll ²ñü÷{[W @ÁÞ èd÷ßS5»)Í@®¶ÿ=*ãbl2±³°Øþœ%A@3%‹©%ÀÅÉø¯0ÐÎì¿Àeû—«¬”ÈyiÆ¿ó_cJÆ ;5O‡’þ5ù_Ìþ›ÁÅqytÙXØØØÁÁ¿ÿùOÿ¿Ö’°3µ7Ùû›`ìädì‰n 0q>²@vf@ÐìËÊbgï~.‰ÀÜÞ é¯Óää°:ºÚ»ÍLlþù;È`5³·±1vú'ÄÅ`u0vÚÙÍ]~GÙÿýû”ÿ ƒ“šÚÛÚÿŽpX-=,v¿CàEÀÍ`oö;Ä `u¶1v¶üá°zìø¬övÀ˜ìåâþ{œläbéüc€ÕÜÞõ÷V¸9ÁÛ3ÀºÎàrÿÃ`Yg Û®àÒ²ÿc‹Ü`U;П"|íÙÆþ‡øÿJc úÏ(XØèìü;6:ºÿ.?ØØ⯗ø[šì$ò›À>¢¿ ì"ö›À"â¿ ,!ññ‚—üMà•¥~8§üoçTøMàœŠ¿ œóÃ?ÄΩô›Àî*¿ \jÕß®³ÚoïHý7sjÿCà+ŽÕÄÉØÔèòýÆÏùOü?;|³°þî6~°®Éo§6ý‡ØÙÀ¾fà_åÿÿê–?¼ ÅÞåÞèWÐê;Yÿ`)›?leûÙÁVv ØÊþ[9ü` §?ð¯~ýÁ. XÃõk¸ý` ÷ßþ¨°zü` Ï?¬áõþû4€ÿqFìÜÿÿ>¢ÿýzµ÷øÈÌ`æàä¿€àFåóùÏiêv GW Œ8øgcããüûz4uu_7.ÿú/Þÿasø–=€¦H‹sö¦‚AV)ßBÊ|% &Êa E-ã뺦ۑâ!mŠGäÖjµ*Ò±Ñö`÷ÈÝŸˆ#Ú¼•Ç%ÏýãRg_öÜŒöÒ½š‰µ®Òü D·®[}wF¯–dºzhp- '… FªcYWèª;Æç˜Õ¾V¡MŒË—öm®X¹‰/†÷¦p‘¢Ù ?¬„BÓ™ÉèÙ¿ê h´/>îÙÙ=%ðÏW°6ŽÎà¹6\yQèwq*ÑøÌ¥¥»ƒäHNZ™õ&â­-ôÒÓɸ/i’‹oé¤ÞÉ&ñšYnØÑëÌÝÙ'f}Æäæ€EÎÒ™úI”ýø™j1Ę»)û%3‘S¸Vú6Xlù‚Ñ/û§ÔôMöùYùLj<:Ò–#ç=`Ë(9ž„ÊÊé7Á™ÙôƒJûÜ7¢ËK’ß䬟0ÝXხðž"ãsa“:b‘87»k_R…#ÍLP·ªmf}¹õ« Ú[à“ñô0•Û:kÖ£é‹!–—³9)G&8]S›Þ`,ó¾!´U 9![7ß•îZìþ<ÌÁžŒñ(vDÂÁº'R!íŽ~)8ãZBã‹C¦!D$ CØ\Ë/Ú±î²Û³#ÜÂÐIwôÍ™?Ã+#…~UÝlÀ?I’"N0¨uäWzUm"•Ó:}U~{{ý„!ð*ÖP^%{Ž@k^!˜£˜Ç;Ùž1¸ùÀs ÖÛüyŽÜFSÇóSŽÂÞ'#R…BbÉ_S8AJ0Ø=^ZÖ.ÍèÓ]ryÇÏýìGXcPš¢š:YTÔÌv¥F¼ª‰ ¾E#ÝŠ:S-0>ש‚”¥yÊä_£yA»ð6;l¼MŸ ںʛ2ZÙÜ5“¶»@Ì¢C‰Hóü[íSi¸±.‰n()¶“•ENI쥀§?mù‰Ì¬Ù†! júŒ«÷³ å+G€6GBÍc*°×tù9þÆsÈXdgAòE±”ëk›VW’ãvj˨®mtDt£}¢/l/ –˜Bƒ787ÍèÒ¨=ˆ¿–uå/p»”Ë¥`–>:¨Ñv˜Ÿ{¼‚ªË²ä¸5,ÍK99Ó›ö}¯ºœ¾úVÖ FÑe¥|öÄÍ`%ÓºçúàŒ'j-:+ü–Í ÀP6ûýKíìṀsä¤rIÎwégŠâXý`ˆÌŒéý¸nád¡8“C»= {²ªL­DÆx±äw?yÕ#¢5ý2FÌmVxê Tïð>¦Pg{T¿ê)8‘žÙ@¯ÊßÌj°É®Â4Iü6ìþ:gH¸yöÃ\ ÀÍÉ}JŽÁÔ/;cà†%ù4àGgq3Êý)GÕ'ïO>Š“„) ¤Ü_ß±þÀHÉð$Y›³ °F pó|Ð…‰>aÆm8üU[séÅ hœ”Æò«íÈ,kVón‡Ýg&^ËJÝ}<Æ=?Y%ჵ¤¡«5Ešó!a¼tšôõ£¦…\9L¤é‰š…t­õ·‡Êø]dÓ!¼]ÃÜÙòÜÚ>o‡ª€f€þstvnÈ-ámA˜SLÌž¯¿þ"…•m™ 31×SƒãÛul÷]‚Ý¥úq4nHb­{¯lí9j®´ j~ *qü"no/ôÔ%e² ¯¸ĘERE›E2¢‹‹ÓB–®ñÙ?›¹ˆÞxn¤9 F+šnnÙÔÞb1€pˆ>[¸fm†FŸ,ó)ŒO@ëûÏåß+Šº¹h™½ß3“Ý°¦cxXˆÜâ8DžðÅ£¦O뛑œ,àF!]êR‹™XQ³"¶®Báºì€óઘÏía å®]Å ä÷”%«Ev3A€Ã ±Ù `~ {¶ìXw¨lªálRýø)f:§©ôÆIöËAùûÑÐ=_Œc"|ö3ÈØ„‹¨±þ<ÃÞÑ~ÊI?„Cõ†ý·ìò½×ê”áñ1µ¯9¿îŽ¢v¨Ý­³eR¸H,«N+5å@*/òSP¢û“.ßp«£¾JÊYX&º¶šÀ&êu¶aÉ~·»CLN€ÔÊÅðX$–ÄJ88IÞ ’ˆaW]3³ZÏÂ|vÒ¹ë4¬·Sxr™7¢¨LH{/I<4¦ äË$=•ÄÎ~Ø Í:šåJY/ðG.ú“¤Šî5*>˜Ôð\ÀÓoZA³¼ßYz-}W²]ð^ÅêxWä‡ kAû.ȈD˜Å…Š(Ì-ÿ=þ¹DeßNMI6+Í̼×ÀdÅEçÖ÷ÍúX5dJX»<ªñÈ€³¸R$"ó¨)?êú@ìhW¥EÿÙõ@ž.eƒRu6¼ôÔi^kV‹LQ9nµ<ÿ òˆçV çVrÜÚ‘)ôGýªt®#+ªeZŠ´‘S+ñü×ÚjízøXºì>6"êŠä8r4l¥©ª¹B™ês³VH{CýnT|”Ÿõ|¦ö0 ?Ì1 4??‹ç}5okhDÍ2KB)±Í’I‡ú^s/ÒMÂGWO/Q/ÞÒºÙ.+Œ¯}¥új¶’F› Kú„Û)ÓcÀš™½ï‰FµOhSZs°ú>bÈíAsØsYKX¤KHS_â8å»NP1X+tT²À(}MÛ^fÑS“*|=T¨4NÀRÝyïöqîQ¾Sž?¥ÀÿÙ¯¼ýƒãÑþÞ’êQrÔ!õÕcuÎÇ­-w[²8lv®$FËlX*Tf)­|›:˜½³ÞÅ»JQú=D)O‰qréM»þ®êwdá9¹7«r=Bè'Kw–è¾ËÈ!ŸjÓ¨ßè8„” 8MDZw¾VTºÎ–/ˬ9+¦²&vÖã Km6Æš£”çɯŠÃVÀ|UÕ6ç1q¬R͸"¿€­‘ëÄÖL z,U'H@{wuÈ\£÷¿”§êQ¯!êuä”ý«"÷0ôç¢HþhÊWµä}êYºvlýؼ ƒ'MÛ,[H;G"¼Aþqåþq*>Ãb:ƒ)f³(Ö›[ÀºÙ-i[uÛ!ÓŽ@¼cíW*5w§WR¸ïö‘F´L3$ºaŠÏ†µA'ÏŠµÒÇ­½0­‚ w×è?#?³X¿Í÷l« -•ÇZkCIû5ÍO!ˆÃëC¡Mäüdß-g‚¤5¹)Û¿ÕrÓ•Yµß?Nº~ú,¦ÑFu!씧-"bã}zÑåD÷ÁÍ ë‘I4JŽ/PÉ&’cÔö}r¹pFìg¿LøTßå>§WZ³òÇ¥ã%—I yh¼|.J z*Ü@h,ÎÚæ<Ÿ1‰²ãHÖØW´AqCÕoÔÕŠ’Ú&',2$þ¢á¥¤5è±Öž¿n²mk …­×\ìÎ?!ÄýN^Býž ©FÈ “ÿ9LÕ–¾QËjT¤×û6Büí•kµýOz†H&öðÏvï¾t¬=ú€c•ª­Ñ#N>×®Ù¡:ˆÜÈ·]ݸà4Ünä ;ÝòºÐùÝO¥ èuv˜ž¸6%qOczt2ç'ýÂ~¥°Þ¯jM×Cõ¤úHt=l'| ë—Ûð‘ô:C_WóMF™xu}›iHm ;⇼²¾¸™îTl+áÍŒàLz;}AÕNquª)Æe5ÿÕôk€È§êŒW6+5âŒj­Rj<Ë.“ïRUL±ˆ×µ“ÙvßUb?©¯ \vYÿ|4¬û”ì¤äx·¦»>.>ñå5hÒã½ÜRŽL4¤Œ0Û×áIm-rê‘ïŽ4hßOH:ýõöÆY-ó0=46uT&–`Ëii´—…RŽø|†DF.Â×&»ï?R__K;å.bœ£7`‘T¼Ó< ¤È#?s´ÊÖž–ÎÛˆUòJªÀ3ëÎ/áN‘{ 3îÆ3•p¤{n‡Æô3¼äö4¾÷š¾c¨Z½aO_ou¸å® Ù±k³Døk‘ ±(É`ôvA$à¦M¨x*Ëd“omÇxg…zÁ¨_×êa:…‘ÞÝþMf,DÖNBµÕÚÂ5s2sûƒUAH,?¹AB•†ª*C,gT.†ïx'ÅP(àä>¾·AŒÊ×P–ˆªÈ»Î#y U@çV‰-*­µeq ß›½J¹œQÉs¢_0¨Ó®Á¢õûôeàþXËenŠd¾jÀ)-²[ërƒ‹[Íî‚vû‘»ÀVÃð¶Ú*µ—-Œ ô’™Ý¨g~gFq“ÔÆ KâJ‡ǼöÈi,%Gw&‘53UÒº×ùñ™B-<XRÈë‡Çú)C×Q`’“ ®)ã£iψò¬RMãsÔ4É‘Šzü€Üq€³ü¦Oj‚èÄŸ9MÚBË[ÊøœSήMa‹?O/±›Ù2¾•ø|SÑC†—k@#+°5­ò= ‘jQÛK†0§©˜-0+~ì]F¨ÿ9ò#EU—Á¬6š{±¡„m˜gBèU å­c_è¡’ÿS0/0Ý#n5„Æðe¨ºƒV]nØ,¸$H"Mb?xÂPÙ)ÆV.Ù³ŸýøÇ͵µ‘K×õgndϨpI!ùÛ#4¬r´`Ù©ú5æ2Ÿë[u¯Ä3ÃŒxƒvS‰ ŒÐ£SâeÊkQñl¿7ö6»D9X¢¬è0–=p»¸ú7–m´é-_Ý¥Ô“ {[ÄäÑäqÚæÖà÷QY8¦ ö8Ã{„ÆÁâÍÓð0’/¥¦ª{›!'J×øíØÐÊ ˆÔþi¦ž.^GÝópïÙŠ¢l™¢ƒñO¾¨[ôN›ùò×\®˜GÞ'TƒàÎnFt¤E4qòùö›ü¬Ñ–#½Üs]íq~Ð5¶©“3Š¿avš~¨è’€‚O÷'£eEøŒjc=‰“—¥Í?¿I´ÎW<ì OÒRYɸø¡º…=öe‹þ.*E¨VÜøPø@i‰´RÕ5Ÿ¤ìDzÛá÷sœá®|‘º ^Ï '“üµ qO´„k×+¶Ú+»ÇĈÀêp ®« é½S”º¥=ž]‰ÚCèÇ'š$Á©FI넶2kúÊÞÍ%ë¦òJ‹4Jƒ/cm=ºÉei½ëú÷d$ÎK^‹øÇ ühžÇ…È¥OEœR²Ë€|ÊPèõçš=Ínõ\è‹2¼/"÷-2|•"äcVÁ5‰MQ(ɇWí™ÊÇ(ª­?EˆU¬ÂÕ¢e#Ìy2 ×xËúÓ°JD}iîs3‰¸­H asôƒ¨™3±ëÒq€ò l#lT‰M 3¯Ë´*ì?÷£Üù8# ªœ‡_ë—­&Ѹ>R-ÔˆHön-{Äí~zó!Ô TJ0Hs¥ÀÒüƒI6gÃók³NœL9»›ûaÉã aäܵƒ˜Q}úzÑ‘Œëþ#[ÁxyjiçRöºßNc÷b½ÉÛÜÅ=("¥zŽ†Ú_V‡—ÌðvÖ…9(MEtRh˸÷‡Þƒ‹„®û#ߌk#[H<{£Ù=©3:÷-´­IKI‰uË.oE¨.0^¦}ÈV¸eîôerçÐ^ûn)_r.0ß²ò 4]·ÞŠ³•òýÐÔ‹ˆxmYë}15»™jÁŠXNnÁu48±&œ¼_GUÉ-xJá79øI$Êqö[ô¢N„¯‚Ôñ¯“Ž&¿mŒ´ ØYÉdœ†¤…Ÿ¬×ç]¥ù™{W*Å_BåaR¹=̾QãÑÚìUK6Þ…KåôB&Ò|9sáïqËòÑŠ6ò±IWvI=î /ÉcÚÐ3Æ_Ú±EG‚ß. öŒ4+Ÿ—!õ'˜í)5 ©/ÙVÏ»ëɽYõýª©…„»Äˆç·Õü™VÈ*·uˆtÕæ`1'…¤â¡`®«ŸÜÕ2êÇ^fÍ;v#¶^K.ÝÏ4™Ë2`‹·t¬èJóå묯k_cMßqåËLÝ.ÂH3^Ø‹¶[Fàƒ¯k{Ð@L]ò˜LªÌLâv*D‡Îûîâ•s+í‡X©­™Øì%*N‚[ûG† ®;¾J¹•õœÀ†*þv/T[u<ÕÁT÷ƒ ­áÊWÙL:kxbÊoôÖ<Ú'ºÏqŽ8ò˜°>ty£çÁðÙõ`’†Æ|ºSÿ|Ú¿ã"û˜öpÂbÆi›Pó°Ü]8”§@IÏûI(¥s w¾5JeKï4› N)ÓÀÛû .ÑDµh©¡`Ì(æ™CŠAïJék(T‚aƈÙ\¨VêæazIæµIEpZšÓŠ˜Vø\{huH§²1ïØÎgóÖª’À&ü-a#~ØÛÀ ÝzkÂzÿk%¿­êgoéÁXj#«— ?hl“¤XžƒrUêf­ðö¼€eÂ7¸G…EY æ¹|«MBF4ª¹?áq£Rì}Ž[ ´‚¤òL´#šÿšBeà€7Ìßcµÿž²‡=d&%lƒÿ+é1‘Õ”£&Æ<úÜ8}bÜ™ø–Q>³WîÅL=È€”pfÊî¡3¡fû.x©Õ®uh0òø ?ÿ“$Ú;ƒø „J_¿º«’§À:½×h1ÿP×è½íN݉9º5ü}.섥ə|:-3bfÂÈzAUTŸ5öšNð­ø‰RqP£Ä ‰¯‡ÊyÙÕèyä²o—EŒ1×D ϼEùOvÜ4æƒÈ½óh²µ‹Yó†zÄë×Y2AÕüæ³…|Яû¢±ÎÍ6¯ídß¾f&h› Dß6;î¼e¾+%¶Ýi$ØïD¹hºšô+Z¸| „”¸pºbíÄÈ@ñ âÁ]§¶¶ê“kðI+S¡7úiž3n^!Œ_W®~Q´Âò[齞ò‘¿ßVÍ¡#û•F7k™'fZö½Nâ¤A *]õ]mv –8Eq)½Åy¬P©0B(Œ#¥-K`&mžÝè5ú‹ùVH æØÎ23;m¢™{Ûø².³L¶vÇÐÕzéP]=IνG '1.‘ÜqL¯•ze(>òî©žÚèt–ÑÛ¸ÉOÍßDxD“%=Œ¶±mAßM$DAMž.ûŒ‡A:©Ä葨–XÛ£q¯¦2Òç衲¾ƒÞM{Ùê7£“$Åa<©]›v›_mz6 'ˆÃ£2®ÉÊœwô¥‡Ê×VXù>TÑ0Ö v­1i¾ëÓ«×èÖ»²Ä›Ëtk(ëßhR5ï´¶g5\ϣŋg¡a^ó aú±qò]à¾Ãçã×,…~µ£.©K$(oÍ|YTÔ=Åã„HPZÛ¬0ìò"?ëäÚå+Ü0KÖˆ…éçØcMº O”ΔË7yî}šMù®8‹¶8»º¸Y‡p‘0ž•ÙæJ™Z±Hæxþ‹ZD˜’ÚÓ'bév¤]⹄§P!Ä·„åõ£;X´”³å²– :@uÅL«Ã{’ÆFo¥ÞÈ7ŠÔ‚&í®çWL²kÅÆQ´—‹S¿´)8Y5vÝñˆÙ1‡lóÞàª)agÞr1°RE—9ù^®ÞS6ˆP¡HòG¤ZÛøˆÕ«ôŒ£¬p·!–)MÛ±}îuή¦=×~ŒÛ„N`ó—W¨ßB$×, ®¹¥ÃÔ•ZS["z]ÿ„¸› ñ M'ȨuïßÉ•nÜÿ@¼ùT¦©Žp8œ’ôÍò’ÉÚ×Î?áÞ|¢»ïýYΆ(fHU ùR=̌Ӵ&—Áý^äÊ y»D§‹;…›aeOÇÃpNÍŪw¶KÎÇ“€ÚrWv³Õ˜èòW‡ þuä zmö ¹Gv@[…È:a+Úí¾Òž…^k„ñuU~ƒŽ'¸oÛt_%’®$:ž ùUj%êæ€Ó_2Ïã½Þìdü¯øðÓÏo™ #Œ4ñ`ΧüB«ä¸y¦˜€–Z ±+±ùäÎÅTnæ IG5föâc¾Š°Kt²ûó>¿{yŸyèiÔ'0ã¸EáVÛ‡ù±JS’eÖ“uÞÌ…ï•ó-Í30p¼6:!ù}õ€RFSYXÉ*ËÞDüs—©gïaÖü 9”_1~ñØYÏÇÔéNë6¶ì¯?½"ÄSt½.ë·ËÌo py 9—Ο3> ê®.Ï{ëë\ˆñ”º™å9ùB\pWDrúì ¨™Œ‡>¶QF]m=êfxÍ@G(Aó]Ô™èˆT…‡‘ñjîä™ÏÎ/¬.hPòÜ ÿ\y)üáí݉ÌíI–ÌHŠÝƒÕšGÊΤd¡7V0ÁS» t¹± ^…‘ÌïŒñç+«—w’!GÄïwت1 p-ëGTÌm73B#,²*zv¢h Éñ© áRi.ã¢Þ_”c—–§blÝ?ÏØû³îIIYBl/wFçt&»ZOvoä˜)Þ~Ü#Ø};? Èx+]}\d¬0ÉxeÙ¼Lò^Eú­~/ ê•ä8ȇW£N`lqo”楗É=ny_æ4EÑ@KÓ.Èþö1ÎîÏÝd-=‹ÅôIåKÅ7b…ÅôWSg„JñƒˆçûWÌ7ðrÜZ܀ϒÙý‡s§cb§v?öàÚe¯_bMê^Ìñ»È”âMS· ëKœº‘Ó>+Ü-?õ‚” Cµ{°ri@WævÞáú™ošñ(…‚'…*Os«¿" 1‘~7wTü^³X—ºåÆîÜ_7Ç"ìÆðé€|[tX gO/O_š…[O(®CŠÛl]q¤‚3XXMx)m,Vw!ê'à9{W-¯(ÄÑE%«5`: xAjØZ<œjP—²¶½Í mOöj©Ä!›©oNvǵ.oIâ©Ð\湃?Í‹èžl•ãi{U9B‚¶Ê—§¦…ʽ?rx¯ÇóËT¥Øh%5Yéü†clÊ®Š‚¡‚ˆˆø™öÏV¬™Ùå0Èö»&}ÙÌðõ Ü'¹ Xd‡):ÿ…”A`ûëŽøf:æQÂ~ÖmÂ츠ËÿËô·%/%1™Ø_cUk<¬œKŸÈro/`wü‚¢i.q-Ö5ÔI€AíÊyîI‹¦…±JÕ²Øl}ëöFdk•(1ß §M 'ÌZN*=DhÉ´“HâåFô9„\ºÐ†|ŽúÂ×¾ › ð+Þ…«°ƒ éöŠËñ<êõÛPh_ ]òFþ˜ä™/ýö¶MV²ø€ìPÈÙ‡YÃÍ«ö>ÝãXçêÉ‚ý„)š}3³ÊÌRÑXÓF7zýŒ:èÉSŽ<ƒd6šhüj²V ß„+‰x©¥dæø^J gí˦”àËë.˜Œï½EIfèW»â3™KÓ Š+•“&k¸WÀ•mc/0bÚÖð¥@’ ˆF6'ä¼Uúˆ¤Ü‚,6ê ÷1Þ³X6 ;‚${:L[ U^¹\,!Èœ°ð+³¨©Š# Ã$V°ršÊåGÊv·­W%kà™ýCkÖ£«Îfʤ•&[¤âO9„›7Âγ² jåYÂôñµøøÇ'z²Gz^ÚÙøöZØÿ*¥dê›Ku°‹U”0Ç>úÔ#ÊUN{º-iœÿY« Í"qžþ¤Î“‚l'­*VÛ1»[UG‡ tЃM‘ªb _7™YúÖ¶¾öGö-‹‡ç zñ&5Áôj+F/mŒ>å"\óð®nv¾×Jž“ª½l@±ËûPEš¾1õmij›ˆîw§n5œz•89Íür¶òæ°Ü/Lº>‡au×ÙpÈ+¤eÁ7ófLS6ˆ%•´juZ.)Cõß^>±ŒNª:H:¶/,Ú¬Uàì19¸)84ùߨmâÚwÈSÝŽ¿ò¯r¼Ox·óMë)ZFMú™tÒ $K^Uw›€Øûóe¸…‡}Ä€‚ú ‹:§5ýðÒ\¿]ˆªc:ötiF‹Q)ÈHÁÆã5Ïù½4±\šiL¬É} Çf{E<Ð@LœKîºqåìÄê1ÌÒ_™umSûÓ·Z‘㽤ïIžaÀT4ño² 2ý$0Ãw²¢†z¯#ˆ‡š¬ú‡ÜÌ™zÃ<âý}€f§áªTÿV›}¤»^¥Mÿíh•Kw•²$G? hŽk˜K²çm¯KX„X´¹ªÐ}!Œ°2ÒV)sàå{Ò5ºB¬¨²YE¯s.u úàf¨‰?%ìç@µ Òžó™å#w¬e›îDLh“i¨YœÙ숚öºÖ+¥7ÂΖ$€}©Fi2QÆöx§jýÏpÖ4xº¯Áä«t¦‰‡Ô* î’QµXª¡ÄÍø]ÚÇ*é_g8‚/FšÄlSh2§Én's­o«¼5^A®~l 2Á½(z…-ÁVÏ{¶Øµ®šBÊÛ¢A-§ÊFí}Ò: ?å\ᢴ¡«­_s¥'µ¤>`²H\ûÊÌ}—]ûr«*‘9xìÑüñPáíÐþ¬Ö&ê‚,»¢ÐíÚ]ªJ¦†°M×7Íu=µ;ÀÓR[©¬BjtŸ èeA ]q2”›$ѱˆ›øœ®EtéÇnŸÒÃøIYyÀl{}ò‡to“)¡Ó³ñ,—k2ü£Í¡TÄ ñW´eµå=¤ÓB(äiVâ ÃmTÁ>V rŸ3 ©•4"Ù‚pç/d{Çà í˜mž¶õµˆªMËHà>Oû+Å=ÕíœyÐý«3ËO¤f?Ÿøª¾R]ÄZSŠ¡ë¾›k«„8ºçRÑ»OQìQÁm¿ Å?ê£Éd@ç%‚¼ Û‚Ÿá˜OíÚ{ «<õ“vû3´ÏtˆHçfT—¯vvñ‘ªe‰õÅ»áBxèôº,fxó.\¹Ç6.øUcþïOÐÏ0I£FöéÙNr ?Q*äÚ(fÿ#rŽsc»ñ¸œQ9}éʼ †®»Ë7óc$)Ôåý¹a \…6 k~S_“%ðw@öç\<Ä>ßIƒTè ·D»”’‹‘eãÊÐçšDà$ªžqìM›/ üä“iT®ŒA+^¬ãÅwûl©Ÿ/se_ú2†Æ£EÞC$ɇ7w ô’zñWÇ}Ñv¤xÅ&ù~•³‹§”it;yƒŽ¯ì²K¦…†‚rþ5ÖãTY¤ÁéNº«uum„±ó™g9°í £}ËÐ-w„s²¦á‚¹•–‰‡tI·q·j=n‘»!_KØxÚYï{º}¨G«¾ÈÛÙc!Uwê¯áŠ,ÇcxZ+UcußÔðÖÂá¾ZÆ¿_æ“ #€Lœçò2ÆåÂÐÏÒDF_þ´? –…í ½ÎšvÙ %È웶AÉ×îÒe~½:’Pû6B2ÁX©öz{žòÍ=’ûóa ©k†w‘›+UáÈÝžßð!«'¢ëÓÌ ¢7B7¯¿±CÂ_¶Ãœ¬µâñ>ÎQŸÅö‹¢u{F_¿›œqñ8¯q3~¯W*¼f»¸8Sª‰B³ýr˜Š‰ûrøìnû“¡Ža*ùÒ4zÔòMï9ûdE—ÑrD›H¹U•«¯§ù¨^9^M GwqeÑ*V†G4Šï,³xš/…´Sˆv|Þ²—Œ ÛÿáÒÿOðÿDS ±“‹½­±“5ÒÿõZ>Y endstream endobj 64 0 obj<>stream xÚíRkTTUf2B‡Ÿy@P‚æ  ¤<“QÊ R^fÎŒw÷Â;ÃL¦Œ†¹aÀPPÁZJš—¦ !’øL呆/ª…«”—  v¬ý¬_­ÎùsöÞßþÎw¾³]£cb<†áÉà09~ 8"6Öp˜lº‹K0ű„„~€ãëËj)ð`ÏÏÓËãAwÁxŠŽ@¥ëIàüÖˆ•@E"r=TR"Dbq I* f¬Cb  (fÒ9 FE$H†R£³Æ…cð&ÒbuÊË’*Jp¥D¾(‰bSè€Jè¬Hœº RJþ Q“ÉÃÔ E$¢£3éoeD‰*t¿peŠš„ˆÀÅÀ&Cãᄶ(FÕÊÉÕpQ ¢@Lª€€=‘BUa¨Š£QR´H… Žç!&ž,‚òm\+D¸,Xà>ñŸãµhÅÈ8]ʬcàñ˜ógL¹C ZÈf²Ù Hí—§¤Iw…b"\ŒbÔ@p½BˆŽNMqžPL µj)Á,&†“T  <Éœ }§`ÅŒ¥èBP®Õ3¼¹€áÁ¥8ÙÞ€çÍÉø+p†¦ªaxà²ÙlöÄ#Dj‚€9>4”=/c J™ ¡Šèí7q³¬ðäG7„–]9dîF ’VåFž8{ý´¥¡-¦ø¬eyªÛãÂgEvӻͻ¤8¨¶J_Ùöë¦ÔÜ7F»5뺋>¨qöEè¦8=5ôX×ü®ÿ—uíη Ê¿Ù󸩧4Ú5$îG‹ïÍê5_Õoöæ Ê«²¶_äéc³3õàV¯¬Ûi6ÆWo_6leM­vï|‚ŸRÛ>+›º/tmÿÏ×–&Î ÏÔ ç'“Û±BŒôŽ%ñ)jçUȼÙRcÏ0ýoßlÙ;ͦ›þŸd û6-Zf÷L×ðÞ–/vœ·¯ƒõýåÄ#‹ º#Þ½,³5Û" ÞJÎÛ½PM«rŸ|­lq2¿íøœŸ¼Šõ *âÞóE;Co¤ 8³ì%¯…Ì»Ø( =\n¬´°îk›Jë|?¹n”Ïú:`¹:oÄ[à?Ũ´òæUò/:©š»ÌepDú§!4»ÞÅ4óÅý¼ºZ‡5w†’j×¼+ÁäV!ë{£#ù•ž*Ñý–úyÇæ¼74×$q_פÚÆZœéf¾®.}êá a wÁ§5Ó•«Ï?ï’mÜݸþ93·9ê€"ù[ý™fËö¨µò³¿\ ñ,/[}íjR³Þëè®R³hÖª2†J/fí-œg*á–Ó‰†8dùR³<ó8rdäÁ¨vpo¹´z.»IÈ©ßøqq…/ÉW+âî§Å‡lÈv€±âœ³¯üË^ߌŠ·W* \îlýJÀë®Gêv¤/¤½]8?$âjcÃéŒKs²Ã.ç4XµÔdçn°âó³gw>‘Ô.mÕZÝ›•Øûfù. /§‡‚i? òD•ÂL[–|i¸Õ¦Xÿ£wQé}FTbRÒÌmí>»´WË~Ô}(2`¶yBójÏ—Äç,+U·œ‹-‘ø£ÌQ«L3ùŠþý¦ŽÊêôÖ Oé°]N—‘uúú­3šŽjX;™úʃét+øÁÞ#«IM#,_6‚XèÙž‡âtgÖ¶ÇTÞ- N¿ÔÚ¸¤nÑŒ¤‹´½=œOqGÇ.Ó7ÐëßÎ{gû‡ûÔóÝ‹wÉ·y&ƒªt0LWný“žû¸=2ÁpôÔLXÓuÏ«÷JvfdZ® ǾÕ_ÝfJ~ñàáÙÅE~6Ü7·¥ìÜþ…Ù`ÿ4Õ|CcàõŸRó·î_`%ï˜m=жm¨€O›ÒëûÌb÷𬺴®ÞKY'N‡·8V[4Ê[JЄêÞÔ¿™¶¹$º¯TyìCkiX•ƒèó2›Çú=¡ÃkòC3O<õ¾0ô˜?ìpc†1!í]ŸZÇeÕ8j>Ý"îvkïþáJUKÜ!å.ÛóU9™Oò;uA÷ hùßí–úæV\:r®¯ù‚,ƒ©ù2‡‡ÙÿpÑÿ'øOˆ!H\‰rúos]k endstream endobj 65 0 obj<>stream xÚÔZmsÛ8þ÷øñ:7=ˆER3;I“¶Iê¼l’¶éöòA¶i[[Ùr%¹i÷×@Y¶¨Øq’öºsãÐ)¾€$€€‡,`±d‚‡,ŽX(ñG1¥ ‹5Ó1þÆuÌYc3L„Z!Á™ˆ„`ÂpDÈB."$$ ÃœR)"“Žà8@’:&¹¦–˜IAÃyÀdH8g2ŠˆL*ƒ};K"$‹¸ÂÕyÄ"=W‚=Ž!Z$ nܳÓdjáäýùÕÙÙ¿öO.{<€×Y2.™„ËÊNßã©Ã~2?´éxR1eB¸^Ò2ä°Wì ›c ¶¦Ÿs¬UI–öfcdä9N0IŠK[ý†y–%üe‹ª[,“ÂZ؇8‡KÀ,Œ` )Ì ‡Êg/^ম¾Ï­ã^Íù07ÊíïeRZ÷¤³‡´(+Z/zÉ’Æk‚ËE¿¢éhNî&%΋t^å‹C7é‡tXMJ2¬½xñ)³ žô‘$NA¼¬…‘atsÍÓ¥¡Ý»ýŒ>å_£ôj”*â¡´a*Â6-ëñ((K$¤Ô[i× Ç¢Pßn¬ ·®B³-­å‹F)n¯L¿A‰ûœ³,0K±ã §s.í4­):!°_I†Çd\vušT°/y¯á ÂÃ[èÁ œÂZ—ßá-̼ƒ÷ð®á#ü‡› >ÛÊí©dÍê²µÙß Mi1XLa1â© òÂÖÇâÆ%ÐoÙ­ Z®?á3d0ul_ÈŠA ø ·ð ¾Ã_n»\µ¨k­Õª4Z¦(™eZzWH–þ=Ë«¡1®¨/ö)’‹0Ê×SéðÿJ’›Ãa<ÖÍ&nœ‚¯á/êÀŸDôC@#6›  ~“ãŸòÀóà‡Í+ðBx଱o¥w²mҧǫÑVíبk…X«ÃG_<ñß!ÝÙ~FXlÃÂú }oï³B>òˆ”Üò”œ07W¤vᯔ®ý†èõÕ+ ‡ÁjŽ†Ÿ0XäÍ6—Cø`upÖ;¹¸ É9òÀŠ‹6X‰ûÁŠüÕ¶Ï5>‡Ãöú»ÁúuÛ®âûQ›£™gsû}½ýïàëmçcGOùUGù¹ çW* )â–þwnÑ×ó£Î/—k 0J7+½¯émµöøxƒú¶U÷ Xô¬c5uçàеl‚Ñ zôŽß¾Äs»Ð?;dhYÍG;ÝÅ…j¹£@_aqL;2Ý©Ÿ·£Ñˆa”íô­¶bA'|rçÑ–”ÚÐûròáñÒAÖ\a¬ÅuyüG 5“,sŠ? F°Ôbh*œ£@¹þnÊV<ˆ).¾1uhŒa•‹ÖèIhêøF9Ä Z‹ú` ­6qO#é Ý|¼i!Çv”Z¬~C2.ËvÇ:Õw´Á0ÝÍò9µKŽÆù´á¦¦_,7ŸÐY`(7 z{û‡G§NbU ¤YãO¤wÀü`I­b^Šw–‡rêéÖ)ù#Â:Êãx¬F«¸n­î¦kÀ‚Æ€Åݬ‡wxžº£‚ÿÝìA·ß¶ÀO»ý ôÔÜ=RtŽ4"OuDFxm$íô.¯Žœ'}¿ý1Gz§ÿì[Ë gï¼åý¥E${HÖâ•G[{²+{´¶N¾Å :Öë®ë¶Ügãvüu6QÁ>7ÛW¤êå^ŸtñÑQ[ueðÕå‘'g\m3ÞEêh¥º]¤öyò%-ü™.ÛF!{íЕÕÇTBÔ»±Ñm-M2DXã'ß½öb&¥kìk2y„r*ï“SÒÚ•†Eý8Š ÅF’Ê3âlÔ ‚a:îÈÒÚt{Úaz$ø3{¾qØœžÝ-F£ÐÏìu$™Ç> ÇçöŽ~GNüxMµDéûY>^Šÿ}r1›OPÎhÌØÍ2t³Øº3G€¡–ÊÍ›æøõ9™ÏÈê%¦ ˜-à)“A‡«’,– ÎqÁ¬Bî]Î^ÏÉq$§¡¼Ëi¯sD¤UŽf£uC?¯Ö Ng¼.®Åë3ÉóÏuÓÔjM«Š4!¥ôk®'ájž Ëê{fÉƯh´õkšlþªF¶]Aü]U‡×4áñªælǪFø¼ª,ñ¥öФÔIš&SV5JUi’ Qž”£e ºIµ(’ J”Ð9®²(ú6Ëo•ôst$²Z@Ÿ”Ž¼›½»µ©Eå(ÜÓW;@¹‡*µ$¿ ùkÅ÷uOQ‰.&5/Ñi:˜Ô±.>(‰Ÿ JtI)Z›ßã7{g½Cg|ã­oU¢]–Ïw¿E¸3SõãyŸ‡ä¢º9¯‡å‚¿3[å÷ôrW*ì¾·%w›°XÐ[ã¶Ày—êË›üÅyë_üæÇ·¤w³b?/¥ýŸø/lV/k¶†iºù¾}pz…×tÔy§©Ût`î×>­ÛʧͽŽO7P<¸Þ;ܧH÷ò²í{™VžÚìJS ÿ¥ªÐKíWÆøò{çÿ7> ·ÑŠ·S¯_~®ÛŒÖp%ÁR>6¿ØzW¦c'Oß^CýŒ>oßßá#ï¨Ìò¿þ+ÀH š endstream endobj 66 0 obj<>stream xÚ””»n1 EEe¦Ñ’`¸J— Eª$ y¸XÀvŠµÿ?ä,’ŒV22)æÁ3w¹—%, aÁ„Õ”´DX’šø““QÄ’L#ÖT1bKUØŸ5ÕÖüÙRcR«³§ƒ€üÅ‚”„HAüB âù³ú‹ø¿³y&VâÆkn'‘‰`|Bq‰Àâæ™5ªϬÄ3ñ̶ =°VÓÍÍáÝéÇù…Cúxw{ëäÃ×ÇûóñÍùþûóéçSÆ%úá_ÿX¢5 ÷ˆ–hØÑŽ”%š¸%¼D;·D–hì–è-Þ[¢Ù[R—èú–´%Ú¿’—o D}Ì#v¯,#vì#v×l#vë\GþÛ5æp"peÅ8b7(4b7(eÄnP†*uÍ-#ŽÜC•¶ªmÄ¡^«¼;¼?=žž»á¹–^fìíuýÉáÓç/¾jöíÑš®an€ééåáá·ø²¶ƒ¶i–&€Ú‹e&Vð&4àb&ËZ°ub›jÁWΣuZ,S±Rò×>1ÁTŒ’}»õÍ ifÊÕO­ÒÛ¸lÝA\1l€OJ'ž6£´– ø™òï51Ô Þ Þ³€ÜÜ6@ÚÑ:2ÍÕ=÷‰QÿÃÅ\,¾Ø• îŒÕV@Þ!&¨™½>Ы-ìû®°îXíW œ‹‰8 âõ„’Î'4F£J/nÓM¥5“íS-Ù´ÈŽ¡{¥À¹X”3©\Û˜‹ÃFme°1=Ž¸ø!Þl“ù—#ò endstream endobj 67 0 obj<>stream endstream endobj 68 0 obj<>stream xÚ”PËNÃ0ü•½59ïÚyµª"¡öVª’*â&.  :rUý{;€„8Àeg=š™™â P‚GHd9p>¾BX­ØZ g”±m[÷O£aï ùˆÏ¬¸v’íÊÙçù—+ù4e^ìfäfê™)Mü ±SËñ®k¹ÿ-Ó9¹àÂÃD:þïT{§ïM…=y2¦¿¤Þ«zSl–1Á”#%1qšc:Cœ…l­eiZuþVÙÿhu„xYÑšwL:¥ƒ»²piM½¬µÙ9ÝÃ<ÿ`ù¬ˆ endstream endobj 69 0 obj<>/W[1 3 1]/Type/XRef/Index[0 164]>>stream xÚbb&FFƳ L Œs@¤˜½D2€E„YÁ"{j?‚Ù—ÀjæHÞÏ`ˆ9`>E°ì)„ÿLÉe"™EâKÀì#H*=Àì­óùxÀ"jx¢Áì‹5ü¿ÑÝ p,{I×b°Èn$wN‘¬ïÁ®ÚgøfïFòc=˜½¡—IÌ^"EÀöê Hw°ze©%"Å|@&KŸ±Ù—‚ÕƒÝ̾DrN»Â|SÁ&çcçï’6°½Ì8H0ÉÀˆN2ÿŧ‹<xp¨$ã¡äZ¦'¸d xÃ2“ endstream endobj startxref 116 %%EOF R.oo/inst/WORDLIST0000644000176200001440000000121514554071374013247 0ustar liggesusersAchim AppVeyor attachLocally BasicObject classinfo clearCache clearLookupCache CMD conditionCall conditionMessage conveniency cut'n'paste DSC finalizer Finalizer Friedrich getCall getCalls getEnvironment getFieldModifier getFieldModifiers getFields getInstantiationTime getLastException getMessage getStackTrace getStaticInstance getWhen hasField hashcode hashCode hashcoded Hornik HOWTOCITE http instantiation InternalErrorException Leisch macOS msg MyClass nonStructure objectSize oo PkgA POSIXct POSIXt pre Pre printStackTrace RCC RccViolationException RData Rdoc RdocException reentrant rethrows Rethrows simpleError subclasses th UseMethod Zeileis R.oo/man/0000755000176200001440000000000014711170612011642 5ustar liggesusersR.oo/man/Non-documented_objects.Rd0000644000176200001440000000714114711170562016530 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 999.NonDocumentedObjects.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Non-documented objects} \alias{Non-documented objects} \title{Non-documented objects} % The BasicObject class \alias{getInstanciationTime.default} \alias{isReferable} % The Class class \alias{forName} \alias{getDetails} \alias{getKnownSubclasses} \alias{getMethods} \alias{getMethods.default} \alias{getName} \alias{getPackage} \alias{getStaticInstance} \alias{getSuperclasses} \alias{isAbstract} \alias{isBeingCreated} \alias{isDeprecated} \alias{isPrivate} \alias{isProtected} \alias{isPublic} \alias{isStatic} \alias{newInstance} % The Exception class \alias{getCalls} \alias{getCall} \alias{getLastException} \alias{getMessage} \alias{getStackTrace} \alias{getStackTraceString} \alias{getWhen} \alias{printStackTrace} % The Object class \alias{attach} \alias{attach.default} \alias{attachLocally} \alias{clone} \alias{clearLookupCache} \alias{clearCache} \alias{detach} \alias{detach.default} \alias{finalize} \alias{getFields} \alias{getInstanciationTime} \alias{getInstanciationTime.default} \alias{getInstantiationTime} \alias{getInternalAddress} \alias{getFieldModifier} \alias{getFieldModifiers} \alias{hasField} \alias{load} \alias{load.default} \alias{novirtual} \alias{registerFinalizer} \alias{save} \alias{save.default} \alias{staticCode} % The Package class \alias{getAuthor} \alias{getBundle} \alias{getBundlePackages} \alias{getChangeLog} \alias{getClasses} \alias{getClasses.default} \alias{getContribUrl} \alias{getContents} \alias{getDataPath} \alias{getDate} \alias{getDescription} \alias{getDescriptionFile} \alias{getDevelUrl} \alias{getDocPath} \alias{getEnvironment} \alias{getExamplePath} \alias{getHistory} \alias{getHowToCite} \alias{getLicense} \alias{getMaintainer} \alias{getManPath} \alias{getNews} \alias{getPath} \alias{getPosition} \alias{getTitle} \alias{getUrl} \alias{getVersion} \alias{isLoaded} \alias{isOlderThan} \alias{showChangeLog} \alias{showContents} \alias{showDescriptionFile} \alias{showHistory} \alias{showHowToCite} \alias{showNews} \alias{startupMessage} \alias{unload} % The RccViolationException class \alias{getRccUrl} % The Rdoc class \alias{argsToString} \alias{check} \alias{compile} \alias{createManPath} \alias{createName} \alias{declaration} \alias{escapeRdFilename} \alias{getClassS4Usage} \alias{getKeywords} \alias{getNameFormat} \alias{getObject} \alias{getObject.Rdoc} \alias{getPackageNameOf} \alias{getRdDeclaration} \alias{getRdHierarchy} \alias{getRdMethods} \alias{getRdTitle} \alias{getUsage} \alias{hierarchy} \alias{isKeyword} \alias{isVisible} \alias{methodsInheritedFrom} \alias{setManPath} \alias{setNameFormat} % The RdocException class \alias{getSource} % Trial functions \alias{callSuperMethodS3} \alias{callSuperMethodS3.default} % Deprecated functions \alias{setClassS3} \alias{setClassS3.default} \alias{getClass.BasicObject} \alias{getClass.default} \description{ This page contains aliases for all "non-documented" objects that \code{R CMD check} detects in this package. Almost all of them are \emph{generic} functions that have specific document for the corresponding method coupled to a specific class. Other functions are re-defined by \code{setMethodS3()} to \emph{default} methods. Neither of these two classes are non-documented in reality. The rest are deprecated methods. } \author{Henrik Bengtsson} \keyword{documentation} \keyword{internal} R.oo/man/getSource.RdocException.Rd0000644000176200001440000000144414711170563016646 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % RdocException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getSource.RdocException} \alias{getSource.RdocException} \alias{RdocException.getSource} \alias{getSource,RdocException-method} \title{Gets the source of the exception} \description{ . } \usage{ \method{getSource}{RdocException}(x, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns the source. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{RdocException}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/print.Exception.Rd0000644000176200001440000000207414711170562015231 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{print.Exception} \alias{print.Exception} \alias{Exception.print} \alias{print,Exception-method} \title{Prints the Exception} \description{ . By default the \code{as.character()} representation plus the stack trace is printed. } \usage{ \method{print}{Exception}(x, ...) } \arguments{ \item{...}{Not used.} } \value{Returns nothing.} \examples{\dontrun{For a complete example see help(Exception).}} \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:as.character.Exception]{*as.character}()}. \code{\link[R.oo:getStackTrace.Exception]{*getStackTrace}()}. \code{\link[R.oo:printStackTrace.Exception]{*printStackTrace}()}. For more information see \code{\link{Exception}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/getSuperclasses.classRepresentation.Rd0000644000176200001440000000132314711170563021340 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % classRepresentation.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getSuperclasses.classRepresentation} \alias{getSuperclasses.classRepresentation} \title{Gets the superclasses} \description{ Gets the superclasses. } \usage{ \method{getSuperclasses}{classRepresentation}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \keyword{methods} \keyword{internal} \keyword{documentation} R.oo/man/getAuthor.Package.Rd0000644000176200001440000000241014711170563015427 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getAuthor.Package} \alias{getAuthor.Package} \alias{Package.getAuthor} \alias{getAuthor,Package-method} \title{Gets the Author of this package} \description{ Gets the Author of this package as specified by the \code{DESCRIPTION} file. } \usage{ \method{getAuthor}{Package}(this, as=c("character", "person"), include=c("given", "family"), ...) } \arguments{ \item{as}{A \code{\link[base]{character}} string specifying the return format.} \item{include}{A \code{\link[base]{character}} \code{\link[base]{vector}} specifying which person fields to include if returning a \code{\link[base]{character}} string.} \item{...}{Optional arguments passed to \code{\link[utils]{format.person}}.} } \value{ Returns a \code{\link[base]{character}} string or a \code{\link[utils]{person}} object. } \examples{ pkg <- Package("R.oo") print(getAuthor(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getRdMethods.classRepresentation.Rd0000644000176200001440000000150114711170563020553 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % classRepresentation.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getRdMethods.classRepresentation} \alias{getRdMethods.classRepresentation} \title{Gets the methods in Rd format} \description{ Gets the methods in Rd format. } \usage{ \method{getRdMethods}{classRepresentation}(class, visibility=c("public", "protected", "private"), trial=FALSE, ...) } \arguments{ \item{visibility}{-} \item{trial}{-} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \keyword{methods} \keyword{internal} \keyword{documentation} R.oo/man/save.Object.Rd0000644000176200001440000000322214711170561014276 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{save.Object} \alias{save.Object} \alias{Object.save} \alias{save,Object-method} \title{Saves an Object to a file or a connection} \description{ Saves an Object to a file or a connection. } \usage{ \method{save}{Object}(this, file=NULL, path=NULL, compress=TRUE, ..., safe=TRUE) } \arguments{ \item{file}{Filename or \code{\link[base:connections]{connection}} to which the Object should be saved. If \code{\link[base]{NULL}}, the Object will be save to a file named "\{class name\}.\{memory location\}.RData", e.g. "Object.26979608.RData".} \item{path}{The path where the file should be saved.} \item{compress}{If \code{\link[base:logical]{TRUE}}, the file is compressed to, otherwise not.} \item{...}{Other arguments accepted by \code{save()} in the base package.} \item{safe}{If \code{\link[base:logical]{TRUE}} and \code{file} is a file, then, in order to lower the risk for incomplete files, the object is first written to a temporary file, which is then renamed to the final name.} } \value{ Returns nothing. } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:load.Object]{*load}()} and \code{\link[base]{save}}(), \code{\link[base]{load}}(). For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{IO} \keyword{internal} \keyword{methods} R.oo/man/print.BasicObject.Rd0000644000176200001440000000172414711170612015440 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{print.BasicObject} \alias{print.BasicObject} \alias{BasicObject.print} \alias{print,BasicObject-method} \title{Prints a BasicObject} \description{ For all objects of class \code{\link{BasicObject}}, this method will print the value of \code{as.character()} of the object. Note that this function is not called if the argument is not an object of class \code{\link{BasicObject}}. } \usage{ \method{print}{BasicObject}(x, ...) } \arguments{ \item{...}{Not used.} } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{print.default}}() For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/showDescriptionFile.Package.Rd0000644000176200001440000000156014711170563017456 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{showDescriptionFile.Package} \alias{showDescriptionFile.Package} \alias{Package.showDescriptionFile} \alias{showDescriptionFile,Package-method} \title{Show the DESCRIPTION file of this package} \description{ Show the DESCRIPTION file of this package. If the \code{DESCRIPTION} file does not exist, an exception is thrown. } \usage{ \method{showDescriptionFile}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/trim.Rd0000644000176200001440000000145014711170564013112 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % trim.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{trim} \alias{trim.default} \alias{trim} \title{Converts to a string and removes leading and trailing whitespace} \description{ Converts to a string and removes leading and trailing whitespace. } \usage{ \method{trim}{default}(object, ...) } \arguments{ \item{object}{A \code{\link[base]{vector}} of \R objects to be trimmed.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{vector}} of \code{\link[base]{character}} strings. } \author{Henrik Bengtsson} \keyword{character} \keyword{internal} R.oo/man/getDate.Package.Rd0000644000176200001440000000164114711170563015047 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getDate.Package} \alias{getDate.Package} \alias{Package.getDate} \alias{getDate,Package-method} \title{Gets the date when package was build} \description{ Checks if the package is loaded onto the search path or not. } \usage{ \method{getDate}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ \code{\link[base:logical]{TRUE}} if the packages has been loaded, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ pkg <- Package("base") print(isLoaded(pkg)) # TRUE } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/load.Object.Rd0000644000176200001440000000424014711170561014260 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Object$load} \alias{Object$load} \alias{load.Object} \alias{Object.load} \alias{load,Object-method} \title{Static method to load an Object from a file or a connection} \description{ Static method to load an Object from a file or a connection, which previously have been saved using \code{save()} of class Object. } \usage{ ## Static method (use this): ## Object$load(file, path=NULL, ...) ## Don't use the below: \method{load}{Object}(static, file, path=NULL, ...) } \arguments{ \item{file}{Filename or \code{\link[base:connections]{connection}} from where to read the Object.} \item{path}{The path where the file exists.} \item{...}{Not used.} } \value{ Returns a reference to the loaded Object. } \details{ Please note that no constructors are called when an Object is loaded and neither is any static class code called. } \section{Type control}{ Typically this static method is called as \code{$load(...)} where \code{} is any Object class. When an Object has been loaded, it is verified that it inherits from \code{}. If it does not, an exception is thrown. Thus, \code{Object$load(...)} will load any Object, but \code{MyClass$load(...)} will only load an Object that inherits from MyClass. If loaded object is not of correct class, an exception is thrown. } \section{Troubleshooting}{ Due to a bug, likely in \R itself, one can not specify the \code{file} argument by its name, i.e. \code{Object$load(file="foo.RData")} will not work, but \code{Object$load("foo.RData")} work just fine. } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:save.Object]{*save}()} and \code{\link[base]{save}}(), \code{\link[base]{load}}(). For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{IO} \keyword{internal} \keyword{methods} R.oo/man/Package.Rd0000644000176200001440000001634014711170563013475 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Package} \docType{class} \alias{Package} \title{The Package class provides methods for accessing package information} \description{ Package: R.oo \cr \bold{Class Package}\cr \code{\link[R.oo]{Object}}\cr \code{~~|}\cr \code{~~+--}\code{Package}\cr \bold{Directly known subclasses:}\cr \cr public class \bold{Package}\cr extends \link[R.oo]{Object}\cr Creates a Package that can be thrown and caught. The \code{Package} class is the root class of all other \code{Package} classes. } \usage{ Package(name=NULL) } \arguments{ \item{name}{Name of the package.} } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{\link[R.oo:as.character.Package]{as.character}} \tab Gets a string representation of this package.\cr \tab \code{\link[R.oo:getAuthor.Package]{getAuthor}} \tab Gets the Author of this package.\cr \tab \code{\link[R.oo:getBundle.Package]{getBundle}} \tab Gets the Bundle that this package might belong to.\cr \tab \code{\link[R.oo:getBundlePackages.Package]{getBundlePackages}} \tab Gets the names of the other packages that is in the same bundle as this package.\cr \tab \code{\link[R.oo:getChangeLog.Package]{getChangeLog}} \tab Gets the change log of this package.\cr \tab \code{\link[R.oo:getClasses.Package]{getClasses}} \tab Gets all classes of a package.\cr \tab \code{\link[R.oo:getContents.Package]{getContents}} \tab Gets the contents of this package.\cr \tab \code{\link[R.oo:getContribUrl.Package]{getContribUrl}} \tab Gets the URL(s) from where this package can be installed.\cr \tab \code{\link[R.oo:getDataPath.Package]{getDataPath}} \tab Gets the path to the data (data/) directory of this package.\cr \tab \code{\link[R.oo:getDate.Package]{getDate}} \tab Gets the date when package was build.\cr \tab \code{\link[R.oo:getDescription.Package]{getDescription}} \tab Gets the description of the package.\cr \tab \code{\link[R.oo:getDescriptionFile.Package]{getDescriptionFile}} \tab Gets the description file of this package.\cr \tab \code{\link[R.oo:getDevelUrl.Package]{getDevelUrl}} \tab Gets the URL(s) from where the developers version of this package can be installed.\cr \tab \code{\link[R.oo:getDocPath.Package]{getDocPath}} \tab Gets the path to the accompanying documentation (doc/) directory of this package.\cr \tab \code{\link[R.oo:getEnvironment.Package]{getEnvironment}} \tab Gets the environment of a loaded package.\cr \tab \code{\link[R.oo:getExamplePath.Package]{getExamplePath}} \tab Gets the path to the example (R-ex/) directory of this package.\cr \tab \code{getHistory} \tab -\cr \tab \code{\link[R.oo:getHowToCite.Package]{getHowToCite}} \tab Gets the citation of this package.\cr \tab \code{\link[R.oo:getLicense.Package]{getLicense}} \tab Gets the License of this package.\cr \tab \code{\link[R.oo:getMaintainer.Package]{getMaintainer}} \tab Gets the Maintainer of this package.\cr \tab \code{\link[R.oo:getName.Package]{getName}} \tab Gets the name of this package.\cr \tab \code{getNews} \tab -\cr \tab \code{\link[R.oo:getPath.Package]{getPath}} \tab Gets the library (system) path to this package.\cr \tab \code{\link[R.oo:getPosition.Package]{getPosition}} \tab Gets the search path position of the package.\cr \tab \code{\link[R.oo:getTitle.Package]{getTitle}} \tab Gets the Title of this package.\cr \tab \code{\link[R.oo:getUrl.Package]{getUrl}} \tab Gets the URL of this package.\cr \tab \code{\link[R.oo:getVersion.Package]{getVersion}} \tab Gets the version of this package.\cr \tab \code{\link[R.oo:isLoaded.Package]{isLoaded}} \tab Checks if the package is installed on the search path or not.\cr \tab \code{\link[R.oo:isOlderThan.Package]{isOlderThan}} \tab Checks if the package is older than a given version.\cr \tab \code{\link[R.oo:ll.Package]{ll}} \tab Generates a list of informative properties of all members of the package.\cr \tab \code{\link[R.oo:load.Package]{load}} \tab Loads a package.\cr \tab \code{\link[R.oo:showChangeLog.Package]{showChangeLog}} \tab Show the change log of this package.\cr \tab \code{\link[R.oo:showContents.Package]{showContents}} \tab Show the CONTENTS file of this package.\cr \tab \code{\link[R.oo:showDescriptionFile.Package]{showDescriptionFile}} \tab Show the DESCRIPTION file of this package.\cr \tab \code{showHistory} \tab -\cr \tab \code{\link[R.oo:showHowToCite.Package]{showHowToCite}} \tab Show the HOWTOCITE file of this package.\cr \tab \code{showNews} \tab -\cr \tab \code{\link[R.oo:startupMessage.Package]{startupMessage}} \tab Generates a 'package successfully loaded' package startup message.\cr \tab \code{\link[R.oo:unload.Package]{unload}} \tab Unloads a package.\cr } \bold{Methods inherited from Object}:\cr $, $<-, [[, [[<-, as.character, attach, attachLocally, clearCache, clearLookupCache, clone, detach, equals, extend, finalize, getEnvironment, getFieldModifier, getFieldModifiers, getFields, getInstantiationTime, getStaticInstance, hasField, hashCode, ll, load, names, objectSize, print, save } \examples{\dontrun{# By defining .onAttach() as follows in zzz.R for a package, an # instance of class Package with the same name as the package will # be made available on the search path. More over, the code below # will also inform the user that the package has been loaded: # # > library(R.oo) # R.oo v0.52 (2003/04/13) was successfully loaded. # .onAttach <- function(libname, pkgname) { pkg <- Package(pkgname) assign(pkgname, pkg, pos=getPosition(pkg)) cat(getName(pkg), " v", getVersion(pkg), " (", getDate(pkg), ")", " was successfully loaded.\n", sep="") } # The Package class works for any packages, loaded or not. # Some information about the base package pkg <- Package("base") print(pkg) # [1] "Package: base v3.6.2 is loaded (pos=14). Title: The R Base Package. # The official webpage is NA and the maintainer is R Core Team . The package is installed in /usr/lib/R/library/base/. # License: Part of R 3.6.2. Description: Base R functions. Type # showNews(base) for package history, and ?base for help." print(list.files(Package("base")$dataPath)) # Some information about the R.oo package print(R.oo::R.oo) # [1] "Package: R.oo v1.23.0-9000 . Title: R Object-Oriented Programming # with or without References. The official webpage is https://github.com/ # HenrikBengtsson/R.oo and the maintainer is Henrik Bengtsson. The package # is installed in /home/alice/R/x86_64-pc-linux-gnu-library/3.6/R.oo/. # License: LGPL (>= 2.1). Description: Methods and classes for object- # oriented programming in R with or without references. Large effort has # been made on making definition of methods as simple as possible with a # minimum of maintenance for package developers. The package has been # developed since 2001 and is now considered very stable. This is a # cross-platform package implemented in pure R that defines standard S3 # classes without any tricks. Type showNews(R.oo) for package history, # and ?R.oo for help." }} \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{classes} R.oo/man/getMessage.InternalErrorException.Rd0000644000176200001440000000261314711170563020670 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % InternalErrorException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getMessage.InternalErrorException} \alias{getMessage.InternalErrorException} \alias{InternalErrorException.getMessage} \alias{getMessage,InternalErrorException-method} \title{Gets the message of the exception} \description{ Gets the message of the exception and adds a message that clarifies that the error is likely due to an internal error and not due to the user. It also gives information how to contact the maintainer or author of the suspicious package. This information is retrieved from the DESCRIPTION file of the package. To help the package developer, information about the current version of R, the current version of the package etc are also returned so the user can easily cut'n'paste that information into a bug report. } \usage{ \method{getMessage}{InternalErrorException}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{InternalErrorException}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/getFieldModifiers.Object.Rd0000644000176200001440000000155514711170561016734 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getFieldModifiers.Object} \alias{getFieldModifiers.Object} \alias{Object.getFieldModifiers} \alias{getFieldModifiers,Object-method} \alias{Object.getFieldModifier} \alias{getFieldModifier.Object} \alias{getFieldModifier,Object-method} \title{Gets all types of field modifiers} \description{ Gets all types of field modifiers, if any. } \usage{ \method{getFieldModifiers}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a named \code{\link[base]{list}}. } \author{Henrik Bengtsson} \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getFields.Interface.Rd0000644000176200001440000000140214711170562015737 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Interface.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getFields.Interface} \alias{getFields.Interface} \alias{Interface.getFields} \alias{getFields,Interface-method} \title{Returns NULL} \description{ Returns NULL. } \usage{ \method{getFields}{Interface}(...) } \arguments{ \item{...}{Ignored.} } \value{ Always returns \code{\link[base]{NULL}}. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Interface}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getEnvironment.Package.Rd0000644000176200001440000000163314711170563016477 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getEnvironment.Package} \alias{getEnvironment.Package} \alias{Package.getEnvironment} \alias{getEnvironment,Package-method} \title{Gets the environment of a loaded package} \description{ Gets the environment of a loaded package. } \usage{ \method{getEnvironment}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{environment}}, or \code{\link[base]{NULL}} if the package was not loaded. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getPosition.Package]{*getPosition}()}. For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/createName.Rdoc.Rd0000644000176200001440000000235714711170563015077 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$createName} \alias{Rdoc$createName} \alias{createName.Rdoc} \alias{Rdoc.createName} \alias{createName,Rdoc-method} \title{Creates a class-method name} \description{ Creates a class-method name. } \usage{ ## Static method (use this): ## Rdoc$createName(class, method, escape=TRUE, ...) ## Don't use the below: \method{createName}{Rdoc}(static, class, method, escape=TRUE, ...) } \arguments{ \item{class}{A class name (\code{\link[base]{character}} string).} \item{method}{A method name (\code{\link[base]{character}} string).} \item{escape}{If \code{\link[base:logical]{TRUE}}, non-valid filename characters are escaped into valid character strings.} \item{...}{Not used.} } \value{ Returns \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:escapeRdFilename.Rdoc]{*escapeRdFilename}()}. For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/createManPath.Rdoc.Rd0000644000176200001440000000216014711170563015537 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$createManPath} \alias{Rdoc$createManPath} \alias{createManPath.Rdoc} \alias{Rdoc.createManPath} \alias{createManPath,Rdoc-method} \title{Creates the directory where the Rd files should be saved} \description{ Creates the directory where the Rd files should be saved. } \usage{ ## Static method (use this): ## Rdoc$createManPath(...) ## Don't use the below: \method{createManPath}{Rdoc}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the directory was creates, \code{\link[base:logical]{FALSE}} if it already exists and throws an \code{\link[R.oo]{Exception}} if failed. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getManPath.Rdoc]{*getManPath}()} For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getBundlePackages.Package.Rd0000644000176200001440000000244614711170563017046 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getBundlePackages.Package} \alias{getBundlePackages.Package} \alias{Package.getBundlePackages} \alias{getBundlePackages,Package-method} \title{Gets the names of the other packages that is in the same bundle as this package} \description{ Gets the names of the other packages that is in the same bundle as this package as specified by the \code{DESCRIPTION} file. } \usage{ \method{getBundlePackages}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} \code{\link[base]{vector}} of package names or \code{\link[base]{NULL}}. } \details{ The first call to this method is normally slow because all installed packages are scanned. The result of this first call is cached and used as the return value for all subsequent calls, which are then much faster. } \examples{\donttest{ pkg <- Package("R.oo") print(getBundle(pkg)) }} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/as.character.Exception.Rd0000644000176200001440000000173014711170562016431 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.Exception} \alias{as.character.Exception} \alias{Exception.as.character} \alias{as.character,Exception-method} \title{Gets a character string representing of the Exception} \description{ . By default the format is: "[\{POSIX date string\}] \{class name\}: \{msg\}". } \usage{ \method{as.character}{Exception}(x, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{\dontrun{For a complete example see help(Exception).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Exception}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/getInternalAddress.Object.Rd0000644000176200001440000000250714711170561017127 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getInternalAddress.Object} \alias{getInternalAddress.Object} \alias{Object.getInternalAddress} \alias{getInternalAddress,Object-method} \title{Gets the memory location where the Object resides} \description{ Gets the memory location where the Object resides. } \usage{ \method{getInternalAddress}{Object}(this, format=c("numeric", "hexstring"), ...) } \arguments{ \item{format}{A \code{\link[base]{character}} string specifying what format to return.} \item{...}{Not used.} } \value{ The address is returned as a \code{\link[base]{numeric}} integer if \code{format == "numeric"}, and as a \code{\link[base]{character}} string if \code{format == "hexstring"}. } \examples{ obj <- Object() getInternalAddress(obj, format="numeric") # 179742632 getInternalAddress(obj, format="hexstring") # "0x000000000ab6a7a8" } \author{Henrik Bengtsson} \seealso{ \code{\link[=getName.environment]{getName()}}. For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getDescriptionFile.Package.Rd0000644000176200001440000000211714711170563017254 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getDescriptionFile.Package} \alias{getDescriptionFile.Package} \alias{Package.getDescriptionFile} \alias{getDescriptionFile,Package-method} \title{Gets the description file of this package} \description{ Gets the description file of this package, i.e. the parsed \code{DESCRIPTION} file. } \usage{ \method{getDescriptionFile}{Package}(this, fields=NULL, ...) } \arguments{ \item{fields}{A \code{\link[base]{vector}} of \code{\link[base]{character}} strings of fields to be returned. If \code{\link[base]{NULL}}, all available fields are returned.} \item{...}{Not used.} } \value{ Returns named \code{\link[base]{vector}} of \code{\link[base]{character}} strings. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/isBeingCreated.Class.Rd0000644000176200001440000000342114711170562016051 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isBeingCreated.Class} \alias{isBeingCreated.Class} \alias{Class.isBeingCreated} \alias{isBeingCreated,Class-method} \title{Checks if a class is currently being initiated initiated} \description{ Checks if a class is currently being initiated initiated. When extending a class for the first time, which is typically done in a constructor, a static instance of the class is created by calling the constructor without parameters. This method provides a way to detect that second call inside the constructor. } \usage{ \method{isBeingCreated}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if a static instance exists, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ setConstructorS3("Car", function(brand=NULL, nbrOfWheels=0) { if(!isBeingCreated(Car)) { if (is.null(brand)) throw("A car must have a brand") if (nbrOfWheels <= 0) throw("A car must have one or more wheels: ", nbrOfWheels) } extend(Object(), "Car", .brand = brand, .nbrOfWheels = nbrOfWheels ) }) setMethodS3("as.character", "Car", function(this, ...) { cat(class(this)[1], ":", this$.brand, " with ", this$.nbrOfWheels, " wheels.", sep="") }) print(Car("Volvo", 4)) print(Car("BMW", 4)) print(Car("Tyrrell P34", 6)) print(Car("T-Rex", 3)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getName.environment.Rd0000644000176200001440000000167614711170564016074 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % getName.environment.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getName.environment} \alias{getName.environment} \title{Gets the name of an environment} \description{ Gets the name of an environment, e.g. \code{"R_GlobalEnv"} or \code{"0x01ddd060"}. } \usage{ \method{getName}{environment}(env, ...) } \arguments{ \item{env}{An \code{\link[base]{environment}}.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ name <- getName(globalenv()) print(name) stopifnot(identical(name, "R_GlobalEnv")) getName(new.env()) } \author{Henrik Bengtsson} \seealso{ \code{\link[base:environment]{environmentName}()}. } \keyword{programming} \keyword{methods} R.oo/man/DOLLAR.Object.Rd0000644000176200001440000000432614711170561014323 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{DOLLAR.Object} \alias{$.Object} \alias{Object.$} \alias{$,Object-method} \alias{Object.[[} \alias{[[.Object} \alias{[[,Object-method} \title{Makes the fields and methods of an Object accessible via the $ and the [[ operator} \description{ Makes the fields and methods of an Object accessible via the \code{$} operator. This method is never called explicitly, but through an indirect usage of the \code{$} operator, e.g. \code{obj$name} or \code{obj$getValue()}. 1) This method will first search for a \code{get()} method, e.g. if name has the value \code{"age"}, a \code{getAge()} will be looked for. If such a method exists it will be called with the Object as the first and only argument, e.g. \code{getAge(this)}. A \code{get()} is only looked for if \code{} is not a private field. A private field is a name \emph{beginning} with a \code{.} (period). The rational for this naming convention is to be consistent with how \code{\link[base]{ls}}() works, which will not list such members by default. 2) If no such method exists, first then, this method will look a field in the Object can has the name \code{name}. 3) If such neither exists, a method with name \code{name} will be searched for and returned. 4) Otherwise, a static field will be looked for. 5) If no fields or methods are found at all, \code{\link[base]{NULL}} is returned. } \usage{ \method{$}{Object}(this, name) \method{[[}{Object}(this, name, exact=TRUE) } \arguments{ \item{name}{The name of the field or method to be accessed.} } \value{ Returns the value of a field or a method (\code{\link[base]{function}}). If no such field or method exists, \code{\link[base]{NULL}} is returned. } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/isProtected.Class.Rd0000644000176200001440000000206614711170562015472 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isProtected.Class} \alias{isProtected.Class} \alias{Class.isProtected} \alias{isProtected,Class-method} \title{Checks if a class is defined protected or not} \description{ Checks if a class is defined protected or not. } \usage{ \method{isProtected}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the class is protected, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ if (isProtected(RccViolationException)) throw("The class RccViolationException should NOT be protected.") } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{class}}(). \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getDetails.Class.Rd0000644000176200001440000000151714711170562015272 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getDetails.Class} \alias{getDetails.Class} \alias{Class.getDetails} \alias{getDetails,Class-method} \title{Lists the fields and methods of a class} \description{ Lists the fields and methods of a class (or an object). } \usage{ \method{getDetails}{Class}(this, private=FALSE, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an invisible \code{\link[base]{character}} string of the class information. } \examples{ getDetails(Exception) } \author{Henrik Bengtsson} \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/attach.BasicObject.Rd0000644000176200001440000000264714711170612015555 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{attach.BasicObject} \alias{attach.BasicObject} \alias{BasicObject.attach} \alias{attach,BasicObject-method} \title{Attach a BasicObject to the R search path} \description{ Attach the members of a BasicObject to the \R search path. If trying to attach the same BasicObject twice without detaching it in between, a \code{\link[base]{warning}} will be generated and nothing will be done. } \usage{ \method{attach}{BasicObject}(this, private=FALSE, pos=2, ...) } \arguments{ \item{private}{If \code{\link[base:logical]{TRUE}}, private fields will also be attached, otherwise not.} \item{pos}{The position at in search path where the BasicObject should be inserted.} \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the \code{\link{BasicObject}} was attached, otherwise \code{\link[base:logical]{FALSE}}. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:detach.BasicObject]{*detach}()} and \code{\link[base]{attach}}(), \code{\link[base]{detach}}(). For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/showHowToCite.Package.Rd0000644000176200001440000000161714711170563016243 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{showHowToCite.Package} \alias{showHowToCite.Package} \alias{Package.showHowToCite} \alias{showHowToCite,Package-method} \title{Show the HOWTOCITE file of this package} \description{ Show the HOWTOCITE file of this package. See also \code{\link[R.oo:getHowToCite.Package]{*getHowToCite}()}. If the \code{HOWTOCITE} file does not exist, an exception is thrown. } \usage{ \method{showHowToCite}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/clone.Object.Rd0000644000176200001440000000177114711170561014447 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{clone.Object} \alias{clone.Object} \alias{Object.clone} \alias{clone,Object-method} \title{Clones an Object} \description{ Creates an identical copy of the object and returns a reference to the new object. } \usage{ \method{clone}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ A reference to the new object. } \examples{ o1 <- Object() o2 <- clone(o1) print(equals(o1, o2)) } \details{ Please note that no constructors are called during the creation of the clone and neither is any static class code called. } \seealso{ For more information see \code{\link{Object}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/setManPath.Rdoc.Rd0000644000176200001440000000217014711170563015070 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$setManPath} \alias{Rdoc$setManPath} \alias{setManPath.Rdoc} \alias{Rdoc.setManPath} \alias{setManPath,Rdoc-method} \title{Sets the path to the directory where the Rd files should be saved} \description{ Sets the path to the directory where the Rd files should be saved. By default the path is \code{../man/} assuming that the current directory is \code{../R/}, which is where source files commonly are placed. } \usage{ ## Static method (use this): ## Rdoc$setManPath(path="../man/", ...) ## Don't use the below: \method{setManPath}{Rdoc}(this, path="../man/", ...) } \arguments{ \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getManPath.Rdoc]{*getManPath}()} For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getRdDeclaration.classRepresentation.Rd0000644000176200001440000000137214711170563021403 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % classRepresentation.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getRdDeclaration.classRepresentation} \alias{getRdDeclaration.classRepresentation} \title{Gets the class declaration in Rd format} \description{ Gets the class declaration in Rd format. } \usage{ \method{getRdDeclaration}{classRepresentation}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \keyword{methods} \keyword{internal} \keyword{documentation} R.oo/man/compile.Rdoc.Rd0000644000176200001440000000461314711170563014460 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$compile} \alias{Rdoc$compile} \alias{compile.Rdoc} \alias{Rdoc.compile} \alias{compile,Rdoc-method} \title{Compile source code files containing Rdoc comments into Rd files} \description{ Compile source code files containing Rdoc comments into Rd files. \emph{Note, the class and methods to be compiled have to be loaded into \R by for instance \code{library()} or \code{source()} before calling this method.} } \usage{ ## Static method (use this): ## Rdoc$compile(filename=".*[.]R$", destPath=getManPath(this), showDeprecated=FALSE, ## addTimestamp=FALSE, locale="C", verbose=FALSE, source=FALSE, check=TRUE, ## debug=FALSE, ...) ## Don't use the below: \method{compile}{Rdoc}(this, filename=".*[.]R$", destPath=getManPath(this), showDeprecated=FALSE, addTimestamp=FALSE, locale="C", verbose=FALSE, source=FALSE, check=TRUE, debug=FALSE, ...) } \arguments{ \item{filename}{The pathname or filename pattern of the Rdoc files to be compiled.} \item{destPath}{The path where the generated Rd files should be saved.} \item{showDeprecated}{If \code{\link[base:logical]{TRUE}}, Rd files are generated for deprecated objects too, otherwise not.} \item{addTimestamp}{If \code{\link[base:logical]{TRUE}}, a date and time stamp is added to the Rd header comments. This timestamp might be confusing for version control systems, which is why it can be turned off with \code{\link[base:logical]{FALSE}}.} \item{locale}{The locale to be set/used when compiling Rdoc comments. This help assuring strings are sorted the same way across systems.} \item{source}{If \code{\link[base:logical]{TRUE}}, the Rdoc files will be \code{source()}:ed first. This work of course only for Rdoc files that are R source files.} \item{verbose}{If \code{\link[base:logical]{TRUE}}, detailed compilation information is printed.} \item{debug}{If \code{\link[base:logical]{TRUE}}, extra debug information is printed.} \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/isKeyword.Rdoc.Rd0000644000176200001440000000164314711170563015010 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$isKeyword} \alias{Rdoc$isKeyword} \alias{isKeyword.Rdoc} \alias{Rdoc.isKeyword} \alias{isKeyword,Rdoc-method} \title{Checks if a word is a Rd keyword} \description{ Checks if a word is a Rd keyword. } \usage{ ## Static method (use this): ## Rdoc$isKeyword(word, ...) ## Don't use the below: \method{isKeyword}{Rdoc}(this, word, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{logical}}. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getKeywords.Rdoc]{*getKeywords}()} For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/print.Class.Rd0000644000176200001440000000166714711170562014347 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{print.Class} \alias{print.Class} \alias{Class.print} \alias{print,Class-method} \title{Prints detailed information about the class and its fields and methods} \description{ Prints detailed information about the class and its fields and methods. } \usage{ \method{print}{Class}(x, ...) } \arguments{ \item{...}{Arguments passed to \code{\link[R.oo:getDetails.Class]{*getDetails}()}.} } \value{ Returns nothing. } \examples{ print(Object) } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getDetails.Class]{*getDetails}()} For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getUrl.Package.Rd0000644000176200001440000000152314711170563014733 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getUrl.Package} \alias{getUrl.Package} \alias{Package.getUrl} \alias{getUrl,Package-method} \title{Gets the URL of this package} \description{ Gets the URL of this package as specified by the \code{DESCRIPTION} file. } \usage{ \method{getUrl}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ pkg <- Package("R.oo") print(getUrl(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/Interface.Rd0000644000176200001440000000224014711170562014033 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Interface.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Interface} \docType{class} \alias{Interface} \title{The Interface class} \description{ Package: R.oo \cr \bold{Class Interface}\cr \code{+--}\code{Interface}\cr \bold{Directly known subclasses:}\cr \cr public class \bold{Interface}\cr This class represents a special set of classes whose purpose is to provide methods (but not fields) shared by multiple different classes. } \usage{ Interface(core=NA, ...) } \arguments{ \item{core}{The core value.} \item{...}{Not used.} } \section{Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{\link[R.oo:extend.Interface]{extend}} \tab Extends another Interface class.\cr \tab \code{\link[R.oo:print.Interface]{print}} \tab Prints an Interface.\cr \tab \code{\link[R.oo:uses.Interface]{uses}} \tab Specifies that an object uses this Interface.\cr } } \author{Henrik Bengtsson} \keyword{classes} \keyword{internal} R.oo/man/BasicObject.Rd0000644000176200001440000000476414711170612014314 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{BasicObject} \docType{class} \alias{BasicObject} \title{A root class like Object but without references} \description{ R.oo\cr \bold{Class BasicObject}\cr public class \bold{BasicObject}\cr } \usage{ BasicObject(core=NULL) } \arguments{ \item{core}{The core value of the object.} } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{$} \tab -\cr \tab \code{$<-} \tab -\cr \tab \code{.DollarNames} \tab -\cr \tab \code{.subset2Internal} \tab -\cr \tab \code{[[} \tab -\cr \tab \code{[[<-} \tab -\cr \tab \code{\link[R.oo:as.character.BasicObject]{as.character}} \tab Gets a character string representing the object.\cr \tab \code{\link[R.oo:attach.BasicObject]{attach}} \tab Attach a BasicObject to the R search path.\cr \tab \code{\link[R.oo:detach.BasicObject]{detach}} \tab Detach a BasicObject from the R search path.\cr \tab \code{\link[R.oo:equals.BasicObject]{equals}} \tab Compares an object with another.\cr \tab \code{\link[R.oo:extend.BasicObject]{extend}} \tab Extends another class.\cr \tab \code{\link[R.oo:getFields.BasicObject]{getFields}} \tab Returns the field names of a BasicObject.\cr \tab \code{\link[R.oo:getInstantiationTime.BasicObject]{getInstantiationTime}} \tab Gets the time when the object was instantiated.\cr \tab \code{\link[R.oo:hasField.BasicObject]{hasField}} \tab Checks if a field exists or not.\cr \tab \code{\link[R.oo:hashCode.BasicObject]{hashCode}} \tab Gets a hash code for the object.\cr \tab \code{\link[R.oo:isReferable.BasicObject]{isReferable}} \tab Checks if the object is referable or not.\cr \tab \code{\link[R.oo:newInstance.BasicObject]{newInstance}} \tab Creates a new instance of the same class as this object.\cr \tab \code{\link[R.oo:objectSize.BasicObject]{objectSize}} \tab Gets the size of the BasicObject in bytes.\cr \tab \code{\link[R.oo:print.BasicObject]{print}} \tab Prints a BasicObject.\cr } \bold{Methods inherited from logical}:\cr Ops,nonStructure,vector-method, Ops,structure,vector-method, Ops,vector,nonStructure-method, Ops,vector,structure-method, as.data.frame, as.raster, coerce,ANY,logical-method } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{internal} \keyword{classes} R.oo/man/as.character.Object.Rd0000644000176200001440000000213714711170561015702 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.Object} \alias{as.character.Object} \alias{Object.as.character} \alias{as.character,Object-method} \title{Gets a character string representing the object} \description{ Gets a character string representing the object. In the class Object, this method simply returns the class name and the hashCode() value of the object. } \usage{ \method{as.character}{Object}(x, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string representation of the Object. By default it is "\{class name\}: \{hash code\}". } \examples{ obj <- Object() as.character(obj) # "Object: 0x000000000ab6a7a8" } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getMethods.Class.Rd0000644000176200001440000000253614711170562015312 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getMethods.Class} \alias{getMethods.Class} \alias{Class.getMethods} \alias{getMethods,Class-method} \title{Returns the method names of class and its super classes} \description{ Returns the method names of class and its super classes as a list. } \usage{ \method{getMethods}{Class}(this, private=FALSE, deprecated=TRUE, unique=TRUE, ...) } \arguments{ \item{private}{If \code{\link[base:logical]{TRUE}}, private methods are also returned, otherwise only public ones are returned.} \item{deprecated}{If \code{\link[base:logical]{TRUE}}, deprecated methods are also returned.} \item{unique}{If \code{\link[base:logical]{TRUE}}, only methods that are not implemented in one of the subclasses are returned for each class.} \item{...}{Not used.} } \value{ Returns a named \code{\link[base]{list}} of named \code{\link[base]{character}} strings. } \examples{ names <- getMethods(Exception) print(names) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getContribUrl.Package.Rd0000644000176200001440000000212514711170563016253 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getContribUrl.Package} \alias{getContribUrl.Package} \alias{Package.getContribUrl} \alias{getContribUrl,Package-method} \title{Gets the URL(s) from where this package can be installed} \description{ Gets the URL(s) from where this package can be installed by first looking for comma or semicolon separated URLs at the optional \code{ContribURL} line in the \code{DESCRIPTION} file of the package. If no such line exists, \code{getUrl()} is used. } \usage{ \method{getContribUrl}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a vector of \code{\link[base]{character}} strings. } \examples{ pkg <- Package("R.oo") print(getContribUrl(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getStaticInstance.Class.Rd0000644000176200001440000000156614711170562016625 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getStaticInstance.Class} \alias{getStaticInstance.Class} \alias{Class.getStaticInstance} \alias{getStaticInstance,Class-method} \title{Gets the static instance of this class} \description{ Gets the static instance of this class. } \usage{ \method{getStaticInstance}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a reference to an \code{\link{Object}}. } \examples{ obj <- getStaticInstance(Object) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getClasses.Package.Rd0000644000176200001440000000154414711170563015571 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getClasses.Package} \alias{getClasses.Package} \alias{Package.getClasses} \alias{getClasses,Package-method} \title{Gets all classes of a package} \description{ Gets all classes of a package. } \usage{ \method{getClasses}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} \code{\link[base]{vector}} of class names. } \examples{ pkg <- Package("R.oo") print(getClasses(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/RdocException.Rd0000644000176200001440000000507614711170563014714 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % RdocException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{RdocException} \docType{class} \alias{RdocException} \title{RdocException are thrown by the Rdoc compiler} \description{ Package: R.oo \cr \bold{Class RdocException}\cr \code{\link[R.oo]{Object}}\cr \code{~~|}\cr \code{~~+--}\code{try-error}\cr \code{~~~~~~~|}\cr \code{~~~~~~~+--}\code{condition}\cr \code{~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~+--}\code{error}\cr \code{~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~+--}\code{simpleError}\cr \code{~~~~~~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~~~~~~+--}\code{\link[R.oo]{Exception}}\cr \code{~~~~~~~~~~~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~~~~~~~~~~~+--}\code{RdocException}\cr \bold{Directly known subclasses:}\cr \cr public static class \bold{RdocException}\cr extends \link[R.oo]{Exception}\cr RdocException are thrown by the Rdoc compiler when it fails to generate a Rd file from an Rdoc comment. } \usage{ RdocException(..., source=NULL) } \arguments{ \item{...}{Any arguments accepted by \code{\link[R.oo]{Exception}}}. \item{source}{Object specifying the source where the Rdoc error occurred. This is commonly a filename \code{\link[base]{character}} string.}. } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{\link[R.oo:as.character.RdocException]{as.character}} \tab Gets a character string representing of the RdocException.\cr \tab \code{\link[R.oo:getSource.RdocException]{getSource}} \tab Gets the source of the exception.\cr } \bold{Methods inherited from Exception}:\cr as.character, getCall, getCalls, getLastException, getMessage, getStackTrace, getWhen, print, printStackTrace, throw \bold{Methods inherited from error}:\cr as.character, throw \bold{Methods inherited from condition}:\cr abort, as.character, conditionCall, conditionMessage, print \bold{Methods inherited from Object}:\cr $, $<-, [[, [[<-, as.character, attach, attachLocally, clearCache, clearLookupCache, clone, detach, equals, extend, finalize, getEnvironment, getFieldModifier, getFieldModifiers, getFields, getInstantiationTime, getStaticInstance, hasField, hashCode, ll, load, names, objectSize, print, save } \author{Henrik Bengtsson} \seealso{ For detailed information about exceptions see \code{\link[R.oo]{Exception}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{classes} R.oo/man/DOLLARLT_-.Class.Rd0000644000176200001440000000442114711170612014627 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{DOLLAR< -.Class} \alias{$<-.Class} \alias{Class.$<-} \alias{$<-,Class-method} \alias{Class.[[<-} \alias{[[<-.Class} \alias{[[<-,Class-method} \title{Makes the fields and methods of a Class assignable via the $<- and the [[<- operator} \usage{ \method{$}{Class}(this, name) <- value \method{[[}{Class}(this, name) <- value } \description{ Makes the fields and methods of a Class assignable via the \code{$<-} operator. This method is never called explicitly, but through an indirect usage of the \code{$<-} operator, e.g. \code{obj$name <- "foo"}. \enumerate{ \item This method will first search for a \preformatted{set()} method, e.g. if name has the value \code{"age"}, a \code{setAge()} will be looked for. If such a method exists it will be called with the Class as the first argument and \code{value} as the second, e.g. \code{setAge(this, value)}. A \code{get()} is only looked for if \code{} is not a private field. A private field is a name \emph{beginning} with a \code{.} (period). The rational for this naming convention is to be consistent with how \code{\link[base]{ls}()} works, which will not list such members by default. \item If no such method exists it will assign the \code{value} to a (existing or a non-existing) field named \code{name}. } Because any \preformatted{set()} is called first, it is possible to \emph{encapsulate} (hide away) fields with certain names or to put restrictions to what values can be assigned to them. } \arguments{ \item{name}{The name of the \preformatted{set()} method or the name of the field to be assigned the new value.} \item{value}{The value to be assigned.} } \value{ Returns itself, i.e. \code{this}, as all \code{$<-} methods must do. } \examples{\dontrun{For a complete example see help(Class).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/DOLLAR.Class.Rd0000644000176200001440000000425314711170612014156 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{DOLLAR.Class} \alias{$.Class} \alias{Class.$} \alias{$,Class-method} \alias{Class.[[} \alias{[[.Class} \alias{[[,Class-method} \title{Makes the fields and methods of a Class accessible via the $ and the [[ operator} \usage{ \method{$}{Class}(this, name) \method{[[}{Class}(this, name, exact=TRUE) } \description{ Makes the fields and methods of a Class accessible via the \code{$} operator. This method is never called explicitly, but through an indirect usage of the \code{$} operator, e.g. \code{obj$name} or \code{obj$getValue()}. \enumerate{ \item This method will first search for a \code{get()} method, e.g. if name has the value \code{"age"}, a \code{getAge()} will be looked for. If such a method exists it will be called with the Class as the first and only argument, e.g. \code{getAge(this)}. A \code{get()} is only looked for if \code{} is not a private field. A private field is a name \emph{beginning} with a \code{.} (period). The rational for this naming convention is to be consistent with how \code{\link[base]{ls}()} works, which will not list such members by default. \item If no such method exists, first then, this method will look a field in the Class can has the name \code{name}. \item If such neither exists, a method with name \code{name} will be searched for and returned. \item If no fields or methods are found at all, \code{\link[base]{NULL}} is returned. } } \arguments{ \item{name}{The name of the field or method to be accessed.} } \value{ Returns the value of a field or a method (\code{\link[base]{function}}). If no such field or method exists, \code{\link[base]{NULL}} is returned. } \examples{\dontrun{For a complete example see help(Class).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/argsToString.Rdoc.Rd0000644000176200001440000000245314711170563015456 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$argsToString} \alias{Rdoc$argsToString} \alias{argsToString.Rdoc} \alias{Rdoc.argsToString} \alias{argsToString,Rdoc-method} \title{Gets the arguments signature of a function} \description{ Gets the arguments signature of a function. } \usage{ ## Static method (use this): ## Rdoc$argsToString(fcn, escapeRd=FALSE, collapse=TRUE, ...) ## Don't use the below: \method{argsToString}{Rdoc}(static, fcn, escapeRd=FALSE, collapse=TRUE, ...) } \arguments{ \item{fcn}{A \code{\link[base]{function}}.} \item{escapeRd}{If \code{\link[base:logical]{TRUE}}, certain Rd markup symbols are escaped.} \item{collapse}{If \code{\link[base:logical]{TRUE}}, each argument is returned as a single string, otherwise split up into a vector of strings as far as possible.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{list}} of \code{\link[base]{character}} strings. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/isStatic.Class.Rd0000644000176200001440000000203514711170562014764 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isStatic.Class} \alias{isStatic.Class} \alias{Class.isStatic} \alias{isStatic,Class-method} \title{Checks if a class is static or not} \description{ Checks if a class is static or not. A class is static if it has static methods. } \usage{ \method{isStatic}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the class is static, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ if (!isStatic(RccViolationException)) throw("RccViolationException should be static because Exception is.") } \author{Henrik Bengtsson} \seealso{ \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/Rdoc.Rd0000644000176200001440000000764314711170563013037 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc} \docType{class} \alias{Rdoc} \title{Class for converting Rdoc comments to Rd files} \description{ Package: R.oo \cr \bold{Class Rdoc}\cr \code{\link[R.oo]{Object}}\cr \code{~~|}\cr \code{~~+--}\code{Rdoc}\cr \bold{Directly known subclasses:}\cr \cr public static class \bold{Rdoc}\cr extends \link[R.oo]{Object}\cr Class for converting Rdoc comments to Rd files. } \usage{ Rdoc() } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{\link[R.oo:argsToString.Rdoc]{argsToString}} \tab Gets the arguments signature of a function.\cr \tab \code{\link[R.oo:check.Rdoc]{check}} \tab Checks the compiled Rd files.\cr \tab \code{\link[R.oo:compile.Rdoc]{compile}} \tab Compile source code files containing Rdoc comments into Rd files.\cr \tab \code{\link[R.oo:createManPath.Rdoc]{createManPath}} \tab Creates the directory where the Rd files should be saved.\cr \tab \code{\link[R.oo:createName.Rdoc]{createName}} \tab Creates a class-method name.\cr \tab \code{\link[R.oo:declaration.Rdoc]{declaration}} \tab Gets the class declaration.\cr \tab \code{\link[R.oo:escapeRdFilename.Rdoc]{escapeRdFilename}} \tab Escape non-valid characters in a filename.\cr \tab \code{\link[R.oo:getClassS4Usage.Rdoc]{getClassS4Usage}} \tab Gets the usage of a S4 class.\cr \tab \code{\link[R.oo:getKeywords.Rdoc]{getKeywords}} \tab Gets the keywords defined in R with descriptions.\cr \tab \code{\link[R.oo:getManPath.Rdoc]{getManPath}} \tab Gets the path to the directory where the Rd files will be saved.\cr \tab \code{\link[R.oo:getNameFormat.Rdoc]{getNameFormat}} \tab Gets the current name format.\cr \tab \code{getObject} \tab -\cr \tab \code{\link[R.oo:getPackageNameOf.Rdoc]{getPackageNameOf}} \tab Gets the package of a method or an object.\cr \tab \code{\link[R.oo:getRdTitle.Rdoc]{getRdTitle}} \tab Extracts the title string of a Rd file.\cr \tab \code{\link[R.oo:getUsage.Rdoc]{getUsage}} \tab Gets the usage of a method.\cr \tab \code{\link[R.oo:hierarchy.Rdoc]{hierarchy}} \tab Gets the class hierarchy.\cr \tab \code{\link[R.oo:isKeyword.Rdoc]{isKeyword}} \tab Checks if a word is a Rd keyword.\cr \tab \code{\link[R.oo:isVisible.Rdoc]{isVisible}} \tab Checks if a member is visible given its modifiers.\cr \tab \code{\link[R.oo:methodsInheritedFrom.Rdoc]{methodsInheritedFrom}} \tab Gets all methods inherited from a class in Rd format.\cr \tab \code{\link[R.oo:setManPath.Rdoc]{setManPath}} \tab Sets the path to the directory where the Rd files should be saved.\cr \tab \code{\link[R.oo:setNameFormat.Rdoc]{setNameFormat}} \tab Sets the current name format.\cr } \bold{Methods inherited from Object}:\cr $, $<-, [[, [[<-, as.character, attach, attachLocally, clearCache, clearLookupCache, clone, detach, equals, extend, finalize, getEnvironment, getFieldModifier, getFieldModifiers, getFields, getInstantiationTime, getStaticInstance, hasField, hashCode, ll, load, names, objectSize, print, save } \author{Henrik Bengtsson} \examples{\dontrun{# Set default author author <- "Henrik Bengtsson, \\url{https://github.com/HenrikBengtsson/R.oo}" # Show the file containing the Rdoc comments rdocFile <- system.file("misc", "ASCII.R", package="R.oo") file.show(rdocFile) # Compile the Rdoc:s into Rd files (saved in the destPath directory) destPath <- tempdir() Rdoc$compile(rdocFile, destPath=destPath) # List the generated Rd files rdFiles <- list.files(destPath, full.names=TRUE) print(rdFiles) # Show one of the files file.show(rdFiles[1]) # Clean up file.remove(rdFiles) }} \references{ R developers, \emph{Guidelines for Rd files}, \url{https://developer.r-project.org/Rds.html}, 2003 } \keyword{classes} \keyword{documentation} R.oo/man/getRdHierarchy.Class.Rd0000644000176200001440000000146514711170562016113 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Class.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getRdHierarchy.Class} \alias{getRdHierarchy.Class} \alias{Class.getRdHierarchy} \alias{getRdHierarchy,Class-method} \title{Gets the class hierarchy in Rd format} \description{ Gets the class hierarchy in Rd format. } \usage{ \method{getRdHierarchy}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getDataPath.Package.Rd0000644000176200001440000000150214711170563015654 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getDataPath.Package} \alias{getDataPath.Package} \alias{Package.getDataPath} \alias{getDataPath,Package-method} \title{Gets the path to the data (data/) directory of this package} \description{ Gets the path to the data (data/) directory of this package. } \usage{ \method{getDataPath}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/clearLookupCache.Object.Rd0000644000176200001440000000170514711170561016550 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{clearLookupCache.Object} \alias{clearLookupCache.Object} \alias{Object.clearLookupCache} \alias{clearLookupCache,Object-method} \title{Clear internal fields used for faster lookup} \description{ Clear internal fields used for faster lookup by removing these fields. This method is called whenever \code{\link[R.oo:clearCache.Object]{*clearCache}()} is called on the object. } \usage{ \method{clearLookupCache}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns itself (invisible). } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getRdMethods.Class.Rd0000644000176200001440000000172014711170562015572 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Class.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getRdMethods.Class} \alias{getRdMethods.Class} \alias{Class.getRdMethods} \alias{getRdMethods,Class-method} \title{Gets the methods of a class in Rd format} \description{ Gets the methods of a class in Rd format. } \usage{ \method{getRdMethods}{Class}(class, visibilities=c("private", "protected", "public"), ...) } \arguments{ \item{visibilities}{A \code{\link[base]{character}} string specifying what types of methods to return.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/printStackTrace.Exception.Rd0000644000176200001440000000176114711170562017200 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{printStackTrace.Exception} \alias{printStackTrace.Exception} \alias{Exception.printStackTrace} \alias{printStackTrace,Exception-method} \title{Prints the stack trace saved when the exception was created} \description{ . } \usage{ \method{printStackTrace}{Exception}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns nothing. } \examples{\dontrun{For a complete example see help(Exception).}} \seealso{ \code{\link[R.oo:getStackTrace.Exception]{*getStackTrace}()}. \code{\link[base:conditions]{tryCatch}()}. For more information see \code{\link{Exception}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/getSuperclasses.Class.Rd0000644000176200001440000000207114711170562016355 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getSuperclasses.Class} \alias{getSuperclasses.Class} \alias{Class.getSuperclasses} \alias{getSuperclasses,Class-method} \title{Gets the super classes of this class} \description{ Gets the super classes of this class. } \usage{ \method{getSuperclasses}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{vector}} of \code{\link[base]{character}} strings. } \examples{ print(getSuperclasses(RccViolationException)) \dontrun{ returns [1] "Exception" "try-error" "Object" } } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{class}}(). \code{\link[R.oo:getKnownSubclasses.Class]{*getKnownSubclasses}()}. For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getDescription.Package.Rd0000644000176200001440000000213614711170563016455 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getDescription.Package} \alias{getDescription.Package} \alias{Package.getDescription} \alias{getDescription,Package-method} \title{Gets the description of the package} \description{ Gets the description of the package. Not to be mixed up with \code{\link[R.oo:getDescriptionFile.Package]{*getDescriptionFile}()}. } \usage{ \method{getDescription}{Package}(this, replaceNewlines=" ", ...) } \arguments{ \item{replaceNewlines}{If a \code{\link[base]{character}} string, all newline characters are replaced with this string. Otherwise not.} \item{...}{Not used.} } \value{ A \code{\link[base]{character}} string. } \examples{ pkg <- Package("base") print(getDescription(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/objectSize.Rd0000644000176200001440000000151514711170564014242 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % objectSize.default.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{objectSize} \alias{objectSize.default} \alias{objectSize} \title{Gets the size of the object in bytes} \description{ Gets the size of the object in bytes. This method is just a wrapper for \code{\link[utils]{object.size}}. } \usage{ \method{objectSize}{default}(...) } \arguments{ \item{...}{Arguments passed to \code{\link[utils]{object.size}}.} } \value{ Returns an \code{\link[base]{integer}}. } \author{Henrik Bengtsson} \seealso{ Internally \code{\link[utils]{object.size}}. } \keyword{attribute} \keyword{utilities} R.oo/man/InternalErrorException.Rd0000644000176200001440000000563514711170563016614 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % InternalErrorException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{InternalErrorException} \docType{class} \alias{InternalErrorException} \title{InternalErrorException represents internal errors} \description{ Package: R.oo \cr \bold{Class InternalErrorException}\cr \code{\link[R.oo]{Object}}\cr \code{~~|}\cr \code{~~+--}\code{try-error}\cr \code{~~~~~~~|}\cr \code{~~~~~~~+--}\code{condition}\cr \code{~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~+--}\code{error}\cr \code{~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~+--}\code{simpleError}\cr \code{~~~~~~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~~~~~~+--}\code{\link[R.oo]{Exception}}\cr \code{~~~~~~~~~~~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~~~~~~~~~~~+--}\code{InternalErrorException}\cr \bold{Directly known subclasses:}\cr \cr public static class \bold{InternalErrorException}\cr extends \link[R.oo]{Exception}\cr InternalErrorException represents internal errors that are likely to be due to implementation errors done by the author of a specific package and not because the user made an error. Errors that are due to unexpected input to functions etc falls under this error type. } \usage{ InternalErrorException(..., package=NULL) } \arguments{ \item{...}{Any arguments accepted by \code{\link{Exception}}}. \item{package}{The name (\code{\link[base]{character}} string) of the package where the error exists. Can also be a \code{\link{Package}} object. If \code{\link[base]{NULL}}, the source of the error is assumed to be unknown.} } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{\link[R.oo:getMessage.InternalErrorException]{getMessage}} \tab Gets the message of the exception.\cr \tab \code{\link[R.oo:getPackage.InternalErrorException]{getPackage}} \tab Gets the suspicious package likely to contain an error.\cr } \bold{Methods inherited from Exception}:\cr as.character, getCall, getCalls, getLastException, getMessage, getStackTrace, getWhen, print, printStackTrace, throw \bold{Methods inherited from error}:\cr as.character, throw \bold{Methods inherited from condition}:\cr abort, as.character, conditionCall, conditionMessage, print \bold{Methods inherited from Object}:\cr $, $<-, [[, [[<-, as.character, attach, attachLocally, clearCache, clearLookupCache, clone, detach, equals, extend, finalize, getEnvironment, getFieldModifier, getFieldModifiers, getFields, getInstantiationTime, getStaticInstance, hasField, hashCode, ll, load, names, objectSize, print, save } \author{Henrik Bengtsson} \seealso{ For detailed information about exceptions see \code{\link{Exception}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{classes} R.oo/man/getExamplePath.Package.Rd0000644000176200001440000000152714711170563016405 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getExamplePath.Package} \alias{getExamplePath.Package} \alias{Package.getExamplePath} \alias{getExamplePath,Package-method} \title{Gets the path to the example (R-ex/) directory of this package} \description{ Gets the path to the example (R-ex/) directory of this package. } \usage{ \method{getExamplePath}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getCalls.Exception.Rd0000644000176200001440000000212714711170562015632 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getCalls.Exception} \alias{getCalls.Exception} \alias{Exception.getCalls} \alias{getCalls,Exception-method} \alias{Exception.getCall} \alias{getCall.Exception} \alias{getCall,Exception-method} \title{Gets the active calls saved when the exception was created} \description{ . } \usage{ \method{getCalls}{Exception}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an unnamed \code{\link[base]{list}} with @language elements. } \examples{\dontrun{For a complete example see help(Exception).}} \seealso{ \code{\link[R.oo:getStackTrace.Exception]{*getStackTrace}()}. \code{\link[utils:debugger]{sys.calls}()}. For more information see \code{\link{Exception}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/getPackage.InternalErrorException.Rd0000644000176200001440000000171314711170563020637 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % InternalErrorException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getPackage.InternalErrorException} \alias{getPackage.InternalErrorException} \alias{InternalErrorException.getPackage} \alias{getPackage,InternalErrorException-method} \title{Gets the suspicious package likely to contain an error} \description{ Gets the suspicious package likely to contain an error. } \usage{ \method{getPackage}{InternalErrorException}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link{Package}} object. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{InternalErrorException}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/hashCode.BasicObject.Rd0000644000176200001440000000155214711170562016025 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{hashCode.BasicObject} \alias{hashCode.BasicObject} \alias{BasicObject.hashCode} \alias{hashCode,BasicObject-method} \title{Gets a hash code for the object} \description{ Gets a hash code for the object. } \usage{ \method{hashCode}{BasicObject}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an \code{\link[base]{integer}}. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:equals.BasicObject]{*equals}()} For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/load.Package.Rd0000644000176200001440000000200614711170563014405 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{load.Package} \alias{load.Package} \alias{Package.load} \alias{load,Package-method} \title{Loads a package} \description{ Loads a package. This is an alternative way to use \code{library()} to load a package. } \usage{ \method{load}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ \code{\link[base:logical]{TRUE}} if the packages is loaded, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ pkg <- Package("base") print(load(pkg)) } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:unload.Package]{*unload}()}. \code{\link[R.oo:isLoaded.Package]{*isLoaded}()}. \code{\link[base]{search}}(). For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/clearCache.Object.Rd0000644000176200001440000000503214711170561015353 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{clearCache.Object} \alias{clearCache.Object} \alias{Object.clearCache} \alias{clearCache,Object-method} \title{Clear fields that are defined to have cached values} \description{ Clear fields that are defined to have cached values by assigning \code{\link[base]{NULL}} to these fields. } \usage{ \method{clearCache}{Object}(this, recursive=TRUE, gc=FALSE, ...) } \arguments{ \item{recursive}{If \code{\link[base:logical]{TRUE}}, the same method is called also on all fields that are \code{\link{Object}}:s. Circular dependencies can exists.} \item{gc}{If \code{\link[base:logical]{TRUE}}, the garbage collector is called, otherwise not.} \item{...}{Not used.} } \value{ Returns itself (invisible). } \examples{ # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Defining a class with a 'cached' fields # - - - - - - - - - - - - - - - - - - - - - - - - - - - - setConstructorS3("CachedObject", function(...) { extend(Object(), "CachedObject", ... ) }) setMethodS3("as.character", "CachedObject", function(this, ...) { s <- NextMethod("as.character", this, ...) s <- sprintf("\%s RAM: \%.2fkb.", s, objectSize(this)/1024) s }) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Example of clearing a cache fields, reassigning it, # and then clearing it again # - - - - - - - - - - - - - - - - - - - - - - - - - - - - obj <- CachedObject(a=1, b=1:10^5, "cached:c"=1:10^6) print(obj) print(ll(obj)) clearCache(obj, gc=TRUE) print(obj) print(ll(obj)) obj$c <- 1:10^6 print(obj) print(ll(obj)) clearCache(obj, gc=TRUE) print(obj) print(ll(obj)) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - # Clearing cached fields recursively and make sure it # avoids race conditions due to circular dependences # - - - - - - - - - - - - - - - - - - - - - - - - - - - - objA <- CachedObject(a=2, "cached:c"=1:10^6, prev=NULL) print(ll(objA)) objB <- CachedObject(a=2, "cached:c"=1:10^6, prev=objA) print(ll(objB)) objC <- CachedObject(a=3, "cached:c"=1:10^6, prev=objB) print(ll(objC)) objA$prev <- objC clearCache(objA, gc=TRUE) print(ll(objA)) print(ll(objB)) print(ll(objC)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/throw.Rd0000644000176200001440000000305714711170564013307 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % throw.default.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{throw} \alias{throw.default} \alias{throw} \title{Throws an Exception} \description{ Throws an exception similar to \code{stop()}, but with support for \code{\link{Exception}} classes. The first argument (\code{object}) is by default pasted together with other arguments (\code{...}) and with separator \code{sep=""}. For instance, to throw an exception, write \code{throw("Value out of range: ", value, ".")}. which is short for \code{throw(Exception("Value out of range: ", value, "."))}. Note that \code{throw()} can be defined for classes inheriting \code{\link{Exception}}, which can then be caught (or not) using \code{\link[base:conditions]{tryCatch}()}. } \usage{ \method{throw}{default}(...) } \arguments{ \item{...}{One or several strings that are concatenated and collapsed into on message string.} } \value{ Returns nothing. } \examples{ rbern <- function(n=1, prob=1/2) { if (prob < 0 || prob > 1) throw("Argument 'prob' is out of range: ", prob) rbinom(n=n, size=1, prob=prob) } rbern(10, 0.4) # [1] 0 1 0 0 0 1 0 0 1 0 tryCatch(rbern(10, 10*0.4), error=function(ex) {} ) } \author{Henrik Bengtsson} \seealso{ See the \code{\link{Exception}} class for more detailed information. } \keyword{error} R.oo/man/attachLocally.Object.Rd0000644000176200001440000000425714711170561016135 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{attachLocally.Object} \alias{attachLocally.Object} \alias{Object.attachLocally} \alias{attachLocally,Object-method} \title{Attaches an Object locally to an environment} \usage{ \method{attachLocally}{Object}(this, private=FALSE, fields=NULL, excludeFields=NULL, overwrite=TRUE, envir=parent.frame(), ...) } \description{ Attaches an Object locally to an environment. By default, the fields of the Object are attached to the parent frame, that is, the calling environment. } \arguments{ \item{private}{If \code{\link[base:logical]{TRUE}}, private fields are included, otherwise not. This is only effective if \code{fields==NULL}.} \item{fields}{A \code{\link[base]{character}} \code{\link[base]{vector}} specifying elements to be copied. If \code{\link[base]{NULL}}, all elements are considered.} \item{excludeFields}{A \code{\link[base]{character}} \code{\link[base]{vector}} specifying elements not to be copied. This has higher priority than \code{fields}.} \item{overwrite}{If \code{\link[base:logical]{FALSE}}, fields that already exists will not be copied.} \item{envir}{The \code{\link[base]{environment}} where fields are copied to.} \item{...}{Not used.} } \value{ Returns (invisibly) a \code{\link[base]{character}} \code{\link[base]{vector}} of the fields copied. } \examples{ foo <- function(object, arg1="some value", ...) { cat("Local objects in foo():\n") print(ls()) attachLocally(object) cat("\nLocal objects in foo():\n") print(ls()) for (name in ls()) { cat("\nObject '", name, "':\n", sep="") print(get(name, inherits=FALSE)) } } a <- "A string" obj <- Object() obj$a <- "Another string" obj$b <- NA foo(obj) print(a) } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:attach.Object]{*attach}()} For more information see \code{\link{Object}}. } \keyword{internal} \keyword{methods} \keyword{utilities} \keyword{programming} R.oo/man/getClassS4Usage.Rdoc.Rd0000644000176200001440000000174114711170563015770 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$getClassS4Usage} \alias{Rdoc$getClassS4Usage} \alias{getClassS4Usage.Rdoc} \alias{Rdoc.getClassS4Usage} \alias{getClassS4Usage,Rdoc-method} \title{Gets the usage of a S4 class} \description{ Gets the usage of a S4 class. } \usage{ ## Static method (use this): ## Rdoc$getClassS4Usage(class, ...) ## Don't use the below: \method{getClassS4Usage}{Rdoc}(static, class, ...) } \arguments{ \item{class}{A class name (\code{\link[base]{character}} string).} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/compileRdoc.Rd0000644000176200001440000000274114711170563014402 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % compileRdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{compileRdoc} \alias{compileRdoc} \title{Compiles the Rdoc help comments in a package} \description{ Compiles the Rdoc help comments in a package by parsing the source code files and writes Rd help files. } \usage{ compileRdoc(pkgname=NULL, path=pkgname, ..., verbose=TRUE) } \arguments{ \item{pkgname}{A \code{\link[base]{character}} string specifying the package name. If \code{\link[base]{NULL}}, the package name is inferred from the DESCRIPTION file that is automatically search for in the subdirectories.} \item{path}{A \code{\link[base]{character}} string specifying the path of the package source directory.} \item{...}{Additional arguments passed to \code{Rdoc\$compile()}.} \item{verbose}{If \code{\link[base:logical]{TRUE}}, verbose output is printed, otherwise not.} } \value{ Returns nothing. } \details{ To compile all Rdoc comments in a package 'PkgA' that is located under the current working directory (e.g. \code{PkgA/R/*.R}) from the system command line, do: \preformatted{ Rscript -e R.oo::compileRdoc() } } \author{Henrik Bengtsson} \seealso{ See the \code{\link{Rdoc}} class. } \keyword{documentation} \keyword{IO} \keyword{internal} R.oo/man/forName.Class.Rd0000644000176200001440000000211014711170562014562 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Class$forName} \alias{Class$forName} \alias{forName.Class} \alias{Class.forName} \alias{forName,Class-method} \title{Gets a Class object by a name of a class} \description{ Gets a Class object by a name of a class. If no such class exists and exception is thrown. } \usage{ ## Static method (use this): ## Class$forName(name, ...) ## Don't use the below: \method{forName}{Class}(static, name, ...) } \arguments{ \item{...}{Optional arguments passed to internal lookup function.} } \value{ Returns a \code{\link{Class}}. } \examples{ print(Class$forName("Exception")) } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{class}}(). \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/charToInt.Rd0000644000176200001440000000237214711170562014034 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % ASCII.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{charToInt} \alias{charToInt.default} \alias{charToInt} \title{Converts a vector of ASCII characters into a vector of integers} \description{ Converts a \code{\link[base]{vector}} of ASCII \code{\link[base]{character}}s to a equal length vector of ASCII \code{\link[base]{integer}}s. } \usage{ \method{charToInt}{default}(ch, ...) } \arguments{ \item{ch}{A \code{\link[base]{character}} \code{\link[base]{vector}}.} \item{...}{Not used.} } \value{ Returns an ASCII \code{\link[base]{integer}} \code{\link[base]{vector}}. } \author{Henrik Bengtsson} \examples{ i <- charToInt(unlist(strsplit("Hello world!", split=NULL))) # Gives: 72 101 108 108 111 32 119 111 114 108 100 33 ch <- intToChar(c(72,101,108,108,111,32,119,111,114,108,100,33)) # Gives: "H" "e" "l" "l" "o" " " "w" "o" "r" "l" "d" "!" } \seealso{ \code{\link{intToChar}}() \code{\link[base]{utf8Conversion}}. \code{\link[base]{rawConversion}} } \keyword{character} \keyword{internal} R.oo/man/ll.Rd0000644000176200001440000000753114711170564012554 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % ll.default.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{ll} \alias{ll.default} \alias{ll} \title{Generates a list of informative properties of all members of an environment} \description{ Generates a list of informative properties of all members of an environment. } \usage{ \method{ll}{default}(pattern=".*", ..., private=FALSE, properties=getOption("R.oo::ll/properties", c("data.class", "dimension", "objectSize")), sortBy=NULL, decreasing=FALSE, envir=parent.frame()) } \arguments{ \item{pattern}{Regular expression pattern specifying which members to return. If \code{".*"}, all names are matched.} \item{...}{A named \code{\link[base]{vector}} of format \code{functionName=value}, where \code{functionName()} will be called on each member found. If the result matches the \code{value}, the member is returned, otherwise not.} \item{private}{If \code{\link[base:logical]{TRUE}}, also private members, i.e. members with a name starting with a \code{.} (period), will be listed, otherwise not.} \item{properties}{Names of properties to be returned. There must exist a \code{\link[base]{function}} with the same name, because it will be called. This way one can extract any type of property by defining new methods.} \item{sortBy}{Name or index of column (property) to be sorted by. If \code{\link[base]{NULL}}, the objects are listed in the order they are found.} \item{decreasing}{A \code{\link[base]{logical}} indicating whether the sorting should be done in increasing or decreasing order.} \item{envir}{An \code{\link[base]{environment}}, a search path index or a name of a package to be scanned.} } \value{ Returns a \code{\link[base]{data.frame}} containing information about all the members. } \section{Default properties returned}{ It is possible to set the default value of argument \code{properties} by setting option \code{"R.oo::ll/properties"}, e.g. \code{options("R.oo::ll/properties"=c("data.class", "dimension"))}. If this option is not set when the package is loaded, it is set to \code{c("data.class", "dimension", "objectSize")}. } \examples{ \dontrun{ To list all objects in .GlobalEnv: > ll() member data.class dimension objectSize 1 *tmp* Person 1 428 2 as.character.Person function NULL 1208 3 country character 1 44 4 equals.Person function NULL 2324 5 filename character 1 84 6 getAge function NULL 372 7 getAge.Person function NULL 612 8 getName.Person function NULL 628 9 hashCode.Person function NULL 1196 10 last.warning list 1 192 11 obj Person 1 428 12 Person Class NULL 2292 13 setAge function NULL 372 14 setAge.Person function NULL 2088 15 setName function NULL 372 16 setName.Person function NULL 760 17 staticCode.Person function NULL 2372 To list all functions in the methods package: ll(mode="function", envir="methods") To list all numeric and character object in the base package: ll(mode=c("numeric", "character"), envir="base") To list all objects in the base package greater than 40kb: subset(ll(envir="base"), objectSize > 40000) } } \author{Henrik Bengtsson} \seealso{ \code{\link[utils]{ls.str}} and \code{\link{ll.Object}}(). } \keyword{utilities} R.oo/man/showContents.Package.Rd0000644000176200001440000000150414711170563016166 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{showContents.Package} \alias{showContents.Package} \alias{Package.showContents} \alias{showContents,Package-method} \title{Show the CONTENTS file of this package} \description{ Show the CONTENTS file of this package. If the \code{CONTENTS} file does not exist, an exception is thrown. } \usage{ \method{showContents}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getInstantiationTime.Object.Rd0000644000176200001440000000246214711170561017510 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getInstantiationTime.Object} \alias{getInstantiationTime.Object} \alias{Object.getInstantiationTime} \alias{getInstantiationTime,Object-method} \title{Gets the time when the object was instantiated} \description{ Gets the time when the object was instantiated (created) as a POSIXt object. } \usage{ \method{getInstantiationTime}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a POSIXt object, which extends class POSIXct. } \details{ The instantiation time stamp is set when the object is created, and only of option \code{"R.oo::BasicObject/instantiationTime"} is \code{\link[base:logical]{TRUE}}. } \examples{ oopts <- options("R.oo::Object/instantiationTime"=TRUE) obj <- Object() print(getInstantiationTime(obj)) options(oopts) } \seealso{ For more about time formats and POSIX see \code{\link[base]{DateTimeClasses}}. For more information see \code{\link{Object}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getDocPath.Package.Rd0000644000176200001440000000175614711170563015523 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getDocPath.Package} \alias{getDocPath.Package} \alias{Package.getDocPath} \alias{getDocPath,Package-method} \title{Gets the path to the accompanying documentation (doc/) directory of this package} \description{ Gets the path to the accompanying documentation (doc/) directory of this package. } \usage{ \method{getDocPath}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ print(list.files(getDocPath(R.oo))) # explicit call, or print(list.files(R.oo$docPath)) # as a virtual field } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/dimension.Rd0000644000176200001440000000242514711170563014126 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % dimension.default.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{dimension} \alias{dimension.default} \alias{dimension} \title{Gets the dimension of the object} \description{ Gets the dimension of the object similar to what \code{dim()} does, but instead of \code{\link[base]{NULL}} it will return the length of a vector. If a function is passed, \code{\link[base]{NULL}} is returned. } \usage{ \method{dimension}{default}(object, ...) } \arguments{ \item{object}{The object for which the dimension should be obtained.} \item{...}{Not used.} } \value{ Returns an \code{\link[base]{integer}} \code{\link[base]{vector}} or \code{\link[base]{NULL}}. } \examples{ dimension(matrix(1:100, ncol=10)) # 10 10 dimension(1:14) # 14 dimension(data.frame(a=1:10, b=10:1)) # 10 2 dimension(print) # NULL } \author{Henrik Bengtsson} \seealso{ \code{\link{ll.default}}(). \code{\link[base]{dim}}() and \code{\link[base]{length}}(). } \keyword{attribute} \keyword{utilities} \keyword{internal} R.oo/man/novirtual.Object.Rd0000644000176200001440000000155014711170561015365 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{novirtual.Object} \alias{novirtual.Object} \alias{Object.novirtual} \alias{novirtual,Object-method} \title{Returns a reference to the same Object with virtual fields turned off} \description{ Returns a reference to the same Object with virtual fields turned off. } \usage{ \method{novirtual}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an \code{\link[R.oo]{Object}}. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getMaintainer.Package.Rd0000644000176200001440000000245014711170563016260 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getMaintainer.Package} \alias{getMaintainer.Package} \alias{Package.getMaintainer} \alias{getMaintainer,Package-method} \title{Gets the Maintainer of this package} \description{ Gets the Maintainer of this package as specified by the \code{DESCRIPTION} file. } \usage{ \method{getMaintainer}{Package}(this, as=c("character", "person"), include=c("given", "family"), ...) } \arguments{ \item{as}{A \code{\link[base]{character}} string specifying the return format.} \item{include}{A \code{\link[base]{character}} \code{\link[base]{vector}} specifying which person fields to include if returning a \code{\link[base]{character}} string.} \item{...}{Optional arguments passed to \code{\link[utils]{format.person}}.} } \value{ Returns a \code{\link[base]{character}} string or a \code{\link[utils]{person}} object. } \examples{ pkg <- Package("R.oo") print(getMaintainer(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/hashCode.Rd0000644000176200001440000000230114711170564013651 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % hashCode.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{hashCode} \alias{hashCode.default} \alias{hashCode} \title{Gets an integer hashcoded for R objects} \description{ Gets an integer hashcoded for R objects. } \usage{ \method{hashCode}{default}(object, ...) } \arguments{ \item{object}{A \code{\link[base]{vector}} or \code{\link[base]{list}} of \R objects.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{vector}} of \code{\link[base]{integer}}'s. } \details{ A \code{\link[base]{character}} string is converted into a hashcode following Java conventions by \code{s[1]*31^(n-1) + s[2]*31^(n-2) + ... + s[n]} using integer arithmetic, where \code{s[i]} is the \code{i}:th character of the string, \code{n} is the length of the string. The hash value of the empty string is zero. For all other types, \code{as.integer()} is called by default. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{internal} R.oo/man/getStaticInstance.Object.Rd0000644000176200001440000000167214711170561016763 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getStaticInstance.Object} \alias{getStaticInstance.Object} \alias{Object.getStaticInstance} \alias{getStaticInstance,Object-method} \title{Gets the static instance of this objects class} \description{ Gets the static instance of this objects class. } \usage{ \method{getStaticInstance}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a reference to an \code{\link[R.oo]{Object}}. } \examples{ ex <- Exception("Oops!") obj <- getStaticInstance(ex) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getName.Class.Rd0000644000176200001440000000152314711170562014562 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getName.Class} \alias{getName.Class} \alias{Class.getName} \alias{getName,Class-method} \title{Gets the name of the class} \description{ Gets the name of the class. } \usage{ \method{getName}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ print(getName(Object)) # "Object" print(getName(Class)) # "Class" } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/R.oo-package.Rd0000644000176200001440000000725614711170562014355 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 999.package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{R.oo-package} \alias{R.oo-package} \alias{R.oo} \docType{package} \title{Package R.oo} \description{ Methods and classes for object-oriented programming in R with or without references. Large effort has been made on making definition of methods as simple as possible with a minimum of maintenance for package developers. The package has been developed since 2001 and is now considered very stable. This is a cross-platform package implemented in pure R that defines standard S3 classes without any tricks. Please note that the Rdoc syntax/grammar used to convert Rdoc comments in code into Rd files is not strictly defined and is modified by the need of the author. Ideally, there will be a well defined Rdoc language one day. } \section{Installation and updates}{ To install this package do\cr \code{install.packages("R.oo")} } \section{Dependencies and other requirements}{ This package requires a standard \R installation and the \pkg{R.methodsS3} package. } \section{To get started}{ To get started,It is very useful to understand that: \enumerate{ \item The \code{\link[R.methodsS3]{setMethodS3}}() function, which is defined in the \pkg{R.methodsS3} package (used to be part of \pkg{R.oo}), is nothing but a conveniency wrapper for setting up S3 methods, and automatically create an S3 generic function, if missing. For more information, see the help of \pkg{R.methodsS3}. \item The \code{\link{Object}} class is a top-level "root" class that provides support for \emph{reference variables}. Any class inheriting from this class supports reference variables. \item The \code{\link{Object}} class is basically a wrapper around an \code{\link[base]{environment}}, which some additional accessors etc. It is the environment data type that provides the "emulation" of reference variables - the Object class structure makes it easier to extends this class and adds some level of coding protection. The Object class features is not intended for referencing individual elements of basic \R data types, but rather for the whole variable of such. For instance, you can reassign a whole matrix \code{X} part of the object this way, but you cannot reassign \code{X[1,1]} without creating a completely new copy. } } \section{Further readings}{ For a detailed introduction to the package see [1] (part of the package distribution). } \section{How to cite this package}{ Whenever using this package, please cite [1] as\cr \preformatted{ Bengtsson, H. The R.oo package - Object-Oriented Programming with References Using Standard R Code, Proceedings of the 3rd International Workshop on Distributed Statistical Computing (DSC 2003), ISSN 1609-395X, Hornik, K.; Leisch, F. & Zeileis, A. (ed.), 2003 } } \author{Henrik Bengtsson} \section{License}{ The releases of this package is licensed under LGPL version 2.1 or newer. } \references{ [1] H. Bengtsson, \emph{The R.oo package - Object-Oriented Programming with References Using Standard R Code}, In Kurt Hornik, Friedrich Leisch and Achim Zeileis, editors, Proceedings of the 3rd International Workshop on Distributed Statistical Computing (DSC 2003), March 20-22, Vienna, Austria. \url{https://www.r-project.org/conferences/DSC-2003/Proceedings/} \cr } \seealso{ People interested in \pkg{R.oo} may also be interested in packages \pkg{proto} and \pkg{mutatr}. } \keyword{package} R.oo/man/000.makeObjectFinalizer.Rd0000644000176200001440000000307514711170561016347 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 020.makeObjectFinalizer,private.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{.makeObjectFinalizer} \alias{.makeObjectFinalizer} \title{Creates a standalone finalizer function for Object} \description{ Creates a standalone finalizer function for Object, which assumes only that the \pkg{base} package is available. } \usage{ .makeObjectFinalizer(this, reloadRoo=TRUE) } \arguments{ \item{this}{The \code{\link[R.oo]{Object}} to be finalized.} \item{reloadRoo}{If \code{\link[base:logical]{TRUE}}, the finalizer will try to temporary reload the \pkg{R.oo} package if not loaded.} } \value{ Returns a \code{\link[base]{function}} that can be passed to \code{\link[base]{reg.finalizer}}(). } \details{ The created finalizer is reentrant. This is always the case when the \pkg{R.oo} package is already loaded when the finalizer is called. It is also always the case on R v2.15.2 Patched r61487 and beyond. In other cases, the finalizer inspects the call stack (via \code{\link{sys.calls}}()) to check whether \code{\link[base]{parse}}() has been called or not. If it is on the call stack, it indicates that \code{\link[base]{parse}}() triggered the garbage collection, and the \pkg{R.oo} package will \emph{not} be reloaded in order to avoid risking \code{\link[base]{parse}}() being called again. } \keyword{internal} R.oo/man/getDevelUrl.Package.Rd0000644000176200001440000000210414711170563015707 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getDevelUrl.Package} \alias{getDevelUrl.Package} \alias{Package.getDevelUrl} \alias{getDevelUrl,Package-method} \title{Gets the URL(s) from where the developers version of this package can be installed} \description{ Gets the URL(s) from where the developers version of this package can be installed by looking for comma or semicolon separated URLs at the optional \code{DevelURL} line in the \code{DESCRIPTION} file of the package. } \usage{ \method{getDevelUrl}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a vector of \code{\link[base]{character}} strings. } \examples{ pkg <- Package("R.oo") print(getDevelUrl(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/print.Interface.Rd0000644000176200001440000000146114711170562015172 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Interface.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{print.Interface} \alias{print.Interface} \alias{Interface.print} \alias{print,Interface-method} \title{Prints an Interface} \description{ For all objects of class \code{\link{Interface}}, this method will print the value of \code{as.character()} of the object. } \usage{ \method{print}{Interface}(x, ...) } \arguments{ \item{...}{Not used.} } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Interface}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/isReferable.BasicObject.Rd0000644000176200001440000000166714711170562016541 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isReferable.BasicObject} \alias{isReferable.BasicObject} \alias{BasicObject.isReferable} \alias{isReferable,BasicObject-method} \title{Checks if the object is referable or not} \description{ Checks if the object is referable or not. } \usage{ \method{isReferable}{BasicObject}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{logical}} value, which by default is \code{\link[base:logical]{TRUE}} for all \code{\link{BasicObject}}'s. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getEnvironment.Object.Rd0000644000176200001440000000166014711170561016350 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getEnvironment.Object} \alias{getEnvironment.Object} \alias{Object.getEnvironment} \alias{getEnvironment,Object-method} \title{Gets the environment of this object} \description{ Gets the environment of this object. This is the environment where the members of the Object are stored. } \usage{ \method{getEnvironment}{Object}(fun, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an \code{\link[base]{environment}}. } \examples{ ll(R.oo) ll(envir=getEnvironment(R.oo)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/equals.Object.Rd0000644000176200001440000000421214711170561014632 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{equals.Object} \alias{equals.Object} \alias{Object.equals} \alias{equals,Object-method} \title{Compares an object with another} \description{ Compares an object with another and returns \code{\link[base:logical]{TRUE}} if they are equal. The equal property must be 1) \emph{reflexive}, i.e. \code{equals(o1,o1)} should be \code{\link[base:logical]{TRUE}}. 2) \emph{symmetric}, i.e. \code{equals(o1,o2)} is \code{\link[base:logical]{TRUE}} if and only if \code{equals(o2,o1)} is \code{\link[base:logical]{TRUE}}. 3) \emph{transitive}, i.e. \code{equals(o1,o2)} is \code{\link[base:logical]{TRUE}} and \code{equals(o2,o3)} is \code{\link[base:logical]{TRUE}}, then \code{equals(o1,o3)} should be \code{\link[base:logical]{TRUE}}. 5) \emph{consistent}, i.e. \code{equals(o1,o2)} should return the same result on multiple invocations as long as nothing has changed. 6) \code{equals(o1,}\code{\link[base]{NULL}}\code{)} should return \code{\link[base:logical]{FALSE}}, unless \code{o1} is also \code{\link[base]{NULL}}. By default, the method returns \code{\link[base:logical]{TRUE}} if and only if the two references compared refer to the same \code{\link[R.oo]{Object}}, i.e. \code{( !is.null(obj) && (hashCode(this) == hashCode(obj)) )}. } \usage{ \method{equals}{Object}(this, other, ...) } \arguments{ \item{other}{The other object this \code{\link[R.oo]{Object}} should be compared to.} \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the Object's are equal, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ o1 <- Object() o2 <- clone(o1) equals(o1, o1) # TRUE equals(o1, o2) # FALSE } \seealso{ \code{\link[R.oo:hashCode.Object]{*hashCode}()}. For more information see \code{\link{Object}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/equals.Rd0000644000176200001440000000333314711170563013432 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % equals.default.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{equals} \alias{equals.default} \alias{equals} \title{Compares an object with another} \description{ Compares an object with another and returns \code{\link[base:logical]{TRUE}} if they are equal. The equal property must be 1) \emph{reflexive}, i.e. \code{equals(o1,o1)} should be \code{\link[base:logical]{TRUE}}. 2) \emph{symmetric}, i.e. \code{equals(o1,o2)} is \code{\link[base:logical]{TRUE}} if and only if \code{equals(o2,o1)} is \code{\link[base:logical]{TRUE}}. 3) \emph{transitive}, i.e. \code{equals(o1,o2)} is \code{\link[base:logical]{TRUE}} and \code{equals(o2,o3)} is \code{\link[base:logical]{TRUE}}, then \code{equals(o1,o3)} should be \code{\link[base:logical]{TRUE}}. 5) \emph{consistent}, i.e. \code{equals(o1,o2)} should return the same result on multiple invocations as long as nothing has changed. 6) \code{equals(o1,}\code{\link[base]{NULL}}\code{)} should return \code{\link[base:logical]{FALSE}}, unless \code{o1} is also \code{\link[base]{NULL}}. By default \code{\link[base]{identical}}() is used. } \usage{ \method{equals}{default}(object, other, ...) } \arguments{ \item{object, other}{Objects to be compared.} \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the objects are equal, otherwise \code{\link[base:logical]{FALSE}}. } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{identical}}(). } \keyword{attribute} \keyword{utilities} \keyword{internal} R.oo/man/extend.BasicObject.Rd0000644000176200001440000000246614711170612015577 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{extend.BasicObject} \alias{extend.BasicObject} \alias{BasicObject.extend} \alias{extend,BasicObject-method} \title{Extends another class} \description{ via a mechanism known as "parasitic inheritance". Simply speaking this method "extends another class". What is actually happening is that it creates an instance of class name \code{...className}, by taking another BasicObject instance and add \code{...className} to the class list and also add all the named values in \code{...} as fields to the new instance. The method should be used by the constructor of a class and nowhere else. } \usage{ \method{extend}{BasicObject}(this, ...className, ...) } \arguments{ \item{...className}{The name of new class.} \item{...}{Named values representing the fields of the new instance.} } \value{ Returns a BasicObject of class \code{className}. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getChangeLog.Package.Rd0000644000176200001440000000304714711170563016023 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getChangeLog.Package} \alias{getChangeLog.Package} \alias{Package.getChangeLog} \alias{getChangeLog,Package-method} \alias{Package.getNews} \alias{getNews.Package} \alias{getNews,Package-method} \alias{Package.getHistory} \alias{getHistory.Package} \alias{getHistory,Package-method} \title{Gets the change log of this package} \description{ Gets the change log of this package, that is, (by default) the \code{NEWS} (then the \code{HISTORY} and \code{ChangeLog}) file, which should is expected to be located in the root directory of the package, i.e. \code{\link[R.oo:getPath.Package]{*getPath}()}. } \usage{ \method{getChangeLog}{Package}(this, filenames=c("NEWS", "HISTORY", "ChangeLog"), newline="\n", ...) } \arguments{ \item{filenames}{A \code{\link[base]{character}} \code{\link[base]{vector}} of (non-case sensitive) filenames to be searched for.} \item{newline}{The \code{\link[base]{character}} string to collapse lines in the file.} \item{...}{Not used.} } \value{ Returns the complete contents of the change log file as a \code{\link[base]{character}} string. If not found, \code{\link[base]{NULL}} is returned. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getLastException.Exception.Rd0000644000176200001440000000216714711170562017362 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Exception$getLastException} \alias{Exception$getLastException} \alias{getLastException.Exception} \alias{Exception.getLastException} \alias{getLastException,Exception-method} \title{Static method to get the last Exception thrown} \description{ Static method to get the last Exception created. } \usage{ ## Static method (use this): ## Exception$getLastException(...) ## Don't use the below: \method{getLastException}{Exception}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an \code{\link{Exception}} object. } \examples{\dontrun{For a complete example see help(Exception).}} \seealso{ For more information see \code{\link{Exception}}. See also \code{\link[base:conditions]{tryCatch}()}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/DOLLARLT_-.BasicObject.Rd0000644000176200001440000000232114711170612015727 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{DOLLAR< -.BasicObject} \alias{$<-.BasicObject} \alias{BasicObject.$<-} \alias{$<-,BasicObject-method} \alias{BasicObject.[[<-} \alias{[[<-.BasicObject} \alias{[[<-,BasicObject-method} \title{Makes the fields and methods of a BasicObject assignable via the $<- and the [[<- operator} \description{ Makes the fields and methods of a BasicObject assignable via the $<- and the [[<- operator. } \usage{ \method{$}{BasicObject}(this, name) <- value \method{[[}{BasicObject}(this, name) <- value } \arguments{ \item{name}{The name of the \preformatted{set()} method or the name of the field to be assigned the new value.} \item{value}{The value to be assigned.} } \value{ Returns itself, i.e. \code{this}, as all \code{$<-} methods must do. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/ll.Package.Rd0000644000176200001440000000271614711170563014105 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{ll.Package} \alias{ll.Package} \alias{Package.ll} \alias{ll,Package-method} \title{Generates a list of informative properties of all members of the package} \description{ Generates a list of informative properties of all members of the package. If the package is not loaded, it will be loaded, the members will be retrieved and then the package will be unloaded again. } \usage{ \method{ll}{Package}(this, envir=pos.to.env(getPosition(this)), ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{data.frame}}. } \details{ Note the difference from the default definition of \code{ll()} as inherited from the \code{\link[R.oo]{Object}} class. Here \code{ll()} has been redefined to list the members of the package, i.e. the members in the environment on search path that belongs to the package, whereas the original usage was to list the members of the Object. However, since the internal members of Package object is not of interest we decided on this definition instead. } \examples{ \dontrun{ll(R.oo)} } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getUsage.Rdoc.Rd0000644000176200001440000000232214711170563014567 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$getUsage} \alias{Rdoc$getUsage} \alias{getUsage.Rdoc} \alias{Rdoc.getUsage} \alias{getUsage,Rdoc-method} \title{Gets the usage of a method} \description{ Gets the usage of a method. } \usage{ ## Static method (use this): ## Rdoc$getUsage(method, class=NULL, wrap=90L, indent=2L, ...) ## Don't use the below: \method{getUsage}{Rdoc}(static, method, class=NULL, wrap=90L, indent=2L, ...) } \arguments{ \item{method}{A method name (\code{\link[base]{character}} string).} \item{class}{An optional class name (\code{\link[base]{character}} string).} \item{wrap}{An \code{\link[base]{integer}} specifying the maximum number of characters per line. Longer lines will be wrapped with newlines.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getStackTraceString.Exception.Rd0000644000176200001440000000165014711170562020007 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getStackTraceString.Exception} \alias{getStackTraceString.Exception} \alias{Exception.getStackTraceString} \alias{getStackTraceString,Exception-method} \title{Gets the stack trace as a string} \description{ . } \usage{ \method{getStackTraceString}{Exception}(this, ..., details=TRUE) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \seealso{ \code{\link[R.oo:getStackTrace.Exception]{*getStackTrace}()}. For more information see \code{\link{Exception}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/getPackage.Class.Rd0000644000176200001440000000164214711170562015237 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getPackage.Class} \alias{getPackage.Class} \alias{Class.getPackage} \alias{getPackage,Class-method} \title{Gets the package to which the class belongs} \description{ Gets the package to which the class belongs. } \usage{ \method{getPackage}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link{Package}}. } \examples{ print(getPackage(Object)) } \author{Henrik Bengtsson} \seealso{ \code{\link{Package}}. \code{\link[base]{class}}(). \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getPackageNameOf.Rdoc.Rd0000644000176200001440000000242114711170563016144 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$getPackageNameOf} \alias{Rdoc$getPackageNameOf} \alias{getPackageNameOf.Rdoc} \alias{Rdoc.getPackageNameOf} \alias{getPackageNameOf,Rdoc-method} \title{Gets the package of a method or an object} \description{ Gets the package of a method or an object. } \usage{ ## Static method (use this): ## Rdoc$getPackageNameOf(objectName, mode="any", unique=TRUE, ...) ## Don't use the below: \method{getPackageNameOf}{Rdoc}(static, objectName, mode="any", unique=TRUE, ...) } \arguments{ \item{objectName}{An method or object name (\code{\link[base]{character}} string).} \item{mode}{Mode of object (\code{\link[base]{character}} string).} \item{unique}{If \code{\link[base:logical]{TRUE}}, only the first matching package is returned if more than one is found.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getConstructorS3.Rd0000644000176200001440000000145114711170564015373 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % getConstructorS3.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getConstructorS3} \alias{getConstructorS3.default} \alias{getConstructorS3} \title{Get a constructor method} \description{ Get a constructor method. } \usage{ \method{getConstructorS3}{default}(name, ...) } \arguments{ \item{name}{The name of the constructor function.} \item{...}{Not used.} } \seealso{ \code{\link{setConstructorS3}}(). \code{\link[R.methodsS3]{getMethodS3}}. \code{\link[R.methodsS3]{isGenericS3}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} R.oo/man/ASCII.Rd0000644000176200001440000000144214711170562012766 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % ASCII.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{ASCII} \alias{ASCII} \alias{ASCII.BEL} \alias{ASCII.BS} \alias{ASCII.HT} \alias{ASCII.LF} \alias{ASCII.FF} \alias{ASCII.CR} \alias{ASCII.SO} \alias{ASCII.SI} \alias{ASCII.DC1} \alias{ASCII.DC3} \alias{ASCII.ESC} \title{8-bit ASCII table} \description{ ASCII is the 8-bit ASCII table with ASCII characters from 0-255. } \examples{ ch <- ASCII[65+1]; # ch == "A" } \author{Henrik Bengtsson} \seealso{ \code{\link{charToInt}}() \code{\link{intToChar}}() } \keyword{character} \keyword{internal} R.oo/man/getLicense.Package.Rd0000644000176200001440000000156314711170563015557 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getLicense.Package} \alias{getLicense.Package} \alias{Package.getLicense} \alias{getLicense,Package-method} \title{Gets the License of this package} \description{ Gets the License of this package as specified by the \code{DESCRIPTION} file. } \usage{ \method{getLicense}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ pkg <- Package("R.oo") print(getLicense(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/extend.Interface.Rd0000644000176200001440000000162614711170562015330 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Interface.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{extend.Interface} \alias{extend.Interface} \alias{Interface.extend} \alias{extend,Interface-method} \title{Extends another Interface class} \description{ Extends another Interface class. } \usage{ \method{extend}{Interface}(this, ...className, ...) } \arguments{ \item{...className}{The name of new interface.} \item{...}{Named values representing the fields of the new instance.} } \value{ Returns an Interface of class \code{className}. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Interface}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getRdTitle.Rdoc.Rd0000644000176200001440000000207014711170563015072 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$getRdTitle} \alias{Rdoc$getRdTitle} \alias{getRdTitle.Rdoc} \alias{Rdoc.getRdTitle} \alias{getRdTitle,Rdoc-method} \title{Extracts the title string of a Rd file} \description{ Extracts the title string of a Rd file corresponding the the specified method of the specified class. } \usage{ ## Static method (use this): ## Rdoc$getRdTitle(class, method, ...) ## Don't use the below: \method{getRdTitle}{Rdoc}(this, class, method, ...) } \arguments{ \item{method}{The method to be search for.} \item{class}{The class the method belongs to.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/unload.Package.Rd0000644000176200001440000000204714711170563014755 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{unload.Package} \alias{unload.Package} \alias{Package.unload} \alias{unload,Package-method} \title{Unloads a package} \description{ Unloads a package. This is an alternative way to use \code{detach()} to unload a package. If the package is not loaded, it will quietly return. } \usage{ \method{unload}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns nothing. } \examples{\dontrun{ pkg <- Package("boot") load(pkg) print(isLoaded(pkg)) unload(pkg) print(isLoaded(pkg)) }} \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:load.Package]{*load}()}. \code{\link[R.oo:isLoaded.Package]{*isLoaded}()}. \code{\link[base]{search}}(). For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/setConstructorS3.Rd0000644000176200001440000001043014711170561015401 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 040.setConstructorS3.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{setConstructorS3} \alias{setConstructorS3.default} \alias{setConstructorS3} \title{Defines a class in S3/UseMethod style} \description{ Defines a class in R.oo/S3 style. What this function currently does is simply creating a constructor function for the class. } \usage{ \method{setConstructorS3}{default}(name, definition, private=FALSE, protected=FALSE, export=TRUE, static=FALSE, abstract=FALSE, trial=FALSE, deprecated=FALSE, envir=parent.frame(), enforceRCC=TRUE, ...) } \arguments{ \item{name}{The name of the class.} \item{definition}{The constructor definition. \emph{Note: The constructor must be able to be called with no arguments, i.e. use default values for all arguments or make sure you use \code{missing()} or similar!}} \item{static}{If \code{\link[base:logical]{TRUE}} this class is defined to be static, otherwise not. Currently this has no effect expect as an indicator.} \item{abstract}{If \code{\link[base:logical]{TRUE}} this class is defined to be abstract, otherwise not. Currently this has no effect expect as an indicator.} \item{private}{If \code{\link[base:logical]{TRUE}} this class is defined to be private.} \item{protected}{If \code{\link[base:logical]{TRUE}} this class is defined to be protected.} \item{export}{A \code{\link[base]{logical}} setting attribute \code{"export"}.} \item{trial}{If \code{\link[base:logical]{TRUE}} this class is defined to be a trial class, otherwise not. A trial class is a class that is introduced to be tried out and it might be modified, replaced or even removed in a future release. Some people prefer to call trial versions, beta version. Currently this has no effect expect as an indicator.} \item{deprecated}{If \code{\link[base:logical]{TRUE}} this class is defined to be deprecated, otherwise not. Currently this has no effect expect as an indicator.} \item{envir}{The environment for where the class (constructor function) should be stored.} \item{enforceRCC}{If \code{\link[base:logical]{TRUE}}, only class names following the R Coding Convention is accepted. If the RCC is violated an RccViolationException is thrown.} \item{...}{Not used.} Note: If a constructor is not declared to be private nor protected, it will be declared to be public. } \section{A constructor must be callable without arguments}{ The requirement that a constructor function should be callable without arguments (e.g. \code{MyConstructor()}) is because that call is used to create the static instance of a class. The reason for this is that a static instance of the class is created automatically when the constructor is called \emph{the first time} (only), that is, when the first of object of that class is created. All classes have to have a static instance. To make a constructor callable without arguments, one can either make sure all arguments have default values or one can test for missing arguments using \code{missing()}. For instance the following definition is \emph{not} correct: \code{setConstructorS3("Foo", function(x) extend(Object(), "Foo", x=x))} whereas this one is \code{setConstructorS3("Foo", function(x=NA) extend(Object(), "Foo", x=x))} } \section{Code validation}{ If argument \code{enforceRCC} is \code{\link[base:logical]{TRUE}}, the class name is validated so it starts with a letter and it also gives a \code{\link[base]{warning}} if its first letter is \emph{not} capital. The reason for this is to enforce a naming convention that names classes with upper-case initial letters and methods with lower-case initial letters (this is also the case in for instance Java). } \examples{\dontrun{For a complete example see help(Object).}} \seealso{ To define a method see \code{\link[R.methodsS3]{setMethodS3}}. For information about the R Coding Conventions, see \code{\link{RccViolationException}}. For a thorough example of how to use this method see \code{\link{Object}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} R.oo/man/isReferable.Object.Rd0000644000176200001440000000163014711170561015564 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isReferable.Object} \alias{isReferable.Object} \alias{Object.isReferable} \alias{isReferable,Object-method} \title{Checks if the object is referable or not} \description{ Checks if the object is referable or not. } \usage{ \method{isReferable}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{logical}} value, which by default is \code{\link[base:logical]{TRUE}} for all \code{\link[R.oo]{Object}}'s. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/declaration.Rdoc.Rd0000644000176200001440000000157214711170563015316 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$declaration} \alias{Rdoc$declaration} \alias{declaration.Rdoc} \alias{Rdoc.declaration} \alias{declaration,Rdoc-method} \title{Gets the class declaration} \description{ Gets the class declaration. } \usage{ ## Static method (use this): ## Rdoc$declaration(class, ...) ## Don't use the below: \method{declaration}{Rdoc}(this, class, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getWhen.Exception.Rd0000644000176200001440000000163014711170562015473 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getWhen.Exception} \alias{getWhen.Exception} \alias{Exception.getWhen} \alias{getWhen,Exception-method} \title{Gets the time when the Exception was created} \description{ Gets the time, as a POSIX object, when the Exception was created. } \usage{ \method{getWhen}{Exception}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a POSIX time object. } \examples{\dontrun{For a complete example see help(Exception).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Exception}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/methodsInheritedFrom.Rdoc.Rd0000644000176200001440000000233014711170563017145 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$methodsInheritedFrom} \alias{Rdoc$methodsInheritedFrom} \alias{methodsInheritedFrom.Rdoc} \alias{Rdoc.methodsInheritedFrom} \alias{methodsInheritedFrom,Rdoc-method} \title{Gets all methods inherited from a class in Rd format} \description{ Gets all methods inherited from a class in Rd format. } \usage{ ## Static method (use this): ## Rdoc$methodsInheritedFrom(class, visibility=c("public", "protected", "private"), ## showDeprecated=FALSE, inheritedFrom=NULL, sort=TRUE, trial=FALSE, ...) ## Don't use the below: \method{methodsInheritedFrom}{Rdoc}(this, class, visibility=c("public", "protected", "private"), showDeprecated=FALSE, inheritedFrom=NULL, sort=TRUE, trial=FALSE, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/as.character.Interface.Rd0000644000176200001440000000150014711170562016366 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Interface.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.Interface} \alias{as.character.Interface} \alias{Interface.as.character} \alias{as.character,Interface-method} \title{Gets a character string representing the Interface} \description{ Gets a character string representing the Interface. } \usage{ \method{as.character}{Interface}(x, ...) } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Interface}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/newInstance.BasicObject.Rd0000644000176200001440000000206414711170562016564 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{newInstance.BasicObject} \alias{newInstance.BasicObject} \alias{BasicObject.newInstance} \alias{newInstance,BasicObject-method} \title{Creates a new instance of the same class as this object} \description{ Creates a new instance of the same class as this object. } \usage{ \method{newInstance}{BasicObject}(this, ...) } \arguments{ \item{...}{Arguments passed to the constructor of the corresponding \code{\link{BasicObject}} class.} } \value{ Returns a reference to an instance of \code{\link{BasicObject}} or a subclass thereof. } \author{Henrik Bengtsson} \seealso{ \code{\link{newInstance.Object}}(). \code{\link{newInstance.Class}}(). For more information see \code{\link{BasicObject}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/as.character.Class.Rd0000644000176200001440000000163614711170562015545 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.Class} \alias{as.character.Class} \alias{Class.as.character} \alias{as.character,Class-method} \title{Returns a short string describing the class} \description{ Returns a short string describing the class. } \usage{ \method{as.character}{Class}(x, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ print(as.character(Object)) # gives: "Class Object: no fields, 8 methods (no inherited)" } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getFields.Object.Rd0000644000176200001440000000256214711170561015254 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getFields.Object} \alias{getFields.Object} \alias{Object.getFields} \alias{getFields,Object-method} \alias{Object.names} \alias{names.Object} \alias{names,Object-method} \title{Returns the field names of an Object} \description{ Returns the field names of an Object. } \usage{ \method{getFields}{Object}(this, private=FALSE, ...) } \arguments{ \item{private}{If \code{\link[base:logical]{TRUE}}, private fields will also be returned, otherwise only public fields are returned.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} \code{\link[base]{vector}} of field names. } \examples{ obj <- Object() obj$x <- 1:100 obj$y <- 100:1 getFields(obj) \dontrun{ gives: [1] "x" "y" } } \author{Henrik Bengtsson} \seealso{ To check if a field exists or not, see \code{\link[R.oo:hasField.Object]{*hasField}()}. For more extensive information about the fields in an Object see \code{\link[R.oo:ll.Object]{*ll}()}. For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/isPrivate.Class.Rd0000644000176200001440000000204214711170562015145 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isPrivate.Class} \alias{isPrivate.Class} \alias{Class.isPrivate} \alias{isPrivate,Class-method} \title{Checks if a class is defined private or not} \description{ Checks if a class is defined private or not. } \usage{ \method{isPrivate}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the class is private, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ if (isPrivate(RccViolationException)) throw("The class RccViolationException should NOT be private.") } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{class}}(). \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/startupMessage.Package.Rd0000644000176200001440000000161614711170563016503 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{startupMessage.Package} \alias{startupMessage.Package} \alias{Package.startupMessage} \alias{startupMessage,Package-method} \title{Generates a 'package successfully loaded' package startup message} \description{ Generates a 'package successfully loaded' package startup message. } \usage{ \method{startupMessage}{Package}(this, ...) } \arguments{ \item{...}{Additional arguments passed to \code{\link[R.methodsS3]{pkgStartupMessage}}.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/uses.Interface.Rd0000644000176200001440000000154514711170562015020 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Interface.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{uses.Interface} \alias{uses.Interface} \alias{Interface.uses} \alias{uses,Interface-method} \alias{uses} \alias{uses.character} \title{Specifies that an object uses this Interface} \description{ Specifies that an object uses this Interface. } \usage{ \method{uses}{Interface}(this, ...) } \value{ Returns a \code{\link[base]{character}} \code{\link[base]{vector}} of class names of Interface:s. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Interface}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/equals.BasicObject.Rd0000644000176200001440000000365014711170562015602 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{equals.BasicObject} \alias{equals.BasicObject} \alias{BasicObject.equals} \alias{equals,BasicObject-method} \title{Compares an object with another} \description{ Compares an object with another and returns \code{\link[base:logical]{TRUE}} if they are equal. The equal property must be 1) \emph{reflexive}, i.e. \code{equals(o1,o1)} should be \code{\link[base:logical]{TRUE}}. 2) \emph{symmetric}, i.e. \code{equals(o1,o2)} is \code{\link[base:logical]{TRUE}} if and only if \code{equals(o2,o1)} is \code{\link[base:logical]{TRUE}}. 3) \emph{transitive}, i.e. \code{equals(o1,o2)} is \code{\link[base:logical]{TRUE}} and \code{equals(o2,o3)} is \code{\link[base:logical]{TRUE}}, then \code{equals(o1,o3)} should be \code{\link[base:logical]{TRUE}}. 5) \emph{consistent}, i.e. \code{equals(o1,o2)} should return the same result on multiple invocations as long as noting has changed. 6) \code{equals(o1,NULL)} should return \code{\link[base:logical]{FALSE}}. By default, the method returns \code{\link[base:logical]{TRUE}} if and only if the two references compared refer to the same \code{\link{BasicObject}}, i.e. \code{( !is.null(obj) && (hashCode(this) == hashCode(obj)) )}. } \usage{ \method{equals}{BasicObject}(this, other, ...) } \arguments{ \item{other}{The other object this object should be compared to.} \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the objects are equal, otherwise \code{\link[base:logical]{FALSE}}. } \seealso{ For more information see \code{\link{BasicObject}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/print.Object.Rd0000644000176200001440000000170514711170561014500 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{print.Object} \alias{print.Object} \alias{Object.print} \alias{print,Object-method} \title{Prints an Object} \description{ For all objects of class \code{\link{Object}}, this method will print the value of \code{as.character()} of the object. Note that this function is not called if the argument is not an object of class \code{\link[R.oo]{Object}}. } \usage{ \method{print}{Object}(x, ...) } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ \code{\link[base]{print.default}}() For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/check.Rdoc.Rd0000644000176200001440000000201314711170563014075 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{check.Rdoc} \alias{check.Rdoc} \alias{Rdoc.check} \alias{check,Rdoc-method} \title{Checks the compiled Rd files} \description{ Checks the compiled Rd files. } \usage{ \method{check}{Rdoc}(this, manPath=getManPath(this), verbose=FALSE, ...) } \arguments{ \item{manPath}{The path to the Rd files (\code{\link[base]{character}} string).} \item{verbose}{If \code{\link[base:logical]{TRUE}}, extra information is outputted.} \item{...}{Not used.} } \value{ Returns a printable object, which, if non-empty will show the errors. } \details{ Internally the \code{tools} package is used. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/ll.Object.Rd0000644000176200001440000000226214711170561013752 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{ll.Object} \alias{ll.Object} \alias{Object.ll} \alias{ll,Object-method} \title{Generates a list of informative properties of all members of an Object} \description{ Generates a list of informative properties of all members of an Object. } \usage{ \method{ll}{Object}(this, ...) } \arguments{ \item{...}{Any arguments accepted by the underlying function \code{ll()}.} } \value{ Returns a \code{\link[base]{data.frame}} containing information about all the members. } \examples{ obj <- Object() obj$x <- 1:100 obj$y <- 100:1 ll(obj) \dontrun{ gives: member data.class dimension objectSize 1 x numeric 100 424 2 y numeric 100 424 } } \author{Henrik Bengtsson} \seealso{ \code{\link{ll.default}}(). For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/hierarchy.Rdoc.Rd0000644000176200001440000000155014711170563015003 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$hierarchy} \alias{Rdoc$hierarchy} \alias{hierarchy.Rdoc} \alias{Rdoc.hierarchy} \alias{hierarchy,Rdoc-method} \title{Gets the class hierarchy} \description{ Gets the class hierarchy. } \usage{ ## Static method (use this): ## Rdoc$hierarchy(class, ...) ## Don't use the below: \method{hierarchy}{Rdoc}(this, class, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/isVisible.Rdoc.Rd0000644000176200001440000000230014711170563014750 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$isVisible} \alias{Rdoc$isVisible} \alias{isVisible.Rdoc} \alias{Rdoc.isVisible} \alias{isVisible,Rdoc-method} \title{Checks if a member is visible given its modifiers} \description{ Checks if a member is visible given its modifiers. } \usage{ ## Static method (use this): ## Rdoc$isVisible(modifiers, visibilities, ...) ## Don't use the below: \method{isVisible}{Rdoc}(static, modifiers, visibilities, ...) } \arguments{ \item{modifiers}{A \code{\link[base]{character}} string of modifiers.} \item{visibilities}{A \code{\link[base]{character}} string of visibility flags.} \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the modifiers are equal or higher than the visibility flags, otherwise \code{\link[base:logical]{FALSE}}. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getPosition.Package.Rd0000644000176200001440000000166514711170563016004 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getPosition.Package} \alias{getPosition.Package} \alias{Package.getPosition} \alias{getPosition,Package-method} \title{Gets the search path position of the package} \description{ Gets the search path position of the package. } \usage{ \method{getPosition}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ An \code{\link[base]{integer}}. } \examples{ pkg <- Package("base") print(getPosition(pkg)) } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getEnvironment.Package]{*getEnvironment}()}. \code{\link[base]{search}}(). For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getContents.Package.Rd0000644000176200001440000000152614711170563015771 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getContents.Package} \alias{getContents.Package} \alias{Package.getContents} \alias{getContents,Package-method} \title{Gets the contents of this package} \description{ Gets the contents of this package, i.e. the parsed \code{CONTENTS} file. } \usage{ \method{getContents}{Package}(this, fields=NULL, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{data.frame}}. } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{dcf}}. For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getRccUrl.RccViolationException.Rd0000644000176200001440000000240314711170563020301 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % RccViolationException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{RccViolationException$getRccUrl} \alias{RccViolationException$getRccUrl} \alias{getRccUrl.RccViolationException} \alias{RccViolationException.getRccUrl} \alias{getRccUrl,RccViolationException-method} \title{Static method to get a URL where the RCC can be found} \description{ Static method to get a URL where one can find details about the R Code Convention (RCC). Currently the URL is \url{https://aroma-project.org/developers/RCC/}. } \usage{ ## Static method (use this): ## RccViolationException$getRccUrl(...) ## Don't use the below: \method{getRccUrl}{RccViolationException}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{\dontrun{For a complete example see help(RccViolationException).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{RccViolationException}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/abort.Rd0000644000176200001440000000423514711170563013251 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % abort.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{abort} \alias{abort.default} \alias{abort} \alias{abort.condition} \title{Aborts the current expression call} \description{ Aborts the current expression call and returns to the top level prompt/browser \emph{without signaling a condition}. } \usage{ \method{abort}{default}(..., call.=TRUE, domain=NULL) } \arguments{ \item{...}{(optional) Objects coerced to \code{\link[base]{character}} and pasted together without a separator, or a @condition object. If no object are given, no message is printed.} \item{call.}{If \code{\link[base:logical]{TRUE}}, the call is added to the message, otherwise not.} \item{domain}{Used to translate the message (see \code{\link[base]{gettext}}()). If \code{\link[base]{NA}}, messages will not be translated.} } \value{ Returns nothing. } \details{ There are still cases where one can "catch" the abort and undo it, cf. [1]. } \examples{\dontrun{ foo <- function() { cat("foo()...\n") on.exit(cat("foo()...done\n")) tryCatch({ stop("Woops!") }, error = function(ex) { cat("An error was caught: ", ex$message, "\n", sep="") }) cat("Continuing...\n") } bar <- function() { cat("bar()...\n") on.exit(cat("bar()...done\n")) tryCatch({ abort("Woops!") }, error = function(ex) { cat("An error was caught: ", ex$message, "\n", sep="") }) cat("This message will never be displayed...\n") } # An error generated by stop() can be caught foo() # ...which is not possible when using abort() bar() # This expression is never reached cat("This line will never be outputted.\n") }} \author{Henrik Bengtsson} \seealso{ \code{\link{throw}}(). \code{\link[base]{stop}}(). Internally, \code{\link[base]{invokeRestart}}()\code{("abort")} is utilized. } \references{ [1] R-devel thread '', Sept 11, 2012, \url{https://stat.ethz.ch/pipermail/r-devel/2012-September/064838.html}.\cr } \keyword{error} \keyword{internal} R.oo/man/getKnownSubclasses.Class.Rd0000644000176200001440000000260714711170562017032 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getKnownSubclasses.Class} \alias{getKnownSubclasses.Class} \alias{Class.getKnownSubclasses} \alias{getKnownSubclasses,Class-method} \title{Gets all subclasses that are currently loaded} \description{ Gets all subclasses that are currently loaded. } \usage{ \method{getKnownSubclasses}{Class}(this, sort=TRUE, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{vector}} of \code{\link[base]{character}} strings. } \examples{ \dontrun{ # Due to a bug in R CMD check (R v1.7.1) the MicroarrayData$read() call # below will call getKnownSubclasses(), which will generate # "Error in exists(objectName, mode = "function") : # [2003-07-07 23:32:41] Exception: F used instead of FALSE" # Note that the example still work, just not in R CMD check print(getKnownSubclasses(Exception)) } \dontrun{ returns [1] "Exception" "try-error" "Object" } } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getSuperclasses.Class]{*getSuperclasses}()}. For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getRdHierarchy.classRepresentation.Rd0000644000176200001440000000136014711170563021071 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % classRepresentation.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getRdHierarchy.classRepresentation} \alias{getRdHierarchy.classRepresentation} \title{Gets the class hierarchy in Rd format} \description{ Gets the class hierarchy in Rd format. } \usage{ \method{getRdHierarchy}{classRepresentation}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \keyword{methods} \keyword{internal} \keyword{documentation} R.oo/man/objectSize.BasicObject.Rd0000644000176200001440000000206414711170562016407 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{objectSize.BasicObject} \alias{objectSize.BasicObject} \alias{BasicObject.objectSize} \alias{objectSize,BasicObject-method} \title{Gets the size of the BasicObject in bytes} \description{ Gets the size of the BasicObject in bytes by summing the sizes of all its members. For this reason, the size of memory the BasicObject actually allocates might vary slightly. } \usage{ \method{objectSize}{BasicObject}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an \code{\link[base]{integer}} specifying the size of the object in number of bytes. } \author{Henrik Bengtsson} \seealso{ \code{\link[utils]{object.size}}. For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getBundle.Package.Rd0000644000176200001440000000231414711170563015401 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getBundle.Package} \alias{getBundle.Package} \alias{Package.getBundle} \alias{getBundle,Package-method} \title{Gets the Bundle that this package might belong to} \description{ Gets the Bundle that this package might belong to as specified by the \code{DESCRIPTION} file. } \usage{ \method{getBundle}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ If the package is part of a bundle, the name of the bundle is returned. Otherwise, \code{\link[base]{NULL}} is returned. } \details{ The first call to this method is normally slow because all installed packages are scanned. The result of this first call is cached and used as the return value for all subsequent calls, which are then much faster. } \examples{\donttest{ pkg <- Package("R.oo") print(getBundle(pkg)) }} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/newInstance.Class.Rd0000644000176200001440000000217514711170562015464 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{newInstance.Class} \alias{newInstance.Class} \alias{Class.newInstance} \alias{newInstance,Class-method} \title{Creates a new instance of this class} \description{ Creates a new instance of this class. Important: It should always be possible to create a new Object by calling the constructor without arguments. This method is simply calling the constructor method of the class. } \usage{ \method{newInstance}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a reference to an \code{\link{Object}}. } \examples{ obj <- newInstance(Object, NA) # equivalent to obj <- Object(NA) } \author{Henrik Bengtsson} \seealso{ \code{\link{newInstance.Object}}(). \code{\link{newInstance.BasicObject}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/setNameFormat.Rdoc.Rd0000644000176200001440000000244614711170563015577 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$setNameFormat} \alias{Rdoc$setNameFormat} \alias{setNameFormat.Rdoc} \alias{Rdoc.setNameFormat} \alias{setNameFormat,Rdoc-method} \title{Sets the current name format} \description{ Sets the current name format. Throws a \code{\link{RccViolationException}} if an unknown format is requested. } \usage{ ## Static method (use this): ## Rdoc$setNameFormat(nameFormat, ...) ## Don't use the below: \method{setNameFormat}{Rdoc}(static, nameFormat, ...) } \arguments{ \item{nameFormat}{ If \code{"method.class"}, help files for methods belonging to classes are named .. If \code{"class.method"}, help files for methods belonging to classes are named .. These are currently the only name formats supported. } \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getNameFormat.Rdoc]{*getNameFormat}()} For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/argsToString.Class.Rd0000644000176200001440000000211014711170562015621 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Class$argsToString} \alias{Class$argsToString} \alias{argsToString.Class} \alias{Class.argsToString} \alias{argsToString,Class-method} \title{Gets the arguments of a function as a character string} \description{ Gets the arguments (with default values) of a function as a character string, which can be used for debugging purposes etc. Used by: classinfo(). } \usage{ ## Static method (use this): ## Class$argsToString(fcn, ...) ## Don't use the below: \method{argsToString}{Class}(this, fcn, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ Class$argsToString(plot) } \seealso{ For more information see \code{\link{Class}}. } \author{Henrik Bengtsson} \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/DOLLAR.BasicObject.Rd0000644000176200001440000000223414711170612015256 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{DOLLAR.BasicObject} \alias{$.BasicObject} \alias{BasicObject.$} \alias{$,BasicObject-method} \alias{BasicObject.[[} \alias{[[.BasicObject} \alias{[[,BasicObject-method} \title{Makes the fields and methods of a BasicObject accessible via the $ and the [[ operator} \description{ Makes the fields and methods of a BasicObject accessible via the $ and the [[ operator. } \usage{ \method{$}{BasicObject}(this, name) \method{[[}{BasicObject}(this, name, exact=TRUE) } \arguments{ \item{name}{The name of the field or method to be accessed.} } \value{ Returns the value of a field or a method (\code{\link[base]{function}}). If no such field or method exists, \code{\link[base]{NULL}} is returned. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/intToChar.Rd0000644000176200001440000000241414711170562014031 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % ASCII.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{intToChar} \alias{intToChar.default} \alias{intToChar} \title{Converts a vector of integers into a vector of ASCII characters} \description{ Converts a vector of ASCII integers to a equal length vector of ASCII characters. To make sure that all values in the input vector are in the range [0,255], the input vector is taken modulo 256. } \usage{ \method{intToChar}{default}(i, ...) } \arguments{ \item{i}{An \code{\link[base]{integer}} \code{\link[base]{vector}}.} \item{...}{Not used.} } \value{ Returns an ASCII \code{\link[base]{character}} \code{\link[base]{vector}}. } \author{Henrik Bengtsson} \examples{ i <- charToInt(unlist(strsplit("Hello world!", split=NULL))) # Gives: 72 101 108 108 111 32 119 111 114 108 100 33 ch <- intToChar(c(72,101,108,108,111,32,119,111,114,108,100,33)) # Gives: "H" "e" "l" "l" "o" " " "w" "o" "r" "l" "d" "!" } \seealso{ \code{\link[base]{utf8Conversion}}. \code{\link{charToInt}}() } \keyword{character} \keyword{internal} R.oo/man/getRdDeclaration.Class.Rd0000644000176200001440000000150514711170562016415 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Class.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getRdDeclaration.Class} \alias{getRdDeclaration.Class} \alias{Class.getRdDeclaration} \alias{getRdDeclaration,Class-method} \title{Gets the class declaration in Rd format} \description{ Gets the class declaration in Rd format. } \usage{ \method{getRdDeclaration}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getManPath.Rdoc.Rd0000644000176200001440000000174314711170563015061 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$getManPath} \alias{Rdoc$getManPath} \alias{getManPath.Rdoc} \alias{Rdoc.getManPath} \alias{getManPath,Rdoc-method} \title{Gets the path to the directory where the Rd files will be saved} \description{ Gets the path to the directory where the Rd files will be saved. } \usage{ ## Static method (use this): ## Rdoc$getManPath(...) ## Don't use the below: \method{getManPath}{Rdoc}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:setManPath.Rdoc]{*setManPath}()} For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/isAbstract.Class.Rd0000644000176200001440000000211414711170562015276 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isAbstract.Class} \alias{isAbstract.Class} \alias{Class.isAbstract} \alias{isAbstract,Class-method} \title{Checks if a class is abstract or not} \description{ Checks if a class is abstract or not. A class is abstract if it has abstract methods. } \usage{ \method{isAbstract}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the class is abstract, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ if (isAbstract(RccViolationException)) throw("The class RccViolationException should NOT be abstract.") } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{class}}(). \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getMessage.Exception.Rd0000644000176200001440000000162014711170562016155 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getMessage.Exception} \alias{getMessage.Exception} \alias{Exception.getMessage} \alias{getMessage,Exception-method} \title{Gets the message of the Exception} \description{ Gets the message of the Exception. } \usage{ \method{getMessage}{Exception}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{\dontrun{For a complete example see help(Exception).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Exception}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/isOlderThan.Package.Rd0000644000176200001440000000201714711170563015704 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isOlderThan.Package} \alias{isOlderThan.Package} \alias{Package.isOlderThan} \alias{isOlderThan,Package-method} \title{Checks if the package is older than a given version} \description{ Checks if the package is older than a given version. } \usage{ \method{isOlderThan}{Package}(this, version, ...) } \arguments{ \item{version}{A \code{\link[base]{character}} string specifying a version to compare with.} \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the version of the package is less than the specified version. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. \code{\link[R.oo:getVersion.Package]{*getVersion}()}. } \keyword{internal} \keyword{methods} R.oo/man/staticCode.Object.Rd0000644000176200001440000000255214711170561015427 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{staticCode.Object} \alias{staticCode.Object} \alias{Object.staticCode} \alias{staticCode,Object-method} \title{Method that will be call each time a new instance of a class is created} \description{ Method that will be call each time a new instance of a class is created. By extending this method it is possible to have static code that is called each time a new instance of a class is created. } \usage{ \method{staticCode}{Object}(static, ...) } \arguments{ \item{static}{The static instance of this class.} \item{...}{Not used.} } \value{ Returns nothing. } \details{ The method \code{extend()} in the Object class will call this method just before returning and it will pass the static instance of the class as a reference. Note that method should never be called explicitly. Any value returned by this method will be ignored. } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/hasField.BasicObject.Rd0000644000176200001440000000207614711170562016030 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{hasField.BasicObject} \alias{hasField.BasicObject} \alias{BasicObject.hasField} \alias{hasField,BasicObject-method} \title{Checks if a field exists or not} \description{ Checks if a field exists or not. } \usage{ \method{hasField}{BasicObject}(this, field, ...) } \arguments{ \item{field}{\code{\link[base]{vector}} of fields to be checked if they exists or not.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{logical}} \code{\link[base]{vector}} indicating for each field if it exists or not. } \author{Henrik Bengtsson} \seealso{ To get the fields of an Object, see \code{\link[R.oo:getFields.BasicObject]{*getFields}()}. For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getStackTrace.Exception.Rd0000644000176200001440000000221714711170562016620 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getStackTrace.Exception} \alias{getStackTrace.Exception} \alias{Exception.getStackTrace} \alias{getStackTrace,Exception-method} \title{Gets the stack trace saved when the exception was created} \description{ . } \usage{ \method{getStackTrace}{Exception}(this, cleanup=getOption("R.oo::Exception/getStackTrace/args/cleanup", TRUE), ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{list}} containing the stack trace. } \examples{\dontrun{For a complete example see help(Exception).}} \seealso{ \code{\link[R.oo:printStackTrace.Exception]{*printStackTrace}()}. \code{\link[utils:debugger]{dump.frames}()}. \code{\link[base:conditions]{tryCatch}()}. For more information see \code{\link{Exception}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/typeOfClass.Rd0000644000176200001440000000142314711170564014373 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % typeOfClass.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{typeOfClass} \alias{typeOfClass.default} \alias{typeOfClass} \title{Gets the type of a class (S3 or S4)} \description{ Gets the type of a class (S3 or S4). } \usage{ \method{typeOfClass}{default}(object, ...) } \arguments{ \item{object}{The object to be checks.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string \code{"S3"}, \code{"S3-Object"} or \code{"S4"}, or \code{\link[base]{NA}} if neither. } \author{Henrik Bengtsson} \keyword{character} R.oo/man/getFields.Class.Rd0000644000176200001440000000177414711170562015120 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getFields.Class} \alias{getFields.Class} \alias{Class.getFields} \alias{getFields,Class-method} \title{Returns the field names of a class} \description{ Returns the field names of a class. } \arguments{ \item{private}{If \code{\link[base:logical]{TRUE}}, private fields will also be returned, otherwise only public fields are returned.} \item{...}{Not used.} } \usage{ \method{getFields}{Class}(this, private=FALSE, ...) } \value{ Returns a \code{\link[base]{character}} \code{\link[base]{vector}} of field names. } \examples{ print(getFields(Exception)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/getKeywords.Rdoc.Rd0000644000176200001440000000175414711170563015342 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$getKeywords} \alias{Rdoc$getKeywords} \alias{getKeywords.Rdoc} \alias{Rdoc.getKeywords} \alias{getKeywords,Rdoc-method} \title{Gets the keywords defined in R with descriptions} \description{ Gets the keywords defined in R with descriptions. } \usage{ ## Static method (use this): ## Rdoc$getKeywords(fullInfo=FALSE, ...) ## Don't use the below: \method{getKeywords}{Rdoc}(this, fullInfo=FALSE, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:setManPath.Rdoc]{*setManPath}()} For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getVersion.Package.Rd0000644000176200001440000000150114711170563015612 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getVersion.Package} \alias{getVersion.Package} \alias{Package.getVersion} \alias{getVersion,Package-method} \title{Gets the version of this package} \description{ Gets the version of this package. } \usage{ \method{getVersion}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. \code{\link[R.oo:isOlderThan.Package]{*isOlderThan}()}. } \keyword{internal} \keyword{methods} R.oo/man/detach.BasicObject.Rd0000644000176200001440000000223414711170612015531 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{detach.BasicObject} \alias{detach.BasicObject} \alias{BasicObject.detach} \alias{detach,BasicObject-method} \title{Detach a BasicObject from the R search path} \description{ Detach, from the \R search path, a BasicObject that has previously been attached. If the BasicObject was not attached, a \code{\link[base]{warning}} will be generated and nothing will be done. } \usage{ \method{detach}{BasicObject}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the BasicObject was detached, otherwise \code{\link[base:logical]{FALSE}}. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:attach.BasicObject]{*attach}()} and \code{\link[base]{attach}}(), \code{\link[base]{detach}}(). For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/escapeRdFilename.Rdoc.Rd0000644000176200001440000000202514711170563016212 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$escapeRdFilename} \alias{Rdoc$escapeRdFilename} \alias{escapeRdFilename.Rdoc} \alias{Rdoc.escapeRdFilename} \alias{escapeRdFilename,Rdoc-method} \title{Escape non-valid characters in a filename} \description{ Escape non-valid characters in a filename. } \usage{ ## Static method (use this): ## Rdoc$escapeRdFilename(filename, ...) ## Don't use the below: \method{escapeRdFilename}{Rdoc}(static, filename, ...) } \arguments{ \item{filename}{A filename (\code{\link[base]{character}} string) to be escaped.} \item{...}{Not used.} } \value{ Returns \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/RccViolationException.Rd0000644000176200001440000000664414711170563016423 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % RccViolationException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{RccViolationException} \docType{class} \alias{RccViolationException} \title{An RccViolationException indicates a violation of the R Coding Conventions (RCC)} \description{ Package: R.oo \cr \bold{Class RccViolationException}\cr \code{\link[R.oo]{Object}}\cr \code{~~|}\cr \code{~~+--}\code{try-error}\cr \code{~~~~~~~|}\cr \code{~~~~~~~+--}\code{condition}\cr \code{~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~+--}\code{error}\cr \code{~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~+--}\code{simpleError}\cr \code{~~~~~~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~~~~~~+--}\code{\link[R.oo]{Exception}}\cr \code{~~~~~~~~~~~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~~~~~~~~~~~+--}\code{RccViolationException}\cr \bold{Directly known subclasses:}\cr \cr public static class \bold{RccViolationException}\cr extends \link[R.oo]{Exception}\cr An RccViolationException indicates a violation of the R Coding Conventions (RCC). It is generated by \code{setConstructorS3()} and \code{setMethodS3()}. It is \emph{not} meant to be caught, but instead the source code that violates the RCC should be fixed. For more information about RCC, see references below. } \usage{ RccViolationException(...) } \arguments{ \item{...}{Any arguments accepted by the constructor of Exception, i.e. one or several \code{\link[base]{character}} strings, which will be concatenated and contain informative message about why the RCC was violated.} } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{\link[R.oo:as.character.RccViolationException]{as.character}} \tab Gets a string representing of the RCC violation.\cr \tab \code{\link[R.oo:getRccUrl.RccViolationException]{getRccUrl}} \tab Static method to get a URL where the RCC can be found.\cr } \bold{Methods inherited from Exception}:\cr as.character, getCall, getCalls, getLastException, getMessage, getStackTrace, getWhen, print, printStackTrace, throw \bold{Methods inherited from error}:\cr as.character, throw \bold{Methods inherited from condition}:\cr abort, as.character, conditionCall, conditionMessage, print \bold{Methods inherited from Object}:\cr $, $<-, [[, [[<-, as.character, attach, attachLocally, clearCache, clearLookupCache, clone, detach, equals, extend, finalize, getEnvironment, getFieldModifier, getFieldModifiers, getFields, getInstantiationTime, getStaticInstance, hasField, hashCode, ll, load, names, objectSize, print, save } \details{ Since it is not possible to assert that the RCC is followed during the parsing of the source code, but first only when the source code is actually executed. } \examples{ \dontrun{ setConstructorS3("myClass", function() { extends(Object(), .value=0) }) setMethodS3("MyMethod", "myClass", function(this) { "Hullo!" }) } } \author{Henrik Bengtsson} \seealso{ See also \code{\link[base]{try}}() and \code{\link[base:conditions]{tryCatch}()}. For detailed information about exceptions see \code{\link{Exception}}. The R Coding Conventions (RCC) can be found at \url{https://aroma-project.org/developers/RCC/}. } \keyword{classes} \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} R.oo/man/getPath.Package.Rd0000644000176200001440000000142414711170563015065 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getPath.Package} \alias{getPath.Package} \alias{Package.getPath} \alias{getPath,Package-method} \title{Gets the library (system) path to this package} \description{ Gets the library (system) path to this package. } \usage{ \method{getPath}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/as.character.RccViolationException.Rd0000644000176200001440000000216214711170563020747 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % RccViolationException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.RccViolationException} \alias{as.character.RccViolationException} \alias{RccViolationException.as.character} \alias{as.character,RccViolationException-method} \title{Gets a string representing of the RCC violation} \description{ Gets a string representing of the RCC violation of format "[\{POSIX date string\}] \{class name\}: \{msg\}, cf. https://aroma-project.org/developers/RCC/". } \usage{ \method{as.character}{RccViolationException}(x, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{\dontrun{For a complete example see help(Exception).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{RccViolationException}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/finalize.Object.Rd0000644000176200001440000000355714711170561015154 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{finalize.Object} \alias{finalize.Object} \alias{Object.finalize} \alias{finalize,Object-method} \title{Finalizer methods called when object is clean out} \description{ Finalizer methods are called just the moment before the object is about to be deleted by the garbage collector. \bold{If creating a custom \code{finalize()} method for a subclass in a package, then it needs to be exported in the NAMESPACE of that package. If not, it will not be found nor called and there will be no error message.} \bold{A finalizer method should never be called explicitly!} } \usage{ \method{finalize}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \examples{ setConstructorS3("MyClass", function() { extend(Object(), "MyClass") }) setMethodS3("finalize", "MyClass", function(this, ...) { cat(as.character(this), "is about to be removed from the memory!\n") }) o <- MyClass() o <- MyClass() o <- MyClass() o <- MyClass() gc() ## MyClass: 0x01BE602C is about to be removed from the memory! ## MyClass: 0x01BFF634 is about to be removed from the memory! ## MyClass: 0x01C13584 is about to be removed from the memory! ## used (Mb) gc trigger (Mb) ## Ncells 229903 6.2 467875 12.5 ## Vcells 53725 0.5 786432 6.0 rm(o) ## MyClass: 0x01C578B0 is about to be removed from the memory! ## used (Mb) gc trigger (Mb) ## Ncells 229903 6.1 467875 12.3 ## Vcells 53725 0.5 786432 6.0 } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/extend.Rd0000644000176200001440000000413514711170564013431 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % extend.default.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{extend} \alias{extend.default} \alias{extend} \title{Extends a object} \description{ via a mechanism known as "parasitic inheritance". Simply speaking this method "extends" the class of an object. What is actually happening is that it creates an instance of class name \code{...className}, by taking another object and add \code{...className} to the class list and also add all the named values in \code{...} as attributes. The method should be used by the constructor of a class and nowhere else. } \usage{ \method{extend}{default}(this, ...className, ...) } \arguments{ \item{this}{Object to be extended.} \item{...className}{The name of new class.} \item{...}{Attribute fields of the new class.} } \value{ Returns an object of class \code{...className}. } \author{Henrik Bengtsson} \examples{ setConstructorS3("MyDouble", function(value=0, ...) { extend(as.double(value), "MyDouble", ...) }) setMethodS3("as.character", "MyDouble", function(object, ...) { fmtstr <- attr(object, "fmtstr") if (is.null(fmtstr)) fmtstr <- "\%.6f" sprintf(fmtstr, object) }) setMethodS3("print", "MyDouble", function(object, ...) { print(as.character(object), ...) }) x <- MyDouble(3.1415926) print(x) x <- MyDouble(3.1415926, fmtstr="\%3.2f") print(x) attr(x, "fmtstr") <- "\%e" print(x) setConstructorS3("MyList", function(value=0, ...) { extend(list(value=value, ...), "MyList") }) setMethodS3("as.character", "MyList", function(object, ...) { fmtstr <- object$fmtstr if (is.null(fmtstr)) fmtstr <- "\%.6f" sprintf(fmtstr, object$value) }) setMethodS3("print", "MyList", function(object, ...) { print(as.character(object), ...) }) x <- MyList(3.1415926) print(x) x <- MyList(3.1415926, fmtstr="\%3.2f") print(x) x$fmtstr <- "\%e" print(x) } \keyword{programming} \keyword{methods} R.oo/man/detach.Object.Rd0000644000176200001440000000224514711170561014574 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{detach.Object} \alias{detach.Object} \alias{Object.detach} \alias{detach,Object-method} \title{Detach an Object from the R search path} \description{ Detach, from the \R search path, an Object that has previously been attached. If the Object was not attached, a \code{\link[base]{warning}} will be generated and nothing will be done. } \usage{ \method{detach}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the Object was detached, otherwise \code{\link[base:logical]{FALSE}}. } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:attach.Object]{*attach}()} and \code{\link[base]{attach}}(), \code{\link[base]{detach}}(). For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/extend.Object.Rd0000644000176200001440000000546714711170561014644 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{extend.Object} \alias{extend.Object} \alias{Object.extend} \alias{extend,Object-method} \title{Extends another class} \description{ via a mechanism known as "parasitic inheritance". Simply speaking this method "extends another class". What is actually happening is that it creates an instance of class name \code{...className}, by taking another Object instance and add \code{...className} to the class list and also add all the named values in \code{...} as fields to the new instance. The method should be used by the constructor of a class and nowhere else. } \usage{ \method{extend}{Object}(this, ...className, ..., ...fields=NULL, ...envir=parent.frame(), ...finalize=NA) } \arguments{ \item{...className}{The name of new class.} \item{...}{Named values representing the fields of the new instance.} \item{...fields}{An optional named \code{\link[base]{list}} of fields. This makes it possible to specify a set of fields using a \code{\link[base]{list}} object.} \item{...envir}{An \code{\link[base]{environment}}.} \item{...finalize}{ A \code{\link[base]{logical}} controlling whether method \code{\link[R.oo:finalize.Object]{*finalize}()} should be called on the \code{\link{Object}} when it is garbage collected or not. If \code{\link[base:logical]{TRUE}}, it will be called. If \code{\link[base:logical]{FALSE}}, it will not be called. If \code{\link[base]{NA}}, it will be called according to argument \code{finalize} of the \code{\link{Object}} constructor. } } \value{ Returns an Object of class \code{className}. } \details{ The reason for the strange name of argument \code{"...className"} is that if one tries to set a field with a name that is a prefix of the name of this arguments and one at the same time does not specify the name of this argument one would run into strange errors. For instance, try \code{extend(Object(), "MyClass", ...c=0)}. } \section{Field modifiers}{ It is possible to specify modifiers to some of the fields. Currently it is only the \code{cached} modifier that is recognized. A field that is cached will be assigned \code{\link[base]{NULL}} when \code{\link[R.oo:clearCache.Object]{*clearCache}()} is called. To specify a modifier, append a comma separated list of modifiers followed by a colon, e.g. "cached:foo". } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getHowToCite.Package.Rd0000644000176200001440000000204714711170563016040 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getHowToCite.Package} \alias{getHowToCite.Package} \alias{Package.getHowToCite} \alias{getHowToCite,Package-method} \title{Gets the citation of this package} \description{ Gets the citation of this package. If text file \code{HOWTOCITE} exists in package root directory, then its contents is retrieved, otherwise \code{\link[utils]{citation}} for the package is retrieved. } \usage{ \method{getHowToCite}{Package}(this, newline="\n", ...) } \arguments{ \item{newline}{The \code{\link[base]{character}} string to collapse lines in the file.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getFields.BasicObject.Rd0000644000176200001440000000216114711170612016206 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getFields.BasicObject} \alias{getFields.BasicObject} \alias{BasicObject.getFields} \alias{getFields,BasicObject-method} \title{Returns the field names of a BasicObject} \description{ Returns the field names of a BasicObject. } \usage{ \method{getFields}{BasicObject}(this, private=FALSE, ...) } \arguments{ \item{private}{If \code{\link[base:logical]{TRUE}}, private fields will also be returned, otherwise only public fields are returned.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} \code{\link[base]{vector}} of field names. } \author{Henrik Bengtsson} \seealso{ To check if a field exists or not, see \code{\link[R.oo:hasField.BasicObject]{*hasField}()}. For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/DOLLARLT_-.Object.Rd0000644000176200001440000000476614711170561015007 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{DOLLAR< -.Object} \alias{$<-.Object} \alias{Object.$<-} \alias{$<-,Object-method} \alias{Object.[[<-} \alias{[[<-.Object} \alias{[[<-,Object-method} \title{Makes the fields and methods of an Object assignable via the $<- and the [[<- operator} \description{ Makes the fields and methods of an Object assignable via the \code{$<-} operator. This method is never called explicitly, but through an indirect usage of the \code{$<-} operator, e.g. \code{obj$name <- "foo"}. 1) This method will first search for a \code{set()} method, e.g. if name has the value \code{"age"}, a \code{setAge()} will be looked for. If such a method exists it will be called with the Object as the first argument and \code{value} as the second, e.g. \code{setAge(this, value)}. A \code{set()} is only looked for if \code{} is a non-private field. A private field is a name \emph{beginning} with a \code{.} (period). The rational for this naming convention is to be consistent with how \code{\link[base]{ls}}() works, which will not list such members by default. Moreover, excluding private fields for the search of a \code{set()} will decrease the overhead for such field. 2) If no such method exists the \code{value} will be assigned to an existing field named \code{name}, if such exists. 3) Otherwise, the value will be assigned to a static field, if such exists. 4) In all other case, the value is assigned to a new field. Because any \code{set()} is called first, it is possible to \emph{encapsulate} (hide away) fields with certain names or to put restrictions to what values can be assigned to them. } \usage{ \method{$}{Object}(this, name) <- value \method{[[}{Object}(this, name) <- value } \arguments{ \item{name}{The name of the \code{set()} method or the name of the field to be assigned the new value.} \item{value}{The value to be assigned.} } \value{ Returns itself, i.e. \code{this}, as all \code{$<-} methods must do. } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/Exception.Rd0000644000176200001440000001257714711170562014107 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Exception} \docType{class} \alias{Exception} \title{The Exception class to be thrown and caught} \description{ Package: R.oo \cr \bold{Class Exception}\cr \code{\link[R.oo]{Object}}\cr \code{~~|}\cr \code{~~+--}\code{try-error}\cr \code{~~~~~~~|}\cr \code{~~~~~~~+--}\code{condition}\cr \code{~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~+--}\code{error}\cr \code{~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~+--}\code{simpleError}\cr \code{~~~~~~~~~~~~~~~~~~~~~~|}\cr \code{~~~~~~~~~~~~~~~~~~~~~~+--}\code{Exception}\cr \bold{Directly known subclasses:}\cr \link[R.oo]{InternalErrorException}, \link[R.oo]{RccViolationException}, \link[R.oo]{RdocException}\cr public static class \bold{Exception}\cr extends simpleError\cr Creates an Exception that can be thrown and caught. The \code{Exception} class is the root class of all other \code{Exception} classes. } \usage{ Exception(..., sep="", collapse=", ") } \arguments{ \item{...}{One or several strings, which will be concatenated and contain informative message about the exception.} \item{sep}{The string to used for concatenating several strings.} \item{collapse}{The string to used collapse vectors together.} } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{\link[R.oo:as.character.Exception]{as.character}} \tab Gets a character string representing of the Exception.\cr \tab \code{getCall} \tab -\cr \tab \code{\link[R.oo:getCalls.Exception]{getCalls}} \tab Gets the active calls saved when the exception was created.\cr \tab \code{\link[R.oo:getLastException.Exception]{getLastException}} \tab Static method to get the last Exception thrown.\cr \tab \code{\link[R.oo:getMessage.Exception]{getMessage}} \tab Gets the message of the Exception.\cr \tab \code{\link[R.oo:getStackTrace.Exception]{getStackTrace}} \tab Gets the stack trace saved when the exception was created.\cr \tab \code{\link[R.oo:getStackTraceString.Exception]{getStackTraceString}} \tab Gets the stack trace as a string.\cr \tab \code{\link[R.oo:getWhen.Exception]{getWhen}} \tab Gets the time when the Exception was created.\cr \tab \code{\link[R.oo:print.Exception]{print}} \tab Prints the Exception.\cr \tab \code{\link[R.oo:printStackTrace.Exception]{printStackTrace}} \tab Prints the stack trace saved when the exception was created.\cr \tab \code{\link[R.oo:throw.Exception]{throw}} \tab Throws an Exception that can be caught.\cr } \bold{Methods inherited from error}:\cr as.character, throw \bold{Methods inherited from condition}:\cr abort, as.character, conditionCall, conditionMessage, print \bold{Methods inherited from Object}:\cr $, $<-, [[, [[<-, as.character, attach, attachLocally, clearCache, clearLookupCache, clone, detach, equals, extend, finalize, getEnvironment, getFieldModifier, getFieldModifiers, getFields, getInstantiationTime, getStaticInstance, hasField, hashCode, ll, load, names, objectSize, print, save } \examples{ ###################################################################### # 1. To catch a regular "error" exception thrown by e.g. stop(). ###################################################################### x <- NA y <- NA tryCatch({ x <- log(123) y <- log("a") }, error = function(ex) { print(ex) }) print(x) print(y) ###################################################################### # 2. Always run a "final" expression regardless or error or not. ###################################################################### filename <- tempfile("R.methodsS3.example") con <- file(filename) tryCatch({ open(con, "r") }, error = function(ex) { cat("Could not open ", filename, " for reading.\n", sep="") }, finally = { close(con) cat("The id of the connection is ", ifelse(is.null(con), "NULL", con), ".\n", sep="") }) ###################################################################### # 3. Creating your own Exception class ###################################################################### setConstructorS3("NegativeLogValueException", function( msg="Trying to calculate the logarithm of a negative value", value=NULL) { extend(Exception(msg=msg), "NegativeLogValueException", .value = value ) }) setMethodS3("as.character", "NegativeLogValueException", function(this, ...) { paste(as.character.Exception(this), ": ", getValue(this), sep="") }) setMethodS3("getValue", "NegativeLogValueException", function(this, ...) { this$.value }) mylog <- function(x, base=exp(1)) { if (x < 0) throw(NegativeLogValueException(value=x)) else log(x, base=base) } # Note that the order of the catch list is important: l <- NA x <- 123 tryCatch({ l <- mylog(x) }, NegativeLogValueException = function(ex) { cat(as.character(ex), "\n") }, "try-error" = function(ex) { cat("try-error: Could not calculate the logarithm of ", x, ".\n", sep="") }, error = function(ex) { cat("error: Could not calculate the logarithm of ", x, ".\n", sep="") }) cat("The logarithm of ", x, " is ", l, ".\n\n", sep="") } \author{Henrik Bengtsson} \seealso{ See also \code{\link[base:conditions]{tryCatch}()} (and \code{\link[base]{try}}()). } \keyword{programming} \keyword{methods} \keyword{error} \keyword{classes} R.oo/man/Object.Rd0000644000176200001440000002610714711170561013350 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Object} \docType{class} \alias{Object} \title{The root class that every class must inherit from} \description{ R.oo\cr \bold{Class Object}\cr public class \bold{Object}\cr \code{Object} is the root class of all other classes. All classes \emph{must} extends this class, directly or indirectly, which means that they all will inherit the methods in this class. } \usage{ Object(core=NA, finalize=TRUE) } \arguments{ \item{core}{The core value of each \emph{reference} referring to the Object. By default, this is just the smallest possible \R object, but there are situations where it is useful to have another kind of core, which is the case with the Class class. \emph{Note that this value belongs to the reference variable and not to the Object, which means it can not be referenced.}} \item{finalize}{If \code{\link[base:logical]{TRUE}}, method \code{\link[R.oo:finalize.Object]{*finalize}()} will be called on this Object when it is garbage collected.} } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{$} \tab -\cr \tab \code{$<-} \tab -\cr \tab \code{.DollarNames} \tab -\cr \tab \code{.subset2Internal} \tab -\cr \tab \code{[[} \tab -\cr \tab \code{[[<-} \tab -\cr \tab \code{\link[R.oo:as.character.Object]{as.character}} \tab Gets a character string representing the object.\cr \tab \code{\link[R.oo:attach.Object]{attach}} \tab Attaches an Object to the R search path.\cr \tab \code{\link[R.oo:attachLocally.Object]{attachLocally}} \tab Attaches an Object locally to an environment.\cr \tab \code{\link[R.oo:clearCache.Object]{clearCache}} \tab Clear fields that are defined to have cached values.\cr \tab \code{\link[R.oo:clearLookupCache.Object]{clearLookupCache}} \tab Clear internal fields used for faster lookup.\cr \tab \code{\link[R.oo:clone.Object]{clone}} \tab Clones an Object.\cr \tab \code{\link[R.oo:detach.Object]{detach}} \tab Detach an Object from the R search path.\cr \tab \code{\link[R.oo:equals.Object]{equals}} \tab Compares an object with another.\cr \tab \code{\link[R.oo:extend.Object]{extend}} \tab Extends another class.\cr \tab \code{\link[R.oo:finalize.Object]{finalize}} \tab Finalizer methods called when object is clean out.\cr \tab \code{\link[R.oo:getEnvironment.Object]{getEnvironment}} \tab Gets the environment of this object.\cr \tab \code{getFieldModifier} \tab -\cr \tab \code{\link[R.oo:getFieldModifiers.Object]{getFieldModifiers}} \tab Gets all types of field modifiers.\cr \tab \code{\link[R.oo:getFields.Object]{getFields}} \tab Returns the field names of an Object.\cr \tab \code{\link[R.oo:getInstantiationTime.Object]{getInstantiationTime}} \tab Gets the time when the object was instantiated.\cr \tab \code{\link[R.oo:getInternalAddress.Object]{getInternalAddress}} \tab Gets the memory location where the Object resides.\cr \tab \code{\link[R.oo:getStaticInstance.Object]{getStaticInstance}} \tab Gets the static instance of this objects class.\cr \tab \code{\link[R.oo:hasField.Object]{hasField}} \tab Checks if a field exists or not.\cr \tab \code{\link[R.oo:hashCode.Object]{hashCode}} \tab Gets a hash code for the Object.\cr \tab \code{\link[R.oo:isReferable.Object]{isReferable}} \tab Checks if the object is referable or not.\cr \tab \code{\link[R.oo:ll.Object]{ll}} \tab Generates a list of informative properties of all members of an Object.\cr \tab \code{\link[R.oo:load.Object]{load}} \tab Static method to load an Object from a file or a connection.\cr \tab \code{names} \tab -\cr \tab \code{\link[R.oo:newInstance.Object]{newInstance}} \tab Creates a new instance of the same class as this object.\cr \tab \code{\link[R.oo:novirtual.Object]{novirtual}} \tab Returns a reference to the same Object with virtual fields turned off.\cr \tab \code{\link[R.oo:objectSize.Object]{objectSize}} \tab Gets the size of the Object in bytes.\cr \tab \code{\link[R.oo:print.Object]{print}} \tab Prints an Object.\cr \tab \code{\link[R.oo:save.Object]{save}} \tab Saves an Object to a file or a connection.\cr \tab \code{\link[R.oo:staticCode.Object]{staticCode}} \tab Method that will be call each time a new instance of a class is created.\cr } } \section{Defining static fields}{ To define a static field of an Object class, use a private field \code{<.field>} and then create a virtual field \code{} by defining methods \code{get()} and \code{set()}. These methods should retrieve and assign the value of the field \code{<.field>} of the \emph{static} instance of the class. The second example below shows how to do this. The example modifies also the static field already in the constructor, which is something that otherwise may be tricky. } \examples{ ######################################################################### # Defines the class Person with private fields .name and .age, and # with methods print(), getName(), setName(), getAge() and setAge(). ######################################################################### setConstructorS3("Person", function(name, age) { if (missing(name)) name <- NA if (missing(age)) age <- NA extend(Object(), "Person", .name=name, .age=age ) }) setMethodS3("as.character", "Person", function(this, ...) { paste(this$.name, "is", as.integer(this$.age), "years old.") }) setMethodS3("equals", "Person", function(this, obj, ...) { ( identical(data.class(this), data.class(obj)) && identical(this$getName(), obj$getName()) && identical(this$getAge() , obj$getAge() ) ) }) setMethodS3("hashCode", "Person", function(this, ...) { # Get the hashCode() of the '.name' and the '.age' fields # using hashCode.default(). hashCode(this$.name) * hashCode(this$.age) }) setMethodS3("getName", "Person", function(this, ...) { this$.name }) setMethodS3("setName", "Person", function(this, newName, ...) { throw("It is not possible to change the name of a Person.") }) setMethodS3("getAge", "Person", function(this, ...) { this$.age }) setMethodS3("setAge", "Person", function(this, newAge, ...) { if (!is.numeric(newAge)) throw("Age must be numeric: ", newAge) if (newAge < 0) throw("Trying to set a negative age: ", newAge) this$.age <- newAge }) ######################################################################### # Code demonstrating different properties of the Object class using # the example class Person. ######################################################################### # Create an object (instance of) the class Person. p1 <- Person("Dalai Lama", 67) # 'p1' is an Object of class Person. print(data.class(p1)) # "Person" # Prints information about the Person object. print(p1) # "Dalai Lama is 67 years old." # or equivalent (except that no generic method has to exist): p1$print() # "Dalai Lama is 67 years old." # Shows that no generic method is required if the \$ operator is used: print(p1$getName()) # "Dalai Lama" # The following will call p1$getName() since there exists a get-() # method for the 'name' property. print(p1$name) # "Dalai Lama" # and equivalent when using the [[ operator. print(p1[["name"]]) # "Dalai Lama" # The following shows that p1$setName(68) is called, simply because # there exists a set-() method for the 'name' property. p1$age <- 68 # Will call p1$setAge(68) # Shows that the age of the Person has been updated: print(p1) # "Dalai Lama is 68 years old." # If there would not exists such a set-() method or field a new # field would be created: p1$country <- "Tibet" # Lists all (non-private) members of the Person object: print(ll(p1)) # which gives # member class mode typeof length dim bytes # 1 country NULL character character 1 NULL 44 # The following will call p1$setName("Lalai Dama") which will # throw an exception saying one can not change the name of # a Person. tryCatch(p1$name <- "Lalai Dama", error=print) # The following will call p1$setAge(-4) which will throw an # exception saying that the age must be a non-negative number. tryCatch(p1$age <- -100, error=print) # Attaches Object 'p1' to the search path. attach(p1) # Accesses the newly created field 'country'. print(country) # "Tibet" # Detaches Object 'p1' from the search path. Note that all # modifications to 'country' are lost. country <- "Sweden" detach(p1) print(p1$country) # "Tibet" # Saves the Person object to a tempory file. filename <- tempfile("R.methodsS3.example") save(p1, filename) # Deletes the object rm(p1) # Loads an Object (of "unknown" class) from file using the # static method load() of class Object. obj <- Object$load(filename) # Prints information about the new Object. print(obj) # Lists all (non-private) members of the new Object. print(ll(obj)) ###################################################################### # Example illustrating how to "emulate" static fields using virtual # fields, i.e. get- and set-methods. Here we use a private static # field '.count' of the static class instance 'MyClass', i.e. # MyClass$.count. Then we define a virtual field 'count' via method # getCount() to access this static field. This will make all queries # for 'count' of any object to use the static field instead. In the # same way is assignment controlled via the setCount() method. A # side effect of this way of coding is that all MyClass instances will # also have the private field '.count' (set to zero except for the # static field that is). ###################################################################### setConstructorS3("MyClass", function(...) { # Create an instance (the static class instance included) this <- extend(Object(), "MyClass", .count = 0 ) # In order for a static field to be updated in the # constructor it has to be done after extend(). this$count <- this$count + 1 # Return the object this }) setMethodS3("as.character", "MyClass", function(this, ...) { paste(class(this)[1], ": Number of instances: ", this$count, sep="") }) # Get virtual field 'count', e.g. obj$count. setMethodS3("getCount", "MyClass", function(this, ...) { MyClass$.count }) # Set virtual field 'count', e.g. obj$count <- value. setMethodS3("setCount", "MyClass", function(this, value, ...) { MyClass$.count <- value }) # Create four instances of class 'MyClass' obj <- lapply(1:4, MyClass) print(obj) print(MyClass$count) print(obj[[1]]$count) stopifnot(obj[[1]]$count == length(obj)) stopifnot(MyClass$count == length(obj)) } \author{Henrik Bengtsson} \references{ [1] H. Bengtsson, \emph{The R.oo package - Object-Oriented Programming with References Using Standard R Code}, In Kurt Hornik, Friedrich Leisch and Achim Zeileis, editors, Proceedings of the 3rd International Workshop on Distributed Statistical Computing (DSC 2003), March 20-22, Vienna, Austria. \url{https://www.r-project.org/conferences/DSC-2003/Proceedings/} \cr } \keyword{programming} \keyword{methods} \keyword{classes} R.oo/man/hashCode.Object.Rd0000644000176200001440000000307614711170561015065 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{hashCode.Object} \alias{hashCode.Object} \alias{Object.hashCode} \alias{hashCode,Object-method} \title{Gets a hash code for the Object} \description{ Gets a hash code for the Object. This makes it possible to put any \code{\link[R.oo]{Object}} in a hash table. The hash code returned must: 1) be \emph{consistent}, i.e. \code{hashCode(obj)} should return the same value on multiple invocations as long as nothing has changed. 2) tell same same thing as \code{equals()}, if \code{equals(o1,o2)} is \code{\link[base:logical]{TRUE}}, then \code{hashCode(o1) == hashCode(o2)} should also be \code{\link[base:logical]{TRUE}}. Note that if \code{equals(o1,o2)} is \code{\link[base:logical]{FALSE}}, \code{hashCode(o1)} \code{hashCode(o2)} may be \emph{either} equal or non-equal. By default, the method returns the internal memory address where the Object is located. } \usage{ \method{hashCode}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{double}}. } \examples{ obj <- Object() hashCode(obj) # 26979608 } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:equals.Object]{*equals}()} For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/Class.Rd0000644000176200001440000001066714711170562013214 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Class} \docType{class} \alias{Class} \title{The Class class describes an Object class} \description{ Package: R.oo \cr \bold{Class Class}\cr \code{\link[R.oo]{Object}}\cr \code{~~|}\cr \code{~~+--}\code{Class}\cr \bold{Directly known subclasses:}\cr \cr public static class \bold{Class}\cr extends \link[R.oo]{Object}\cr The Class class describes an Object class. First of all, this class is most commonly used \emph{internally} and neither the end user nor the programmer need to no about the class Class. } \usage{ Class(name=NULL, constructor=NULL) } \arguments{ \item{name}{Name of the class.} \item{constructor}{Constructor (\code{\link[base]{function}}) of any Object class.} } \section{Fields and Methods}{ \bold{Methods:}\cr \tabular{rll}{ \tab \code{$} \tab -\cr \tab \code{$<-} \tab -\cr \tab \code{.DollarNames} \tab -\cr \tab \code{.subset2Internal} \tab -\cr \tab \code{[[} \tab -\cr \tab \code{[[<-} \tab -\cr \tab \code{\link[R.oo:argsToString.Class]{argsToString}} \tab Gets the arguments of a function as a character string.\cr \tab \code{\link[R.oo:as.character.Class]{as.character}} \tab Returns a short string describing the class.\cr \tab \code{\link[R.oo:forName.Class]{forName}} \tab Gets a Class object by a name of a class.\cr \tab \code{\link[R.oo:getDetails.Class]{getDetails}} \tab Lists the fields and methods of a class.\cr \tab \code{\link[R.oo:getFields.Class]{getFields}} \tab Returns the field names of a class.\cr \tab \code{\link[R.oo:getKnownSubclasses.Class]{getKnownSubclasses}} \tab Gets all subclasses that are currently loaded.\cr \tab \code{\link[R.oo:getMethods.Class]{getMethods}} \tab Returns the method names of class and its super classes.\cr \tab \code{\link[R.oo:getName.Class]{getName}} \tab Gets the name of the class.\cr \tab \code{\link[R.oo:getPackage.Class]{getPackage}} \tab Gets the package to which the class belongs.\cr \tab \code{\link[R.oo:getRdDeclaration.Class]{getRdDeclaration}} \tab Gets the class declaration in Rd format.\cr \tab \code{\link[R.oo:getRdHierarchy.Class]{getRdHierarchy}} \tab Gets the class hierarchy in Rd format.\cr \tab \code{\link[R.oo:getRdMethods.Class]{getRdMethods}} \tab Gets the methods of a class in Rd format.\cr \tab \code{\link[R.oo:getStaticInstance.Class]{getStaticInstance}} \tab Gets the static instance of this class.\cr \tab \code{\link[R.oo:getSuperclasses.Class]{getSuperclasses}} \tab Gets the super classes of this class.\cr \tab \code{\link[R.oo:isAbstract.Class]{isAbstract}} \tab Checks if a class is abstract or not.\cr \tab \code{\link[R.oo:isBeingCreated.Class]{isBeingCreated}} \tab Checks if a class is currently being initiated initiated.\cr \tab \code{\link[R.oo:isDeprecated.Class]{isDeprecated}} \tab Checks if a class is deprecated or not.\cr \tab \code{\link[R.oo:isPrivate.Class]{isPrivate}} \tab Checks if a class is defined private or not.\cr \tab \code{\link[R.oo:isProtected.Class]{isProtected}} \tab Checks if a class is defined protected or not.\cr \tab \code{\link[R.oo:isPublic.Class]{isPublic}} \tab Checks if a class is defined public or not.\cr \tab \code{\link[R.oo:isStatic.Class]{isStatic}} \tab Checks if a class is static or not.\cr \tab \code{\link[R.oo:newInstance.Class]{newInstance}} \tab Creates a new instance of this class.\cr \tab \code{\link[R.oo:print.Class]{print}} \tab Prints detailed information about the class and its fields and methods.\cr } \bold{Methods inherited from Object}:\cr $, $<-, [[, [[<-, as.character, attach, attachLocally, clearCache, clearLookupCache, clone, detach, equals, extend, finalize, getEnvironment, getFieldModifier, getFieldModifiers, getFields, getInstantiationTime, getStaticInstance, hasField, hashCode, ll, load, names, objectSize, print, save } \details{ The class Class describes the Object class or one of its subclasses. All classes and constructors created by \code{setConstructorS3()} will be of class Class. Its methods provide ways of accessing static fields and static methods. Its \emph{print()} method will print detailed information about the class and its fields and methods. } \author{Henrik Bengtsson} \keyword{classes} \keyword{programming} \keyword{methods} R.oo/man/as.character.RdocException.Rd0000644000176200001440000000155014711170563017242 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % RdocException.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.RdocException} \alias{as.character.RdocException} \alias{RdocException.as.character} \alias{as.character,RdocException-method} \title{Gets a character string representing of the RdocException} \description{ . } \usage{ \method{as.character}{RdocException}(x, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{RdocException}}. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/throw.Exception.Rd0000644000176200001440000000204114711170562015232 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Exception.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{throw.Exception} \alias{throw.Exception} \alias{Exception.throw} \alias{throw,Exception-method} \title{Throws an Exception that can be caught} \description{ Throws an Exception that can be caught by \code{tryCatch()}. } \usage{ \method{throw}{Exception}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns nothing. } \examples{\dontrun{For a complete example see help(Exception).}} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Exception}}. See also \code{\link[base:conditions]{tryCatch}()}. This method overrides (and is fully backward compatible with) the one defined in the \pkg{R.methodsS3} package. } \keyword{programming} \keyword{methods} \keyword{error} \keyword{internal} \keyword{methods} R.oo/man/objectSize.Object.Rd0000644000176200001440000000232214711170561015441 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{objectSize.Object} \alias{objectSize.Object} \alias{Object.objectSize} \alias{objectSize,Object-method} \title{Gets the size of the Object in bytes} \description{ Gets the size of the Object in bytes by summing the sizes of all its members. For this reason, the size of memory the Object actually allocates might vary slightly. } \usage{ \method{objectSize}{Object}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns an \code{\link[base]{integer}} specifying the size of the object in number of bytes. } \examples{ obj <- Object() obj$x <- 1:100 obj$y <- 100:1 objectSize(obj) # 856 } \author{Henrik Bengtsson} \seealso{ To clear fields that are declared \code{cached}, see \code{\link[R.oo:clearCache.Object]{*clearCache}()}. \code{\link[utils]{object.size}}. For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/getKnownSubclasses.classRepresentation.Rd0000644000176200001440000000134614711170563022015 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % classRepresentation.misc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getKnownSubclasses.classRepresentation} \alias{getKnownSubclasses.classRepresentation} \title{Gets the known subclasses} \description{ Gets the known subclasses. } \usage{ \method{getKnownSubclasses}{classRepresentation}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \keyword{methods} \keyword{internal} \keyword{documentation} R.oo/man/showChangeLog.Package.Rd0000644000176200001440000000235214711170563016222 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{showChangeLog.Package} \alias{showChangeLog.Package} \alias{Package.showChangeLog} \alias{showChangeLog,Package-method} \alias{Package.showHistory} \alias{showHistory.Package} \alias{showHistory,Package-method} \alias{Package.showNews} \alias{showNews.Package} \alias{showNews,Package-method} \title{Show the change log of this package} \description{ Show the change log of this package. If the change log file does not exist, an exception is thrown. } \usage{ \method{showChangeLog}{Package}(this, filenames=c("NEWS", "NEWS.md", "HISTORY", "ChangeLog"), ...) } \arguments{ \item{filenames}{A \code{\link[base]{character}} \code{\link[base]{vector}} of (non-case sensitive) filenames to be searched for.} \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:getChangeLog.Package]{*getChangeLog}()}. For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/as.character.Package.Rd0000644000176200001440000000147614711170563016036 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.Package} \alias{as.character.Package} \alias{Package.as.character} \alias{as.character,Package-method} \title{Gets a string representation of this package} \description{ Gets a string representation of this package. } \usage{ \method{as.character}{Package}(x, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{print(R.oo)} \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/isLoaded.Package.Rd0000644000176200001440000000201314711170563015210 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isLoaded.Package} \alias{isLoaded.Package} \alias{Package.isLoaded} \alias{isLoaded,Package-method} \title{Checks if the package is installed on the search path or not} \description{ Checks if the package is installed on the search path or not. } \usage{ \method{isLoaded}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ \code{\link[base:logical]{TRUE}} if the packages has been loaded, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ pkg <- Package("base") print(isLoaded(pkg)) # TRUE } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:load.Package]{*load}()}. \code{\link[base]{search}}(). For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getTitle.Package.Rd0000644000176200001440000000154314711170563015254 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getTitle.Package} \alias{getTitle.Package} \alias{Package.getTitle} \alias{getTitle,Package-method} \title{Gets the Title of this package} \description{ Gets the Title of this package as specified by the \code{DESCRIPTION} file. } \usage{ \method{getTitle}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \examples{ pkg <- Package("R.oo") print(getTitle(pkg)) } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/getNameFormat.Rdoc.Rd0000644000176200001440000000167214711170563015563 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Rdoc.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{Rdoc$getNameFormat} \alias{Rdoc$getNameFormat} \alias{getNameFormat.Rdoc} \alias{Rdoc.getNameFormat} \alias{getNameFormat,Rdoc-method} \title{Gets the current name format} \description{ Gets the current name format. } \usage{ ## Static method (use this): ## Rdoc$getNameFormat(...) ## Don't use the below: \method{getNameFormat}{Rdoc}(static, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:setNameFormat.Rdoc]{*setNameFormat}()} For more information see \code{\link{Rdoc}}. } \keyword{internal} \keyword{methods} \keyword{documentation} R.oo/man/getInstantiationTime.BasicObject.Rd0000644000176200001440000000230214711170562020444 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getInstantiationTime.BasicObject} \alias{getInstantiationTime.BasicObject} \alias{BasicObject.getInstantiationTime} \alias{getInstantiationTime,BasicObject-method} \title{Gets the time when the object was instantiated} \description{ Gets the time when the object was instantiated (created) as a POSIXt object. } \usage{ \method{getInstantiationTime}{BasicObject}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a POSIXt object, which extends class POSIXct. } \details{ The instantiation timestamp is set when the object is created, and only of option \code{"R.oo::BasicObject/instantiationTime"} is \code{\link[base:logical]{TRUE}}. } \seealso{ For more about time formats and POSIX see \code{\link[base]{DateTimeClasses}}. For more information see \code{\link{BasicObject}}. } \author{Henrik Bengtsson} \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/hasField.Object.Rd0000644000176200001440000000244414711170561015064 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{hasField.Object} \alias{hasField.Object} \alias{Object.hasField} \alias{hasField,Object-method} \title{Checks if a field exists or not} \description{ Checks if a field exists or not. } \usage{ \method{hasField}{Object}(this, field, ...) } \arguments{ \item{field}{\code{\link[base]{vector}} of fields to be checked if they exists or not.} \item{...}{Not used.} } \value{ Returns a \code{\link[base]{logical}} \code{\link[base]{vector}} indicating for each field if it exists or not. } \examples{ obj <- Object() obj$x <- 1:100 obj$y <- 100:1 hasField(obj, c("x", "a", "b", "y")) \dontrun{ gives: [1] TRUE FALSE FALSE TRUE } } \author{Henrik Bengtsson} \seealso{ To get the fields of an Object, see \code{\link[R.oo:getFields.Object]{*getFields}()}. For more extensive information about the fields in an Object see \code{\link[R.oo:ll.Object]{*ll}()}. For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/isPublic.Class.Rd0000644000176200001440000000211714711170562014754 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isPublic.Class} \alias{isPublic.Class} \alias{Class.isPublic} \alias{isPublic,Class-method} \title{Checks if a class is defined public or not} \description{ Checks if a class is defined public or not. A class is public if it is neither private nor protected. } \usage{ \method{isPublic}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the class is public, otherwise \code{\link[base:logical]{FALSE}}. } \examples{ if (!isPublic(RccViolationException)) throw("The class RccViolationException should be public.") } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{class}}(). \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/objectSize.environment.Rd0000644000176200001440000000154314711170564016606 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % objectSize.environment.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{objectSize.environment} \alias{objectSize.environment} \title{Gets the size of an environment in bytes} \description{ Gets the size of an environment in bytes. } \usage{ \method{objectSize}{environment}(envir, ...) } \arguments{ \item{envir}{An \code{\link[base]{environment}}().} \item{...}{Arguments passed to \code{\link[base]{ls}}().} } \value{ Returns an \code{\link[base]{integer}}. } \author{Henrik Bengtsson} \seealso{ Internally \code{\link[utils]{object.size}} is used. } \keyword{attribute} \keyword{utilities} \keyword{methods} R.oo/man/getName.Package.Rd0000644000176200001440000000136214711170563015052 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % Package.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{getName.Package} \alias{getName.Package} \alias{Package.getName} \alias{getName,Package-method} \title{Gets the name of this package} \description{ Gets the name of this package. } \usage{ \method{getName}{Package}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns a \code{\link[base]{character}} string. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{Package}}. } \keyword{internal} \keyword{methods} R.oo/man/throw.error.Rd0000644000176200001440000000153614711170563014436 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % error.throw.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{throw.error} \alias{throw.error} \title{Throws (rethrows) an object of class 'error'} \description{ Rethrows an 'error' object. The 'error' class was introduced in R v1.8.1 with the new error handling mechanisms. } \usage{ \method{throw}{error}(error, ...) } \arguments{ \item{error}{An object or class 'error'.} \item{...}{Not used.} } \value{ Returns nothing. } \author{Henrik Bengtsson} \seealso{ See the \code{tryCatch()} method etc. See the \code{\link{Exception}} class for more detailed information. } \keyword{error} \keyword{methods} R.oo/man/as.character.BasicObject.Rd0000644000176200001440000000154514711170562016647 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % BasicObject.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{as.character.BasicObject} \alias{as.character.BasicObject} \alias{BasicObject.as.character} \alias{as.character,BasicObject-method} \title{Gets a character string representing the object} \description{ Gets a character string representing the object. } \usage{ \method{as.character}{BasicObject}(x, ...) } \value{ Returns a \code{\link[base]{character}} string representation of the object. } \author{Henrik Bengtsson} \seealso{ For more information see \code{\link{BasicObject}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/man/newInstance.Object.Rd0000644000176200001440000000202014711170561015611 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{newInstance.Object} \alias{newInstance.Object} \alias{Object.newInstance} \alias{newInstance,Object-method} \title{Creates a new instance of the same class as this object} \description{ Creates a new instance of the same class as this object. } \usage{ \method{newInstance}{Object}(this, ...) } \arguments{ \item{...}{Arguments passed to the constructor of the corresponding \code{\link{Object}} class.} } \value{ Returns a reference to an instance of \code{\link{Object}} or a subclass thereof. } \author{Henrik Bengtsson} \seealso{ \code{\link{newInstance.Class}}(). \code{\link{newInstance.BasicObject}}(). For more information see \code{\link{Object}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/isDeprecated.Class.Rd0000644000176200001440000000166014711170562015600 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 060.Class.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{isDeprecated.Class} \alias{isDeprecated.Class} \alias{Class.isDeprecated} \alias{isDeprecated,Class-method} \title{Checks if a class is deprecated or not} \description{ Checks if a class is deprecated or not. } \usage{ \method{isDeprecated}{Class}(this, ...) } \arguments{ \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the class is deprecated, otherwise \code{\link[base:logical]{FALSE}}. } \author{Henrik Bengtsson} \seealso{ \code{\link[base]{class}}(). \code{\link{setConstructorS3}}(). For more information see \code{\link{Class}}. } \keyword{internal} \keyword{methods} \keyword{programming} R.oo/man/attach.Object.Rd0000644000176200001440000000266314711170561014614 0ustar liggesusers%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Do not modify this file since it was automatically generated from: % % 050.Object.R % % by the Rdoc compiler part of the R.oo package. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \name{attach.Object} \alias{attach.Object} \alias{Object.attach} \alias{attach,Object-method} \title{Attaches an Object to the R search path} \description{ Attach the members of an Object to the \R search path. If trying to attach the same Object twice without detaching it in between, a \code{\link[base]{warning}} will be generated and nothing will be done. } \usage{ \method{attach}{Object}(this, private=FALSE, pos=2, ...) } \arguments{ \item{private}{If \code{\link[base:logical]{TRUE}}, private fields will also be attached, otherwise not.} \item{pos}{The position at in search path where the Object should be inserted.} \item{...}{Not used.} } \value{ Returns \code{\link[base:logical]{TRUE}} if the \code{\link[R.oo]{Object}} was attached, otherwise \code{\link[base:logical]{FALSE}}. } \examples{\dontrun{For a complete example see help(Object).}} \author{Henrik Bengtsson} \seealso{ \code{\link[R.oo:detach.Object]{*detach}()} and \code{\link[base]{attach}}(), \code{\link[base]{detach}}(). For more information see \code{\link{Object}}. } \keyword{programming} \keyword{methods} \keyword{internal} \keyword{methods} R.oo/DESCRIPTION0000644000176200001440000000211414711213442012572 0ustar liggesusersPackage: R.oo Version: 1.27.0 Depends: R (>= 2.13.0), R.methodsS3 (>= 1.8.2) Imports: methods, utils Suggests: tools Title: R Object-Oriented Programming with or without References Authors@R: c(person("Henrik", "Bengtsson", role=c("aut", "cre", "cph"), email = "henrikb@braju.com")) Author: Henrik Bengtsson [aut, cre, cph] Maintainer: Henrik Bengtsson Description: Methods and classes for object-oriented programming in R with or without references. Large effort has been made on making definition of methods as simple as possible with a minimum of maintenance for package developers. The package has been developed since 2001 and is now considered very stable. This is a cross-platform package implemented in pure R that defines standard S3 classes without any tricks. License: LGPL (>= 2.1) LazyLoad: TRUE URL: https://github.com/HenrikBengtsson/R.oo BugReports: https://github.com/HenrikBengtsson/R.oo/issues NeedsCompilation: no Packaged: 2024-11-01 17:26:30 UTC; henrik Repository: CRAN Date/Publication: 2024-11-01 18:00:02 UTC