hola a todos, estoy tratando de crear una clase para manejar variables de la 
siguiente forma:
pero no tengo claro como recuperar los valores individuales de cada variable 
posteriormente
alguna idea sera bienvenida

local v, vCia

v    := xV():New():xInit()
vCia := v:cia()
msgbox(var2char(len(vCia)))

//-------------------------------------------------
* CLASE PARA MANEJO DE VARIABLES
//-------------------------------------------------
CLASS xV
     VAR Ide,An,Ms
      CLASS VAR Stack
EXPORTED
      VAR    aCia
      METHOD xInit,Create, cia
ENDCLASS
//----------------------------------
* Inicia Clase de Variables
//----------------------------------
METHOD xV:xInit
::Stack := {}                     Initializes
::aCia  := {}                     Valor Initial de la Variable
RETURN Self
//------------------------------------------------------------------------
* Requiere Recursos del Sistema - Apertura de Tablas que contengan 
parámetros que requiera la clase
//------------------------------------------------------------------------
METHOD xV:create
USE CIAS NEW
::Id       :=  alias()-> IdCia
::An      :=  alias()->Anual
::Ms     :=   alias()->Mes
RETURN Self
//-------------------------------------------------
* Variables para parámetros de la Cía.
//-------------------------------------------------
METHOD xV:cia
AADD(::aCia,::Id)
AADD(::aCia,::An)
AADD(::aCia,::Ms)
RETURN ::aCia

mil gracias

Hola Alfredo

v:cia() lo estas llamando antes que create() por lo que las  variables 
::ide, ::an y ::ms no se están inicializadas
xV():New():xInit():Create()

otra cosita
por cuestiones de tener en claro la declaración de la clase y que sea, 
digamos legible
>>>     VAR Ide,An,Ms debería estar debajo de exported: si esa va a ser su 
>>> función


otra cosita has de clarado ::Ide cuando debería ser ::Id
y alias()-> lo escribiría como ( Alias() )->


saludos

"Alfredo Luis Salas Ortiz" escribió en el mensaje de 
noticias:5894cb2f$3ccf8a3f$12f1f@news.alaska-software.com...

hola a todos, estoy tratando de crear una clase para manejar variables de la
siguiente forma:
pero no tengo claro como recuperar los valores individuales de cada variable
posteriormente
alguna idea sera bienvenida

local v, vCia

v    := xV():New():xInit()
vCia := v:cia()
msgbox(var2char(len(vCia)))

//-------------------------------------------------
* CLASE PARA MANEJO DE VARIABLES
//-------------------------------------------------
CLASS xV
     VAR Ide,An,Ms
      CLASS VAR Stack
EXPORTED
      VAR    aCia
      METHOD xInit,Create, cia
ENDCLASS
//----------------------------------
* Inicia Clase de Variables
//----------------------------------
METHOD xV:xInit
::Stack := {}                     Initializes
::aCia  := {}                     Valor Initial de la Variable
RETURN Self
//------------------------------------------------------------------------
* Requiere Recursos del Sistema - Apertura de Tablas que contengan
parámetros que requiera la clase
//------------------------------------------------------------------------
METHOD xV:create
USE CIAS NEW
::Id       :=  alias()-> IdCia
::An      :=  alias()->Anual
::Ms     :=   alias()->Mes
RETURN Self
//-------------------------------------------------
* Variables para parámetros de la Cía.
//-------------------------------------------------
METHOD xV:cia
AADD(::aCia,::Id)
AADD(::aCia,::An)
AADD(::aCia,::Ms)
RETURN ::aCia

mil gracias

Alfredo,

Segn veo en tu cdigo:
> METHOD xV:cia
> AADD(::aCia,::Id)
> AADD(::aCia,::An)
> AADD(::aCia,::Ms)
> RETURN ::aCia

El resultado de ejecutar:
> vCia := v:cia()

Es un arreglo ::aCia que te devuelve el mtodo.
Por lo tanto, vCia tiene un arreglo cuyos elementos son:

vCia = { ::Id , ::An,  ::Ms }

Entonces, acceder mediante un subndice debera ser lo mismo que:

vCia[1] = ::Id
vCia[2] = ::An
vCia[3] = ::Ms

Saludos

Jos Luis Otermin
Alaska Software

Hola Alfredo,

Ahi van algunas notas sueltas por si sirven de ayuda.

-------------
Las variables de instancia  Ide,An,Ms y la variable de clase Stack, tienen la visibilidad protegida que es la que se usa por defecto si no se especifica. Como bien dice Jorge por cuestiones de legibilidad deberías poner antes la sentencia PROTECTED:  para que no quede la sospecha de que están protegidas por accidente, y si el ocultarlas ha sido accidental, pues ponerle EXPORTED: para remediarlo. Normalmente cuando estas escribiendo una clase te acuerdas de todo y no tienes problemas, pero 6 - 7 meses más tarde cuando tienes que revisarla muchas veces te preguntas, ¿por que carajo escondí yo estas variables?  
-----------------

METHOD xV:cia
AADD(::aCia,::Id)
AADD(::aCia,::An)
AADD(::aCia,::Ms)
RETURN ::aCia

Este método es muy curioso  porque cada vez que accedas a él tu array va a ir creciendo, yo personalmente en primer lugar devolvería NIL en lugar del array, para no caer en la tentación  de usarlo como método de acceso por accidente, y en segundo lugar lo renombraría con un nombre algo más intuitivo como ::PushValues() o algo así. Probablemente la razón de que tome todas estas precauciones es que el 90% de mis neuronas deben de estar en un estado lamentable despues de tantos años de atiborrarlas a nicotina, por eso uso tecnicas para que no se note mucho que solo uso el otro 10%.

------------

CLASS VAR Stack
Normalmente el lugar idóneo para inicializar una CLASS VAR es el método initClass, que se ejecuta automáticamente cuando se crea el class object
( no lo confundas con un instance object) 
-------------
:Id       :=  alias()-> IdCia

Como dice Jorge ( alias() )->IdCia , aunque en este caso bien prodrías poner FIELD->IdCia que viene siendo lo mismo y está más claro
-------------

>pero no tengo claro como recuperar los valores individuales de cada variable 
>posteriormente
pues si las pones como exportadas v:Ide directamente, y si no pues tendrás que hacerte un metodo exportado para acceder a ellas.

-------------
Si la CLASS VAR Stack tienes intención de usarla como un stack, probablemente te pueda ser util la clase TGXbStack de ot4xb

INLINE METHOD initclass
::Stack := TGXbStack():New(.T.)
 si vamos a usarlo desde distintos threads hay que ponerle .T. al crear el objeto, para que se serialice el acceso
return Self

Ahí tienes el link a la ayuda:
http://www.xbwin.com/ot4xbXHlp/tgxbstack%28%29.html


Saludos,
Pablo

Alfredo,

Luego de pensar un poco, para que puedas aprender a usar una Pila, decid
hacer pblica una clase llamada XbpStack la cual pertenece al proyecto
ABM-GUI.

Aqui va:

Uso:

oStack := XbpStack():new()
oStack:push( "A" )
oStack:push( "B" )
oStack:push( "C" )
oStack:push( "D" )
? oStack:pop()     Imprime : "D"
? oStack:pop()     Imprime : "C"
? oStack:pop()     Imprime : "B"
? oStack:pop()     Imprime : "A"
? oStack:pop()     Imprime : NIL

oStack := NIL      destruye al stack.

//////////////////////////////////////////////////

 Implements an stack

CLASS XbpStack

//////////////////////////////////////////////////
   HIDDEN:
   VAR aStack   Holds the Stack
   EXPORTED:

   METHOD Init    STACK object constructor.
   METHOD FREE    Frees stack.
   METHOD LEN     Get stack length.
   METHOD POP     Get last pushed data.
   METHOD PUSH    Push data to the stack.
ENDCLASS

//////////////////////////////////////////////////

 New() constructs and returns a new stack object.
 This class can be used to store, access and control arbitrary data.

METHOD XbpStack:Init()

//////////////////////////////////////////////////
   ::aStack := Array(0)
RETURN self

//////////////////////////////////////////////////
 Free() removes all elements from stack.
METHOD XbpStack:FREE()

//////////////////////////////////////////////////
   ::aStack := Array(0)
RETURN .t.

//////////////////////////////////////////////////
 Len() returns the count of elements of stack.
METHOD XbpStack:LEN()

//////////////////////////////////////////////////
RETURN LEN(::aStack)

//////////////////////////////////////////////////
 Pop() returns a single element of the stack
METHOD XbpStack:POP()

//////////////////////////////////////////////////
   LOCAL xValue
   IF Len( ::aStack ) > 0
      xValue := ATail( ::aStack )
      ASize( ::aStack, Len(::aStack)-1 )
   ENDIF
RETURN xValue

//////////////////////////////////////////////////
 Push() puts an element at the top of the stack
METHOD XbpStack:PUSH( xValue )

//////////////////////////////////////////////////
   AAdd( ::aStack, xValue )
RETURN SELF

Saludos

Jos Luis Otermin
Alaska Software

Hola,

En mi clase TGXbStack uso un CRITICAL_SECTION para serializar el acceso desde distintos threads si llamas a New() con el parametro .T., en Xbase++ puro puedes hacer lo mismo utilizando la clausula SYNC al declarar los métodos. Si no se serializa el acceso en multithread se te puede armar un buen pitote.

Saludos,
Pablo

Jelou Pablo!!

> Hola,
>
> En mi clase TGXbStack uso un CRITICAL_SECTION
> para serializar el acceso desde distintos threads si llamas a New()
> con el parametro .T.

He visto que te has tomado a pecho lo de "Thread awareness" (cuidadoso con 
los hilos).

> en Xbase++ puro puedes hacer lo mismo
> utilizando la clausula SYNC al declarar los mtodos.
> Si no se serializa el acceso en multithread se te puede armar un buen 
> pitote.

Lo s, de hecho he aprendido sobre ese asuntillo cuando traduje la Gua de 
Programacin 

Pero me han dicho al odo que dejara de volar tan alto para los 
principiantes pues las alturas les da vrtigo )))

Entonces me dije:
- Aprend a andar en bicicleta luego de aprender a correr.
- Aprend a correr luego de aprender a caminar.
- Aprend a caminar luego de tropezar y caer muchas veces.

As que me baj del parapente y solt la bicicleta. Me puse las rodilleras y 
ac estamos, hablando de hilos (y yo que no s zurcir!) y sus enriedos 
)))

> Saludos,
> Pablo

Un abrazo grande y gracias por ayudar

Jos Luis

Hola,

A ver, tampoco es tan complicado,solo hay 2 opciones correctas posibles:

1) Usas tu stack en 1 solo hilo.
2) Serializas las operaciones y lo usas en tantos hilos como gustes.

Cualquier otra opción es una cagada, porque tarde o temprano va a acabar fallando, si tienes buena suerte intentaras acceder a una posición que no existe y te saltará un error y con algo de mala suerte perderas items lo que aun es peor porque si no te salta el error ni te das cuenta.

Me recordaste un viejo chiste con eso de la bicicleta.   

¡¡¡ Pepe,  sal corriendo para tu casa que tu mujer te está poniendo los cuernos con tu mejor amigo!!!
Ahí va el tipo todo nervioso, agarra la bicicleta y sale pedaleando a toda leche, al pasar la primera curva se sale del camino y cae rodando monte abajo dandose golpes por todos lados. Y asi que logra recomponerse un poco dice, a ver recapacitemos, yo no estoy casado y ni si quiera me llamo Pepe, y además, no sé montar en bicicleta.

Saludos,
Pablo

Jelou!!!

Muy bueno el chiste )

> A ver, tampoco es tan complicado,solo hay 2 opciones correctas posibles:
>
> 1) Usas tu stack en 1 solo hilo.

Es el caso que sub.

> 2) Serializas las operaciones y lo usas en tantos hilos como gustes.

Bueno, la idea sera que explicaras qu es la serializacin y cmo funciona.
De paso no ser el nico al que Hctor rete por volar alto jajaja

Un abrazo


Jos Luis Otermin
Alaska Software

Hola Jose Luis,

Mira que te gusta hacer de oso 

> Bueno, la idea sería que explicaras qué es la serialización y cómo funciona.

Normalmente el termino serialización a secas se suele emplear para referirse a la transformación de un objeto multidimensional en otro lineal con el fin de almacenarlo o transportarlo mientras que la serialización de accesos o de operaciones se refiere a un tipo de sincronización que impide que se inicie una operación hasta que no se haya completado la siguiente, así que a partir de ahora para que no haya confusiones usaremos el término control de concurrencia.

Cuando yo era chico  asi como de unos 3 - 4 años, las monjas de la escuela tenian un semaforo de cartulina pintado en verde por un lado y en rojo y cuando uno iba al aseo le daba la vuelta y lo ponia en rojo y cuando regresaba pues le volvia a dar la vuelta y lo ponía en verde, así ibamos de uno en uno para no acabar meandonos los unos a los otros. 

Bueno pues el concepto es el mismo, si un hilo está manipulando un array el otro se espera y no lo toca hasta que el anterior ha terminado lo que tenia que hacer.

Y bueno la implementacion en Xbase++ es tan facil  como  ponerle el atributo SYNC al declarar el método
asi
METHOD XbpStack:PUSH( xValue )
quedaría como
SYNC METHOD XbpStack:PUSH( xValue )

Tampoco era tan dificil, no? 

Un abrazote,
Pablo

Hombre, siempre se aprende algo cada día.

Saludos a todos, y espero que nos volvamos a juntar de nuevo!

Osvaldo


On 12/16/2010 1:21 PM, Pablo Botella wrote:
> Hola Jose Luis,
>
> Mira que te gusta hacer de oso 
>
>> Bueno, la idea sería que explicaras qué es la serialización y cómo funciona.
>
> Normalmente el termino serialización a secas se suele emplear para referirse a la transformación de un objeto multidimensional en otro lineal con el fin de almacenarlo o transportarlo mientras que la serialización de accesos o de operaciones se refiere a un tipo de sincronización que impide que se inicie una operación hasta que no se haya completado la siguiente, así que a partir de ahora para que no haya confusiones usaremos el término control de concurrencia.
>
> Cuando yo era chico  asi como de unos 3 - 4 años, las monjas de la escuela tenian un semaforo de cartulina pintado en verde por un lado y en rojo y cuando uno iba al aseo le daba la vuelta y lo ponia en rojo y cuando regresaba pues le volvia a dar la vuelta y lo ponía en verde, así ibamos de uno en uno para no acabar meandonos los unos a los otros.
>
> Bueno pues el concepto es el mismo, si un hilo está manipulando un array el otro se espera y no lo toca hasta que el anterior ha terminado lo que tenia que hacer.
>
> Y bueno la implementacion en Xbase++ es tan facil  como  ponerle el atributo SYNC al declarar el método
> asi
> METHOD XbpStack:PUSH( xValue )
> quedaría como
> SYNC METHOD XbpStack:PUSH( xValue )
>
> Tampoco era tan dificil, no? 
>
> Un abrazote,
> Pablo
>
>
>
>
>