Hex to Base64

[Cubysoft]

Hey,

das funktioniert perfekt.. aber kannst du mich bitte kurz aufklären, wieso die ID automatisch in LittleEndian ausgegeben wird? Macht das Int32()?

[Sir Rufo]

Zitat:

Zitat von Cubysoft (Beitrag 1300674)

Hey,

das funktioniert perfekt.. aber kannst du mich bitte kurz aufklären, wieso die ID automatisch in LittleEndian ausgegeben wird? Macht das Int32()?

Deswegen http://de.wikipedia.org/wiki/Byte-Re...ware-Beispiele (s. Hardware Beispiele)

Und nein, Int32 sorgt nur für einen 4-Byte-Integer Wert (32bit => 4 Byte)

[Cubysoft]

Achso, aber unter Windows ist eh alles Little Endian.. danke :D

Ich habe jetzt eigentlich alles, was ich wollte, nur eine Sache klappt noch nicht. Ich wollte den in #2 geposteten Weg benutzen, stelle nun aber fest, dass ich dafür ein TIdBytes und nicht TBytes brauche. Außerdem kann ich kein Array vom Type TIdBytes erstellen, obwohl ich IdCoder unter uses eingebunden habe.

"[dcc32 Fehler] Project1.dpr(29): E2003 Undeklarierter Bezeichner: 'TIdBytes'"

Außerdem scheinen die beiden Typen auch, obwohl sie den gleichen Aufbau haben nicht kompatibel zueinander zu sein. Könnt ihr mir noch sagen, wie ich dann jetzt and meinen Base64 String aus dem TBytes Array komme? :)


PS: Sir Rufo, ich habe dir in Skype mal ne Anfrage geschickt, eventuell kannst du mir da kurz helfen, da kommen wir schneller zu einer Lösung

[himitsu]

gleicher Auffbau <> identischer Aufbau

Und ich versteh nicht, warum du TIdBytes nicht finden kannst.

• der steht garantiert in Indy-Hilfe (man mag es nicht glauben, aber F1 sagt mir genau wo der Typ zu finden ist)
• Strg+Shift+F findet immer alles ... garantiert
• du hast eine Funktion, welche diesen Typ benutzt, also kann man entweder über Help Insight nachsehn wo der her kommt oder man geht zur Deklaration der Funktion und lässt sich von da zur Typ-Deklaration weiterleiten
• ...

[Sir Rufo]

Also

Delphi-Quellcode:

TIdBytes

befindet sich in der unit

Delphi-Quellcode:

IdGlobal

.

Um von

Delphi-Quellcode:

TBytes

nach

Delphi-Quellcode:

TIdBytes

zu kommen, kann man

1. das benutzen
   
   Delphi-Quellcode:

   function BytesToIdBytes( const ABuffer: TBytes ): TIdBytes;
   begin
     SetLength( Result, Length( ABuffer ) );
     Move( ABuffer[ 0 ], Result[ 0 ], Length( ABuffer ) );
   end;

2. oder ganz einfach und stumpf casten, denn es sind beides
   Delphi-Quellcode:

   array of Byte

   Delphi-Quellcode:

   var
     LBuffer : TBytes;
     LIdBuffer : TIdBytes;
   begin
     // LBuffer mit Werten füllen
     LIdBuffer := TIdBytes( LBuffer );
   end;

Es wäre auch nett, wenn du deine Delphi Version angeben könntest, dann wäre es auch einfacher dir die richtigen Units zu nennen, bzw. in den neueren Versionen sind viele Sachen schon von Haus aus enthalten.

Die Delphi-Version kannst das hier im Thread machen, oder wesentlich geschickter in deinem Profil vermerken.

[Sir Rufo]

Und hier nochmal das Beispiel erweitert mit dem Base64 Encoding und mit einem eigenen Datentyp

Delphi-Quellcode:

program dp_185013;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.Classes,
  System.NetEncoding,
  System.SysUtils;

type
  TMyData = packed record
    Header: Byte;
    Amount: Byte;
    Data: Int32;
    Tail: Byte;
  end;

procedure OutputBuffer( ABuffer: TBytes );
var
  I: Integer;
begin
  for I := low( ABuffer ) to high( ABuffer ) do
  begin
    write( IntToHex( ABuffer[ I ], 2 ), ' ' );
    if ( I + 1 - low( ABuffer ) ) mod 16 = 0 then
      Writeln;
  end;
  Writeln;
end;

procedure TestData;
var
  LData: TMyData;
  LBuffer: TBytes;
begin
  // Daten in den Record schreiben
  LData.Header := $02;
  LData.Amount := StrToInt( '1' );
  LData.Data := StrToInt( '46762' );
  LData.Tail := 0;

  // Buffer auf Mass bringen
  SetLength( LBuffer, SizeOf( TMyData ) );
  // Record in einem Rutsch in den Buffer kopieren
  Move( LData, LBuffer[ 0 ], Length( LBuffer ) );

  // Ausgabe als HEX
  OutputBuffer( LBuffer );
  // Ausgabe als Base64
  Writeln( TNetEncoding.Base64.EncodeBytesToString( LBuffer ) );
end;

procedure Test;
var
  LStream: TMemoryStream;
  LBuffer: TBytes;
begin
  LStream := TMemoryStream.Create;
  try
    // Daten in den Stream
    LStream.WriteData( $02 );
    LStream.WriteData( Byte( StrToInt( '1' ) ) );
    LStream.WriteData( Int32( StrToInt( '46762' ) ) );
    LStream.WriteData( $00 );

    // Stream-Inhalt nach TBytes kopieren
    SetLength( LBuffer, LStream.Size );
    LStream.Position := 0;
    LStream.Read( LBuffer, Length( LBuffer ) );
    // Ausgabe der TBytes zur Kontrolle
    OutputBuffer( LBuffer );

    Writeln( TNetEncoding.Base64.EncodeBytesToString( LBuffer ) );
  finally
    LStream.Free;
  end;
end;

begin
  try
    Test;
    TestData;
  except
    on E: Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

[Cubysoft]

Danke Sir Rufo und allen anderen. Es funktioniert perfekt.. Ich habe es vorher mit der Encode64 Funktion versucht und die lieferte mir einfach schlicht falsche Ergebnisse. Vielen Lieben Dank an alle!

[Popov]

Vielleicht noch soviel, weil es nicht erwähnt wurde - allgemein (beim PC) besteht ein Byte aus 8 Bits. Früher nutzte man für Text-Nachrichten aber nur 7 Bits. Soweit ich also immer noch richtig informiert bin, wurden (oder werden immer noch) z. B. bei Emails nur 7 Bits genutzt. Das 8. Bit bleibt ungenutzt. Wie gesagt, ich weiß nicht ob das immer noch so ist, sollte es aber.

Damit ergibt sich aber die Frage wie man Dateien mit Email verschickt die 8 Bits nutzen (also de facto fast alles), Man könnte also alles auf 7 Bit runter rechnen. Das Problem dabei ist aber, dass das 7 Bit Textsystem auch Steuerzeichen nutzt. Man kann also nicht alle 127 Ascii-Zeichen (7 Bits) nutzen. Also zieht man die ersten 32 Zeichen (inkl. Null) ab. Das Leerzeichen eignet sich auch nicht, also 33. Bleiben ca. 94 Zeichen. Also 7 Bits kann man klicken. 7 Bits minus 1 Bit machen 6 Bit. Die Sonderzeichen könnte man nutzen, das ganze würde eher so 6 1/2 Bits bringen. Geht nicht. Also ganze 6 Bits, das macht 64 Zeichen. Also nimmt man die Zeichen A-Z, a-z, 0-9, = und noch ein Zeichen.

Base64 ist also 8 Bit auf 6 Bit runter gerechnet.