Tratamiento de constantes

[apicito]

Buenas.
Como respuesta de un webService obtengo un parámetro Estado que es de tipo EstadoTipo y que se compone de un array de posibles valores.

EstadoTipo = (NO_LEIDA, ACEPTADA, RECHAZADA, EXPIRADA);

No sé como trabajar con el valor que me devuelve. Si intento cargarla en memo para ver los valores devueltos me dice que no es un string y me ofrece los posibles valores de la constante.
Puedes ver la imagen del IDE

Alguien puede explicarme como trabajar con estos valores.
Gracias.

[Caminante]

Hola

Esa definicion es de un tipo enumerado no una constante.

Saludos

[Casimiro Notevi]

Los valores son los que pone en la imagen: 0, 1, 2, 3

[apicito]

Gracias por la respuesta.

Y como hago para obtener el valor que me viene?
Por que si hago:

  memo.Lines.Add('Estado '+result.Metadatos[i].Estado);

Obtengo el error de compilación:
[dcc32 Error] Unit1.pas(115): E2010 Incompatible types: 'string' and 'EstadoTipo'

Saludos.

[Caminante]

Hola

Pues en delphi 7 lo que haria seria declarar un array.

Código Delphi [-]
Valores:array[No_leida..expirada]of string=('No leida','Aceptada','Rechazada,'Expirada');

Y lo usaria asi:

Código Delphi [-]
memo.Lines.Add('Estado '+ valores[result.Metadatos[i].Estado]);

Bueno no lo he probado asi que tal vez halla que hacerle unos ajustes. Pero creo que se entiende la idea.

Saludos

[apicito]

Este valor lo recibo como respuesta a una petición SOAP y se carga en una TRemotable con esta definición:

  MetadatosTipo = class(TRemotable)
  private
    FticketID: ticketID;
    FMensajeID: IDGlobalTipo;
    FEstado: EstadoTipo;
    FEmisor: TipoNIF;
    FNombreEmisor: NombreEmisorTipo;
    FNombreEmisor_Specified: boolean;
    FTitular: TipoNIF;
    FNotificado: TipoNIF;
    FTipoMensajeria: TipoMensajeTipo;
    FActoNotificado: ActoNotificadoTipo;
    FActoNotificado_Specified: boolean;
    FAsunto: AsuntoTipo;
    FCuerpo: CuerpoTipo;
    FCuerpo_Specified: boolean;
    FDetalles: DetallesMensajeTipo;
    FDetalles_Specified: boolean;
    FNombreFicheroAdjunto: NombreFicheroAdjuntoTipo;
    FNombreFicheroAdjunto_Specified: boolean;
    FFerchaPuestaDisposicion: TXSDateTime;
    FEventoRecogida: InformacionEventoTipo;
    FEventoRecogida_Specified: boolean;
    FDatosRecogida: DatosRecogidaTipo;
    FDatosRecogida_Specified: boolean;
    procedure SetNombreEmisor(Index: Integer; const ANombreEmisorTipo: NombreEmisorTipo);
    function  NombreEmisor_Specified(Index: Integer): boolean;
    procedure SetActoNotificado(Index: Integer; const AActoNotificadoTipo: ActoNotificadoTipo);
    function  ActoNotificado_Specified(Index: Integer): boolean;
    procedure SetCuerpo(Index: Integer; const ACuerpoTipo: CuerpoTipo);
    function  Cuerpo_Specified(Index: Integer): boolean;
    procedure SetDetalles(Index: Integer; const ADetallesMensajeTipo: DetallesMensajeTipo);
    function  Detalles_Specified(Index: Integer): boolean;
    procedure SetNombreFicheroAdjunto(Index: Integer; const ANombreFicheroAdjuntoTipo: NombreFicheroAdjuntoTipo);
    function  NombreFicheroAdjunto_Specified(Index: Integer): boolean;
    procedure SetEventoRecogida(Index: Integer; const AInformacionEventoTipo: InformacionEventoTipo);
    function  EventoRecogida_Specified(Index: Integer): boolean;
    procedure SetDatosRecogida(Index: Integer; const ADatosRecogidaTipo: DatosRecogidaTipo);
    function  DatosRecogida_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property ticketID:                ticketID                  Index (IS_ATTR) read FticketID write FticketID;
    property MensajeID:               IDGlobalTipo              read FMensajeID write FMensajeID;
    property Estado:                  EstadoTipo                read FEstado write FEstado;
    property Emisor:                  TipoNIF                   read FEmisor write FEmisor;
    property NombreEmisor:            NombreEmisorTipo          Index (IS_OPTN) read FNombreEmisor write SetNombreEmisor stored NombreEmisor_Specified;
    property Titular:                 TipoNIF                   read FTitular write FTitular;
    property Notificado:              TipoNIF                   read FNotificado write FNotificado;
    property TipoMensajeria:          TipoMensajeTipo           read FTipoMensajeria write FTipoMensajeria;
    property ActoNotificado:          ActoNotificadoTipo        Index (IS_OPTN) read FActoNotificado write SetActoNotificado stored ActoNotificado_Specified;
    property Asunto:                  AsuntoTipo                read FAsunto write FAsunto;
    property Cuerpo:                  CuerpoTipo                Index (IS_OPTN) read FCuerpo write SetCuerpo stored Cuerpo_Specified;
    property Detalles:                DetallesMensajeTipo       Index (IS_OPTN) read FDetalles write SetDetalles stored Detalles_Specified;
    property NombreFicheroAdjunto:    NombreFicheroAdjuntoTipo  Index (IS_OPTN) read FNombreFicheroAdjunto write SetNombreFicheroAdjunto stored NombreFicheroAdjunto_Specified;
    property FerchaPuestaDisposicion: TXSDateTime               read FFerchaPuestaDisposicion write FFerchaPuestaDisposicion;
    property EventoRecogida:          InformacionEventoTipo     Index (IS_OPTN) read FEventoRecogida write SetEventoRecogida stored EventoRecogida_Specified;
    property DatosRecogida:           DatosRecogidaTipo         Index (IS_OPTN) read FDatosRecogida write SetDatosRecogida stored DatosRecogida_Specified;
  end;

y EstadoTipo se define como:

  EstadoTipo = (NO_LEIDA, ACEPTADA, RECHAZADA, EXPIRADA);

Al intentar leer los datos de la respuesta en cuando no sé como acceder al valor que trae.

Como ves en la imagen del otro post me ofrece los posibles valores de EstadoTipo.

Y si intento

memo.Lines.Add('Estado '+result.Metadatos[i].Estado);

me da el error de compilación que puse en el otro post.

De hecho, si lo vuelco en un xml obtengo su valor:

<tns:RespuestaConsulta xmlns:ape="urn:correos.es:ape.sne.datos.1.0" 
                       xmlns:ds="http://www.w3.org/2000/09/xmldsig#" 
					   xmlns:tns="urn:correos.es:ape.sne.ws.accesobuzon.1.0">
	<tns:Paginacion>
		<tns:pagina>1</tns:pagina>
		<tns:totalPaginas>2</tns:totalPaginas>
		<tns:numeroElementos>30</tns:numeroElementos>
	</tns:Paginacion>
	<tns:Metadatos tns:ticketID="148620">
		<tns:MensajeID>1485796663920-1-0</tns:MensajeID>
		<tns:Estado>NO_LEIDA</tns:Estado>
		<tns:Emisor>28972577Y</tns:Emisor>
		<tns:NombreEmisor>Servicio de Notificaciones Electrónicas SNE</tns:NombreEmisor>
		<tns:Titular>P3208600A</tns:Titular>
		<tns:Notificado>P3208600A</tns:Notificado>
		<tns:TipoMensajeria>NOTIFICACION</tns:TipoMensajeria>
		<tns:ActoNotificado>PRUEBAS</tns:ActoNotificado>
		<tns:Asunto>Prueba Notificacion</tns:Asunto>
		<tns:Cuerpo>esto es una prueba de Notificacion WS</tns:Cuerpo>
		<tns:Detalles />
		<tns:FerchaPuestaDisposicion>2017-01-30T18:18:04+01:00</tns:FerchaPuestaDisposicion>
	</tns:Metadatos>
</tns:RespuestaConsulta>

[bitbow]

Si tienes
EstadoTipo = (NO_LEIDA, ACEPTADA, RECHAZADA, EXPIRADA);
Al final solo tienes de que tipo es el estado actuamente, solo necesitas compar el Estadotipo.

con algun case o varios if y devolver la cadena que desees.

Estadotipo no va a contener un valor si no el tipo.

Saludos.

[apicito]

Gracias bitbow.
No había trabajado nunca con este tipo de datos y me estaba volviendo loco.
Ahora lo entiendo:

         case result.Metadatos[i].Estado of
             EstadoTipo.NO_LEIDA: Estado := 'NO_LEIDA';
             EstadoTipo.ACEPTADA: Estado := 'ACEPTADA';
             EstadoTipo.RECHAZADA: Estado := 'RECHAZADA';
             EstadoTipo.EXPIRADA: Estado := 'EXPIRADA';
         end;

Un saludo.

[[AgustinOrtu]]

Podes usar este truco: Ayudante para tipos enumerados

Código PHP:

var
  s: string;
begin
  s := Enum<EstadoTipo>.ValueName(result.Metadatos[i].Estado);
end; 


[ecfisa]

Hola.

Para versiones mas antiguas de Delphi, otra opcion es:

Código Delphi [-]
uses TypInfo;
...
function StateName( const Estado: EstadoTipo ): string;
begin
  Result := GetEnumName( TypeInfo( EstadoTipo ), Ord( Estado ) );
end;

Uso:

Código Delphi [-]
...
  Estado := StateName( result.Metadatos[i].Estado );

  // o de forma directa: 
  Estado := GetEnumName( TypeInfo( EstadoTipo ), Ord( result.Metadatos[i].Estado ) );

Saludos

[apicito]

Gracias [AgustinOrtu] y ecfisa.
Al final é optado por la solución de ecfisa:

uses TypInfo;
...
memo.Lines.Add('Estado '+GetEnumName( TypeInfo( EstadoTipo ), Ord( result.Metadatos[i].Estado )));

[apicito]

Abusando de vuestra paciencia, aprovecho que ya está en el post #6 de este hilo la definición del TRemotable y el xml que se me devuelve para hacer otra pregunta.
Si el xml me devuelve el valor del TicketID en esta etiqueta:

	<tns:Metadatos tns:ticketID="148620">
		<tns:MensajeID>1485796663920-1-0</tns:MensajeID>

y está definido en el TRemotable como:

  MetadatosTipo = class(TRemotable)
  private
    FticketID: ticketID;
  ....
  published
    property ticketID:                ticketID                  Index (IS_ATTR) read FticketID write FticketID;

Como puedio obtener el valor del TicketID?.
Por que a pesar de que el IDE me lo sugiere como uno de los miembros de result.Metadatos[i], si hago:

memo.Lines.Add('ticketID '+result.Metadatos[i].ticketID);

me apareceen blanco.
Tengo que hacer algo distinto al estar declarado com IS_ATTR?.
Un saludo.