[[PageOutline]]

= OOP in TOL =

La principal diferencia del nuevo TOL 2.0.1 con respecto a sus predecesores será la apuesta por la programación orientada al objeto (OOP).

Se trataría de que el usuario pudiera definir estructuras de NameBlock, es decir clases virtuales puras en la nomenclatura OOP, con una API mínima para poder usarla como descriptor de argumento en funciones de forma análoga al Struct en Set. Así como a los conjuntos con estructura se les denomina usualmente registros, a los NameBlock con clase les llamaremos instancias.

== Miembros y métodos ==
A los elementos de una estructura se les suele llamar campos, pero en una clase hay que distinguir los métodos de los miembros. Un método es una función de una clase con un prototipo o definición conocida y fija, es decir, que el tipo devuelto y los argumentos, incluidos sus nombres, están prefijados de antemano.Todos los demás elementos de una clase se denominarán miembros. Nótese que un elemento de tipo {{{Code}}} no es un método.

Tanto unos como otros pueden estar definidos desde un principio o pueden estar solamente declarados a la espera de que se implementen posteriormente.
 * '''Declaración de miembro''': [[BR]] {{{ Text _.name; }}}
 * '''Declaración de método''':  [[BR]] {{{ Text getName(Real unused); }}}
 * '''Definición de miembro''':  [[BR]] {{{ Text _.name = "nobody"; }}}
 * '''Definición de método''':   [[BR]] {{{ Text getName(Real unused) { _.name}; }}}

Los métodos deben ser definidos en la propia clase o en alguna de sus clases heredadas y serán almacenados en la propia clase, y por lo tanto sólo existe una copia única para todas las intancias, la cual no se debe alterar bajo ningún concepto, mientras que los miembros se ubican físicamente en las instancias, pueden por tanto ser definidos por estas, y cada instancia tiene su propia copia de forma que los cambios sufridos en una no afectan a las demás.

=== El miembro privado reservado _this ===

Todos los NameBlock, sean o no instancia de una clase, tienen un miembro privado llamado _this al que se puede acceder desde todos sus métodos.

{{{
//Example of using implicit private member _this
NameBlock a = 
[[
  Text _.name = "a";
  Text getName(Real unused) { _this::_.name }
]];

//User cannot overwrite _this due to it's a reserved word
NameBlock b = 
[[
  Text _.name = "b";
  NameBlock _this = a;
  Text getName(Real unused) { _this::_.name }
]];
  
}}}

=== Uso de miembros de tipo Code ===

En OOP no se recomienda el uso de miembros que apunten a funciones asignables como pueden ser los punteros de funciones en C++ o los objetos de tipo Code en TOL. Una función asignable pretende recoger comportamientos polimórficos impredecibles y eso en OOP se trata mediante herencia de métodos virtuales.

TOL dará un un mensaje de aviso cuando esto ocurra, aunque se permitirá su uso por si fuera necesario en casos extremos.

En tales casos las funciones así utilizadas no tendrán acceso al ámbito de la clase pues no se trata de verdaderos métodos.

Aún más peligroso resulta usar estos miembros de tipo Code dentro de un !NameBlock genérico, no instancia de clase, puesto que en ellos es imposible distinguir si fue creado como método o como objeto, por lo que tendrá acceso al ámbito del !NameBlock y sólo debería ser asignado a verdaderos métodos del mismo, nunca a objetos externos. 

Especialmente dañino resultaría que una misma función externa fuera asignada a miembros de tipo Code de diferentes !NameBlock's no globales, o bien que esa función se usara además fuera de ellos, pues ello podría incluso ocasionar una caída de TOL.

=== Miembros y métodos estáticos ===

Si la declaración de un elemento de la clase va precedida por la palabra reservada '''Static''', entonces dicho elemento será compartido por tadas las intancias de dicha clase y para referirse a ellos fuera del ámbito de la misma será necesario utilizar la sintaxis {{{<nombre_de_clase>::<nombre_de_elemento>}}}

== Instancias ==
Una instancia de una clase es un NameBlock que cumple la API definida por dicha clase y define al menos todos los miembros sin valor por defecto. Obsérvese que el orden de declaración de los miembros es irrelevante e independiente del orden de herencia de las clases.

{{{
VectorDoc.Ser vd.ser =
[[
  Text    _.name = "Viernes";
  Text    _.description = "Es 1 los días viernes y 0 el resto";
  Serie   _ser = CalInd(WD(5),C)
]];

VectorDoc.Mat vd.mat =
[[
  Text   _.name = "Constante";
  Matrix _mat = SetCol(NCopy(1,100));
  Text   _.description = "Siempre vale 1"
]];
}}}

Para ser más exacto sólo esposibe crear instancias de una clase no virtual, es decir, con todos los métodos implementados, lo cual se explicará más adelante.

== Clases ==

=== Clases primarias ===
Son aquellas clases que no heredan de ninguna otra previa sino que se definen por sí mismas. En cierta manera, una clase primaria es a un NameBlock lo que un Struct es para un Set: le obliga a seguir una pauta organizativa, aunque los requisitos que conlleva son algo distintos.

=== Clases estructurales ===

Llamaremos clase estructural a aquella que no tiene ningún método. 

{{{
Class Doc
{ 
  Text _.name;
  Text _.description
};
}}}

=== Clases no estructurales ===

Si tiene algún método le diremos no estructural.

{{{
Class Doc
{ 
  Text _.name;
  Text _.description;
  Text getName(Real unused) { _.name } 
};
}}}

=== Clases virtuales ===

Una clase no estructural será virtual si tiene algún método no definido, el cual deberá ser definido en alguna clase heredada de esta, o bien en la propia instanciación de objetos.

{{{
Class Doc
{ 
  Text _.name;
  Text _.description;
  Text getName(Real unused) { _.name };
  Text getSize(Real unused)
};
}}}

=== Clases virtuales puras ===

Una clase primaria virtual pura es aquella que en la que ningún método tiene una definición por defecto

{{{
Class Vector
{ 
  Matrix  get.column  (Anything unused);
  Real    has.timeInfo(Anything unused);
  TimeSet dating      (Anything unused);
  Date    firstDate   (Anything unused);
  Date    lastDate    (Anything unused)
};
}}}

=== Clases heredadas ===
Es posible crear clases heredadas de otras que implementen métodos o asignen valores por defecto a miembros. También está permitida la herencia múltiple siempre y cuando no exista conflicto entre los métodos y miembros heredados. Si no desea cambiar ninguno de los miembros o métodos por defecto ni añadir nada nuevo, simplemente se listan las clases de las que se quiere heredar. En otro caso se abrirían llaves y se harían las modificaciones o añadidos pertinentes:

{{{
//Si no se quiere cambiar nada con herencia múltiple se enumeran las clases
//antecesoras
Class VectorDoc: Vector, Doc;

//Con herencia simple no tiene mucho sentido no cambiar nada
//pues sería una simple clonación de tipos
Class VectorDoc.Ser: VectorDoc
{
  Serie  _ser;
  Matrix  get.data    (Anything unused) { Tra(SerMat(_ser)) };
  Real    has.timeInfo(Anything unused) { True };
  TimeSet dating      (Anything unused) { Dating(_ser) };
  Date    firstDate   (Anything unused) { First(_ser) };
  Date    lastDate    (Anything unused) { Last(_ser) }
};

Class VectorDoc.Mat: VectorDoc
{
  Matrix _mat;
  Matrix  get.data    (Anything unused) { _mat }
  Real    has.timeInfo(Anything unused) { False };
  TimeSet dating      (Anything unused) { W };
  Date    firstDate   (Anything unused) { UnknownDate };
  Date    lastDate    (Anything unused) { UnknownDate }
};
}}}

=== Otros ejemplos de clases ===

Esta otra sería una clase primaria parcialmente virtual pues tiene algunos miembros y métodos definidos por defecto y otros no

{{{
Class Input
{
  VectorDoc _.data;
  Real  _.enabled = True;
  Polyn _.omega = 1;
  Polyn _.delta = 1;
  Ratio transferFunction (Anything unused)
  {
    _.omega / _.delta
  };
  Matrix eval(Polyn omega, Polyn delta)
  {
    Polyn  _.omega := omega;
    Polyn  _.delta := delta;
    MatDifEq(transferFunction, _.vector::get.column(0))
  }
};
}}}

=== Clases anidadas ===
Una clase puede tener un miembro que es una instancia de otra clase
{{{
Class Output
{
  VectorDoc _.data;
  Set _.arima
};
}}}

=== Las clases vistas como tipos de usuario ===

Los nombres de clase funcionarán como tipos definidos por el usuario a todos los efectos, salvo alguna excepción debida a las limitaciones del parser de TOL y que quedarán debidamente documentadas. Es posible entonces declarar argumentos de función de una clase determinada lo cual admitirá cualquier NameBlock que sea instancia de esa clase o cualquier clase heredada de ella.

{{{
Matrix sum(Vector a, Vector b)
{
  a::get.data(0) + b::get.data(0)
};

Matrix c = sum(vd.ser, vd.mat);
}}}

=== Predeclaración de clases ===

Es posible predeclarar una clase sin definir sus métodos ni las clases de las que hereda, para poder ser usada dentro de otra clase que a su vez la precise, tal y como se ilstra en el siguiente ejemplo:

{{{

//Forward declaration
Class ClHeight;

//This class uses ClHeight as a method argument
Class ClAge
{
  Text _.name;
  Real _.age;
  Real equalName(ClHeight arg)
  {
    _.name==arg::_.name
  }
};

//This class uses ClAge as a method argument
Class ClHeight
{
  Text _.name;
  Real _.height;
  Real equalName(ClAge arg)
  {
    _.name==arg::_.name
  }
};
}}}