#---------------------------------------------------------------#
## utilización de los objetos RC                                   ##

rm(list =ls()) # esta instrucción vacía el entorno


#---------------------------------------------------------------#
## una clase simple sin método de usuario                  ##

Persona <- setRefClass("Persona",
  fields = list (
    id        = "numeric",
    nom       = "character",
    atributos = "vector",
    memoria   = "ANY",         # tipo todavía desconocido
    timer     = "ANY"          # ídem
    )
  )

Persona$fields()   # los campos
Persona$methods()  # todos los métodos

#---------------------------------------------------------------#
## una instancia                                                ##

untel <-  Persona$new(    # nueva instancia
          id = 1,          # primer campo
          nom = "Untel"    # otro   campo
          )

untel$id        #  simplemente
untel$nom
untel$atributos # NULL
untel$memoria   # todavía más NULL ...   

m <-  matrix(seq(1:9),3,3) # una matriz 3 x 3
untel$memoria <- m  # almacena valores de la matriz 
untel$memoria                                       

#---------------------------------------------------------------#
## añadir setters al objeto                           ##

# los campos de la clase persona
attributs(Persona$fields())

pf <- attributs(Persona$fields())$names
pf

Persona$descriptores(pf)    # descriptores de acceso getX... y setX...
Persona$methods()        # get o set seguido del field con mayúsculas


untel$getNom()                        # se obtiene el nombre
untel$setMemoria(m+1)                 # actualización de la memoria
untel$getMemoria()                    # leer memoria


attributs(untel)     # atributo en sentido R
attributs(Persona)
m <- matrix(1:12, nrow = 4)
attributs(m)
attributs(m)$dim

                                      # en sentido RC
untel$setAtributos(c("bonito","grande")) # creación de los atributos
untel$getAtributos()                  # obtención de los atributos
                                      # mayúsculas atributos
untel$setAtributos(c(untel$getAtributos(),"fuerte")) 
untel$getAtributos()                      
  
#---------------------------------------------------------------#
## adición del constructor                                       ##

Persona$methods(iniciar = # no cambiar
                  función (##
                    ## su propio código, 1 de 2
                    ## valores predeterminados para sus parámetros
                    ##
                    nombre = "Desconocido", # argumento 1
                    id = 0, # argumento 2
                    ##
                    ## final de su código, 1 de 2
                    ##
                    ...){ # ... : parámetro de superclase
                    callSuper(...) # llamar param superclase
                    ##
                    ## inicio de su propio código 2 de 2
                    ## use <<- en lugar de <-
                    ##
                    nom <<- nom # argumento de recuperación
                    id <<- id # argumento de recuperación
                    timer <<- Sys.time() # por ejemplo
                    ##
                    ## final de su propio código, 2 de 2
                    ##
                    .self # hecho!
                    }
                  )

Persona$methods()

untel <- Persona$new()
untel$getNom()

henri <- Persona$new(nom = "Henri",
                      id  = 2)
henri$getNom()
henri$getId()
henri$getTimer()

#---------------------------------------------------------------#
## herencia                                                    ##

## herencia y nuevos campos
Data_scientist <- setRefClass("Data_scientist",
                    contains = "Persona",
                    
                    fields = list (
                      competencia_R     = "logico",
                      competencia_estados = "logico"
                      )
                    )
#---------------------------------------------------------------#
## sobrecarga método, aquí el constructor                      ##
Data_scientist$methods( initialize =  
                        function(competencia_R = FALSE,...){
                          callSuper(...)
                          competencia_R     <<- competencia_R
                          competencia_estados <<- TRUE
                          .self
                          }
                        )
#---------------------------------------------------------------#
## un nuevo método para esta clase                      ##

Data_scientist$methods( comunica =  
                          function(){
                            ch1 <- ""
                            ch2 <- ""
                            if (competencia_R){
                              ch1 <- ", especialista en R"
                              }
                            if (competencia_estados){
                              ch2 <-", amantes de la estadística"
                              }
                            print (paste("Hola, soy",
                                         .self$nom,
                                         ch1,
                                         ch2
                                         ))
                          }
                        )

#---------------------------------------------------------------#
## creación nuevos descriptores de acceso                                 ##

Data_scientist$descriptores(c("competencia_R",
                           "competencia_estados"
                           ))    # descriptores de acceso getX... y setX...

#---------------------------------------------------------------#
## test                                                        ##

Data_scientist$fields()
Data_scientist$methods()

untel <- Data_scientist$new() # valores por defecto
untel$getNom()
untel$getCompetencia_R()

raoul <- Data_scientist$new(nom = "Raoul",
                            id  = 100,
                            competencia_R = TRUE,
                            memoria = "Pi = 3.1416",
                            atributos = c("pequeño","hombre")
                            )

raoul$comunica()           # raoul comunica ... ;-)

raoul$setCompetencia_estados(FALSE)

raoul$comunica()           # raoul comunica ... ... :-((

raoul$getId()
raoul$getMemoria()
raoul$getAtributos()

#---------------------------------------------------------------#
## objeto mutable                                               ##

paolo <- raoul      
paolo$comunica()
paolo$setMemoria("Pi = euh no lo sé")
raoul$getMemoria()

tristan <- raoul$copy()
raoul$setMemoria("¿quién soy? ...........")
tristan$getMemoria()

rm(raoul)
tristan$setNom("Tristan clon de Raoul")
tristan$comunica()
raoul$comunica()
paolo$comunica()

