Convertir PSafeArray a String

[Lizeth]

Hola tengo que convertir de PSafeArray a String pero no se ni como hacerlo. Tengo esto:

Mi variable es de este tipo
var consolResult : IConsolidationResult;

y esta a su vez tiene esta propiedad

ConsolResult.Template que es de tipo PSafeArray este a su vez tiene lo siguiente:

PSafeArray = ^TSafeArray;
{$EXTERNALSYM tagSAFEARRAY}
tagSAFEARRAY = record
cDims: Word;
fFeatures: Word;
cbElements: Longint;
cLocks: Longint;
pvData: Pointer;
rgsabound: array[0..0] of TSafeArrayBound;
end;
TSafeArray = tagSAFEARRAY;
{$EXTERNALSYM SAFEARRAY}
SAFEARRAY = TSafeArray;


Ahora no se cual de esas propiedades usar para pasar a string, ni como hacerlo.

Gracias

[roman]

Pues no parece tener mucho sentido esto. Son estructuras totalmente disímiles. ¿Que es lo que esperarías obtener en el string?

// Saludos

[Lizeth]

Necesito recuperar lo que tiene y pasarlo al string para guardarlo en la base de datos. Es que asi me lo piden que lo guarde como string .

Gracias por la respuesta

[roman]

Pues entonces pide que te expliquen exactamente qué es lo que desean.

Mira, es cierto que un string puede almacenar cualquier secuencia de bytes y no sólo caracteres, así que en ese sentido puede guardar "cualquier" cosa. Pero la estructura que mencionas tiene un apuntador (pvData), lo cual no tiene sentido guardar pues es una dirección de memoria que cambia en cada ejecución. También tiene el campo rgsabound que, por la forma en que está declarado, suele apuntar a arreglos de longitud variable y habría que ver qué hay en cada arreglo.

Dicho esto, vamos a suponer que TSafeArray estuviera declarado así:

Código Delphi [-]
TSafeArray = record
  cDims: Word;
  fFeatures: Word;
  cbElements: Longint;
  cLocks: Longint;
end;

es decir, sin los elementos conflictivos.

Una forma de pasar el contenido de un SafeArray a un String podría ser esta:

Código Delphi [-]
SetLength(s, SizeOf(a));
Move(a, s[1], SizeOf(a));

donde s es un String y a de tipo TSafeArray.

Para recuperar el valor guardado en un string a un SafeArray harías lo contrario:

Código Delphi [-]
Move(s[1], a, SizeOf(a));

// Saludos

[LoPiTaL]

SetLength(s, SizeOf(a));
Move(a, s[1], SizeOf(a));

Hola, roman. ¿Realmente funcionaría este código? Si alguno de los campos en a tiene como valor $00 (caracter final de string), entonces no podrías recuperar lo que vaya después, perdiendo parte de la estructura...

Yo usaría las funciones que proporciona Delphi, creo que eran BinToHex y HexToBin, que convierte un buffer en un string con caracteres hexadecimales y viceversa.

Un saludo,
LoPiTaL

[[Al González]]

Lizeth: ¿Qué dice la documentación de la interfaz IConsolidationResult referente a su propiedad Template?

Como dice Román, habría que ver qué contiene ese arreglo.

En Delphi existen varias funciones para tratar con variantes arreglos. Se puede conocer cuáles son sus dimensiones, el tamaño de los elementos, etc. Es decir, sacar el dato "crudo" del arreglo y copiarlo a un String es viable, pero antes hay que entender qué viene en el SafeArray.

¿Algún enlace Web a la documentación de esa interfaz? ¿Tienes el manual o ayuda de de esa interfaz a la mano? ¿A qué biblioteca pertenece?

Saludos.

Al González.

[roman]

Empezado por LoPiTaL

Hola, roman. ¿Realmente funcionaría este código? Si alguno de los campos en a tiene como valor $00 (caracter final de string), entonces no podrías recuperar lo que vaya después, perdiendo parte de la estructura...

Sí que puedes. Recuerda, un string, pese a lo que normalmente entendemos por él (una secuencia de caracteres alfanuméricos), en realidad puede almacenar cualquier secuencia de bytes, incluido el cero. El detalle aquí es cómo recuperas la información. Si utilizas un string para almacenar caracteres no alfanuméricos, no puedes esperar usar dicho string en contextos alfanuméricos, por ejemplo, en un ShowMessage.

Haz esta prueba (con la declaración que yo puse del SafeArray):

Código Delphi [-]
var
  a, b: TSafeArray;
  s: String;

begin
  a.cDims := 84;
  a.fFeatures := 3254;
  a.cbElements := 0;
  a.cLocks := 6;

  SetLength(s, SizeOf(a));
  Move(a, s[1], SizeOf(a));

  ZeroMemory(@b, SizeOf(b));
  Move(s[1], b, SizeOf(b));
end;

b debe contener una copia exacta de a.

// Saludos

[Lizeth]

Hola gracias chicos, bueno intente lo que dijo Roman así:

Código Delphi [-]
    SetLength(sHuella, SizeOf(ConsolResult.Template));
    Move(ConsolResult.Template.rgsabound, sHuella[1], SizeOf(ConsolResult.Template));
 Memo1.Text := sHuella;

y lo paso a un memo para ver que hay, mm pero me da simbolitos raros, | así.

No les puedo dar mas datos de la clase en donde se encuentra IConsolidationResult porque no me lo permiten , pero si les puedo poner que tiene y es esto, no tengo manual, pero si ayuda, acontinuación les pongo lo que tengo.

Código Delphi [-]
//Dual OleAutomation Dispatchable
 
IConsolidationResult = interface(IDispatch)
    function Get_Success: Byte; safecall;
    function Get_Template: PSafeArray; safecall;
    function Get_Index: Integer; safecall;
    function Get_Quality: Byte; safecall;
    property Success: Byte read Get_Success;
    property Template: PSafeArray read Get_Template;
    property Index: Integer read Get_Index;
    property Quality: Byte read Get_Quality;
  end;

En la ayuda viene esto:

Index Gets the index of the reference input template

Quality Gets the Quality of the resulting template
Success Gets the result of the consolidation process
Template Gets the consolidated fingerprint template buffer

[roman]

Empezado por Lizeth

y lo paso a un memo para ver que hay, mm pero me da simbolitos raros, | así.

Claro, revisa lo que comenté a LoPiTaL. Si guardas datos binarios, no esperes poder verlos en un Memo.

// Saludos

[Lizeth]

Hola, bueno pues despúes de muchas semanas resolvimos el problema. Es en delphi 7. He aqui una posible solución para pasar el contenido de un puntero de un PSafeArray a String en hexadecimal y de String en hexadecimal a PSafeArray. Espero le sirva a alguien.

Código Delphi [-]
unit Unit2;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, OleCtnrs, OleServer, StdCtrls, ActiveX; // Activex más lo que se necesite
  
type
   TByteDynArray = array of Byte;//Declaro mi tipo TBytes 
   TBytes = TByteDynArray;
  TForm2 = class(TForm)   
    Button1: TButton;
    //...
  private
    { Private declarations }
    otoSafe, otoSafe2 : PSafeArray; //Mi variables tipo PSafeArray; 
  public
    { Public declarations }  
  
  end;
var
  Form2: TForm2;
implementation

{$R *.dfm}
 //-------------------------- funciones propias ------------------
function SafeArrayAsByteArray(Arr: PSafeArray): TBytes;
// Convierto de PSafeArray a TBytes
var
 LBound, UBound, i: Integer;
begin
 SafeArrayGetLBound(Arr, 1, LBound);
 SafeArrayGetUBound(Arr, 1, UBound);
 SetLength(result, UBound-LBound+1);
 for i := LBound to UBound do 
   SafeArrayGetElement(Arr,i,result[i]); 
end;

function ByteToHex(InByte: byte): shortstring;
// Pasa de Byte a un shortstring en hexadecimal
const Digits:array[0..15] of char='0123456789ABCDEF';
begin
   result:=digits[InByte shr 4] + digits[InByte and $0F];
end;

function ByteToStr(const Value: TBytes): String;
// Paso de Byte a String
var
    I: integer;
    S, CR : String;
    Letra: char;
begin
    S := '';
    for I := 0 to Length(Value)-1 do
     begin
        CR:= ByteToHex(Value[i])+':';
        S := S+CR;
    end;
    Result := S;
end;
function StrToByte(const Value: String): TBytes;
// Hacemos la inversa de mi string a TByte 
var
   I,j: integer;
   iPos  : integer;
   Hex : TBytes;
   sCaden, sCopia : string;
begin
   SetLength(Result, Length(Value)div 3);
    j:= 0;
    for I := 1 to Length(Value) - 1 do
    begin
      if Value[i] = ':' then
       begin
         Result[j]:= strToInt('$'+ sCaden);
         sCaden := '';
         inc(j);
       end
      else
       sCaden:= sCaden + Value[i];
    end;
end;
function ByteArrayAsSafeArray(Arr: TBytes): PSafeArray;
// La inversa de TBytes a PSafeArray;
var
  pvData: PByteArray;
  Bounds: TVarArrayBoundArray;
begin
   Bounds[0].LowBound:=0;
   Bounds[0].ElementCount:=Length(Arr);
   Result := SafeArrayCreate(varByte, 1, Bounds);
   SafeArrayAccessData(Result, Pointer(pvData));
   Move(Arr[0], pvData[0], Length(Arr));
end;
//--------------------------------------- funciones <-------------------------------
// Como las uso
procedure TForm2.Button2Click(Sender: TObject);
var 
   mibyte, prueba : TBytes;  
begin
  
    otoSafe   := coderResult2.Template; // yo tengo esto que es de tipo PSafeArray;
    mibyte    := SafeArrayAsByteArray(otoSafe);  
    Edit1.Text:= ByteToStr(mibyte);
    prueba    := StrToByte(Edit1.Text);//la inversa
    otoSafe2  := ByteArrayAsSafeArray(prueba);
    
end;

[rodrinig]

hola Lizeth, estuve viendo y me parace que es para guardar la lectura de una huella , puede ser?

Muchas Gracias

Rodrigo