Extraer nombre de unidad en tiempo de ejecución.

[[Delphius]]

Buenas foristas,

Llevo desde hace tiempo intentando obtener información sobre la unidad, u objeto en ejecución.
Viendo en CodeGear he encontrado un ejemplo sencillo de como extraer el nombre de la unidad donde está declarado la clase de un objeto. La función es sencilla:

Código Delphi [-]
function GetUnitName(argObject: TObject): string;
var
  ptrTypeData: PTypeData;
begin
  if (argObject.ClassInfo <> nil) then
  begin
    ptrTypeData := GetTypeData(argObject.ClassInfo);
    Result := ptrTypeData.UnitName;
  end;
end;

Lo que tengo pensando es determinar ciertos "permisos" para acceder a un dato. Veran... yo estoy declarando un form genérico el cual contiene un array de tamaño fijo (por el momento) del tipo variant. Mi idea es emplear ese array y estar evitando declarar variables. Entonces se me ocurrió la idea de darle la posibilidad de definir algo como "permisos" para acceder al contenido de las variables. Algo como public y private.

Tengo pensado hacer algo como:

// En algún momento anterior...
ElArray[4].Permiso = pPrivate;

Con esto estoy indicando que quiero que el contenido de la posición 4 sea privado para el form.

De tal modo que cuando haga esto:

ExtractValue(Index: integer, ToCopy: ¿?);

Siendo ExtractValue un procedimiento con el que cuenta la clase, Index es la posición del array a examinar y ToCopy alguna variable o propiedad de algún objeto.

Pueda determinar si ToCopy puede o no acceder al dato almacenado en la posición Index del array. De modo tal que si ToCopy está declarado en una unidad (si es una variable) o es una propiedad de algún objeto (instancia... claro está) declarado dentro de la unidad se le permita pasar dicho valor.
Pero claro... si ToCopy está en otra unidad... no se le permita acceder a este dato, arroyando una excepción.

Un planteo que se me estaba ocurriendo es tener dos arrays: uno para privado y otro para público...

Se que no es muy elegante hacer lo que pretendo.... sobre todo si es más sencillo hacer cosas como:

Código Delphi [-]
TForm1 = class(Tform)
....

public
  variable1: tipo;
  variable2: tipo;
private
  variable3: tipo;

....
end;

De modo que con un simple:

Código Delphi [-]
algo := form1.variable1;

Mi intención es evitarme estar declarando estas variable. Y Al mismo tiempo que las herencias de dicho Form puedan implementar mayores funciones, procedimientos... de acuerdo a la necesidad del momento.

Escucho alternativas.
Espero que se me haya entendido algo...

Saludos,

[roman]

La verda, creo que no entendí nada. Siguiendo tu idea de los permisos, podrías usar una propiedad tipo arreglo:

Código Delphi [-]
type
  TVisibility = (vPublic, vPrivate, ... );

  TChapuza = record
    Visibility: TVisibility;
    Value: Variant;
  end;

  TChapucero = class
  private
    FEntries: array of TChapuza;

    function GetValue(I: Integer): Variant;
    procedure SetValue(I: Integer; const Value: Variant);
  public
    property Values[I: Integer]: Variant read GetValue write SetValue;
  end;

Es decir, internamente guardas cada valor junto con su 'visibilidad', y los métodos de acceso GetValue y SetValue se encargan de verificar la visibilidad y lanzar una excepción si la entrada correspondiente no tiene marcada la visibilidad 'adecuada'.

No me quedaría nada claro qué se entiende por adecuada, pues si quieres saberlo dependiendo de la unidad desde donde se accede, pues lo veo algo difícil, o terminarás con una sintaxis mucho más engorrosa que haber declarado variables.

No sé, creo que no entiendo lo que realmente buscas.

// Saludos

[[Delphius]]

Muchas gracias roman por ofrecer tu ayuda.

No lo entendiste mal...
El código que te expones es similar a lo que ya venía planteando. Esa parte es sencilla de entender.

Veamos si me termino de explicar mejor.
Supongamos que tenemos dos unidades: UnidadA y UnidadB. Cada unidad tiene asociado un Form: FormA y FormB respectivamente. Dichos Form son heredados de uno que denomino ExpertForm.

ExpertForm contiene este array interno. y los procedimientos adecuados.
Con FormB se realiza una operación cualquiera y se guarda el contenido en una posición x en el array, que justamente tiene visibilidad pública, para que luego siga realizando otras operaciones con dicho valor. También, un control del FormA debe tener una copia del valor de la posición x del array del FormB.

Una posible solución es hacer el típico ejemplo que mostraba antes (sin emplear el array):

FormA.propiedad_asociada_variable = FormB.Propiedad_de_variable;

Pero supongamos que A debe mantener un registro de otros tantos valores de distintos valores de la operatoria de B. Alli ya se pueden hacer un array dinámico... un TList,... hay muchas opciones.

El planteo de mi array variant es para esos usos en que se necesita mantener valores que son útiles para el formulario como para otros. Pretendo usarlos para mantener un flujo de datos (independientes del tipo. Por eso variant) dinámico entre unidades.

En algunos casos con mantener una unidad llamada Globales basta... pero en los casos en que no se puede determinar cuantas variables se empleen... la unidad Globales ya no sirve de mucho.
El propósito de mantener esa visibilidad es para determinar la reglas de flujo de los datos. Por ejemplo: "FormB necesita saber un dato que proporciona FormA, y a su vez... FormA debe conocer otros datos de una FormC. FormC no debe ser "vista" por FormB" pero que estas reglas puedan ir cambiando en forma dinámica.... "FormB ahora podrá acceder a FormC, pero no a FormA.

Estuve pensando en como averiguar esto de la visibilidad... si la visibilidad está pensada para ser dinámica... ¿Cómo podría saber el "Sender" de quien solicita la orden para conocer el dato?

Por eso estaba pensando en incorporar un procedimiento del tipo:

Código Delphi [-]
ExtractValue(Index: integer; ToCopy: ¿?);

De modo que cuando se solicite pasar el dato de un lugar a otro se llame a dicha función.
Mi gran duda es como determinar si ToCopy puede tener dicho acceso.

Si ToCopy es un objeto, se puede determinar el Control Padre y comparandolo con el del "Padre" del array (self) para determinar si pertenece a la forma en cuestión u otra. Pero... el "valor" debe ser asignado a una propiedad de un objeto... o a una variable... y dicha variable puede estar en una simple unidad (no le pertenece a un objeto).

Esa es mi gran duda...

Empezado por roman

si quieres saberlo dependiendo de la unidad desde donde se accede, pues lo veo algo difícil

Sip... es algo complicado.

Mis ideas pueden ser ridículas... pero puede que me sirvan... de hecho toda esta idea me surgió como una alternativa para evitarme lo de unidades globales, declaraciones de mil variables.

A veces mi cerebro me sale con cosas un poco complicadas.

Espero haberme explicado mejor.
Y como dije, estoy considerando opciones.

Muchas gracias,
Saludos,