Kurze Erklärung der Codezeilen: Das Objekt welches den Lesevorgang unterstützt ist der FileStream. Diesen erzeugen wir mit Hilfe der File Klasse, indem wir ein File öffnen. Unter FileMode finden wir noch andere Optionen, welche das File verändern oder auch neu erzeugen können. Die einzelnen Bytes lesen wir mit ReadByte() aus, wobei diese Methode überraschenderweise einen int Wert zurückgibt und kein byte. Dies liegt daran, dass wenn das Ende des Files erreicht wurde, die Methode -1 zurückgibt. Der Rückgabewert muss also 256 mögliche Bytewerte plus die -1 abbilden können, wodurch der Datentyp byte ausscheidet. Die Ausgabe des Bytes formatieren wir in ein Hexadezimalformat, da es für die Bytedarstellung so üblich ist. Der Öffne- und Lesevorgang kann diverse Exceptions hervorrufen, weshalb ich hier der Einfachheit halber alle Exceptions über einen Kamm schere. Dies ist nicht besonders elegant – für unsere Zwecke aber erstmal ausreichend. Wichtig ist, dass wir in einem finally Block den Filestrom schließen. Dies würde mit Close(), oder wie hier gezeigt mit Dispose() gehen, was im Wesentlichen das Gleiche ist.

Kurze Erklärung der Codezeilen: Bei der Pfadangabe müssen wir für Windows Systeme den Backslash doppelt hinterlegen. Dies wird später nochmal bei der Escape Notwendigkeit erklärt. Ich gehe hier einfach davon aus, dass unter dem C:\temp Verzeichnis die Datei MyBitmap.bmp befindet. Hier kann jede beliebige Datei (die aktuell nicht von einem anderen Programm geöffnet ist) eingetragen werden.

Kurze Erklärung der Codezeilen: using kümmert sich um das automatische Schließen des Filestroms. Wir haben zwar keine trenngenaue Ausgabe einer möglichen Fehlersituation, da kein catch() mehr vorhanden ist – für die meisten Fälle dürfte dies aber ausreichend sein.

Kurze Erklärung der Codezeilen: Die Unterschiede zu C# sind minimal. Java hält die Funktionalität für das Öffnen eines Files nicht in statischen Methoden, sondern kapselt sie in einem Objekt der Klasse File. Der Konstruktor FileInputStream() akzeptiert dieses File, wobei er auch direkt einen String mit dem Filenamen fName verarbeiten würde, wodurch das File Objekt entfallen könnte. Ansonsten ist Java etwas stringenter beim Abfangen von Exceptions. So muss bspw. auch beim Schließen mit einer IOException gerechnet werden

Kurze Erklärung der Codezeilen: Da wir eine klar definierte Anzahl an Bytes lesen wollen, können wir das myBuffer Array mit einer festen Größe erzeugen. In readBytes legen wir die tatsächlich gelesene Anzahl an Bytes ab. Dies ist dann sinnvoll, wenn das File weniger Bytes hat, als in noOfBytes gefordert wird. Das Lesen beginnen wir mit dem Offset 0 – wir wollen das File von Anfang an lesen. Nach dem Lesevorgang geben wir die gelesenen Bytes aus.

Kurze Erklärung der Codezeilen: In C werden die Fileleseoperationen mit fopen(), fread() und fclose() erledigt. Hierbei wird das File durch fopen() geöffnet und ein Zeiger hierauf zurückgegeben. fread() erwartet ein Array als myBuffer, welches den Inhalt aufnimmt. Da C keinen Datentyp byte kennt, verwenden wir unsigned char, was gleichbedeutend ist. Die Funktion erwartet noch die Größe eines zu lesenden Elements (also ein Byte) und die Anzahl der maximal zu lesenden Bytes – und natürlich den Zeiger auf das File. Als Rückgabewert erhalten wir dann wieder die Anzahl der tatsächlich gelesenen Bytes. Da wir den myBuffer über malloc() dimensioniert haben, müssen wir mit free() den Speicherplatz wieder freigeben. Weiterhin dürfen wir auch hier das Schließen des Files nicht vergessen. Die Ausgabe wurde über printf() realisiert und hierbei die C-interne Funktionalität der Hex-Ausgabe über %02x (also zweistellige Hexadezimaldarstellung) formatiert. Das Errorhandling habe ich mir hier gespart. Wer Fehler prüfen möchte, kann die Funktion ferror() nutzen.

Kurze Erklärung der Codezeilen: Die Funktionalitäten für das Filesystem befinden sich in der fs Bibliothek. Dort liegen auch die Funktionen zum Lesen, Umbenennen, Löschen etc. Die Vorgehensweise für das Lesen ist erstmal nichts neues. Da JavaScript jedoch dynamisch typisiert ist, können wir kein Bytearray (bzw. wie in C ein unsigned char Array) verwenden, sondern müssen ein speziell für diese Daten vorbereitetes Objekt verwenden – den Buffer. Dieser wird mit der benötigten Größe allokiert (sprich „erzeugt“). Danach wird das File geöffnet. In JavaScript kann man hierfür die open() Methode aus der fs Bibiothek verwenden. Diese Methode benötigt wieder den Filenamen und die Information, dass gelesen wird („r“ steht hier für read). Der dritte Parameter ist eine sogenannte „Callback Funktion“ für die Verarbeitung, sprich dem Lesen des Files. Ähnlich wie bei den Lambda Ausdrücken in Java tragen wir hier die Funktion ein, welche nach der Ausführung von open() aufgerufen wird. Sollte der Parameter err leer sein, so wurde die Datei geöffnet, ansonsten wird die Fehlermeldung ausgegeben. Im Erfolgsfall lesen wir wieder die notwendige Anzahl an Bytes in den myBuffer und merken uns, wie viele Bytes tatsächlich gelesen wurden. Diese geben wir anschließend als Hexwert (also Basis 16) aus

Kurze Erklärung der Codezeilen: „rb“ steht wie in C für „read binary“. Der read() Befehl erwartet lediglich die Anzahl der Bytes und liefert ein „iterierbares“ Objekt – also eine Datenmenge, welche mit einer Zählschleife ausgelesen werden kann. Dieses Objekt kann entweder als Parameter eines Konstruktors für eine list verwendet werden – also einem arrayähnlichem Konstrukt, oder wie im oberen Code einfach einer foreach Schleife übergeben werden, in der wir jedes Element in die Variable myByte schreiben. Mit print(hex(myByte)) geben wir die Bytes als Hexadezimalwerte aus. Wie bei den anderen Sprachen auch, muss ich das geöffnete File am Ende schließen. Das Errorhandling sollte an dieser Stelle selbsterklärend sein.

Kurze Erklärung der Codezeilen: Da die PHP Lesefunktion fread() nicht die Anzahl der gelesenen Bytes sondern den Fileinhalt als String zurückgibt, müssen wir die einzelnen Bytes aus dem String mittels ord() extrahieren. Wir werden weiter unten nochmal den Unterschied zwischen Text und Bytes klären. Soviel sei hier gesagt – wir greifen uns mit Hilfe der Zählschleife die einzelnen gelesenen Zeichen ab und wandeln sie mit ord() in eine Bytezahl um, die wir wiederum mit dechex() in einen Hexwert konvertieren. Die Option „rb“ der fopen() Funktion steuert hier nicht die Interpretation der Daten als Byte, sondern im Wesentlichen den Umgang mit dem Zeilentrenner, über den wir auch weiter unten nochmal sprechen werden.

Kurze Erklärung der Codezeilen: Zuerst werden die RGB Werte aus der color Variable extrahiert. Die noOfZero Berechnung entspricht dem oben beschriebenen Algorithmus. Die Größe des body Arrays berechnet sich auf Basis der Breite * 3 (wegen 3 Bytes pro Pixel) plus die errechneten Füllwerte mit 0 und der Höhe. Die beiden Schleifen gehen die Zeilen (r für Rows) bzw. Spalten (c für Columns) durch und setzen jeweils die RGB Werte. Nach jeder Zeile werden mit einer eigenen Schleife die 0x00 Werte gefüllt. Dies ist streng genommen nicht notwendig, da die Initialisierung mit 0 in C# automatisch erfolgt. Damit der Code aber einfacher in die anderen Programmiersprachen portierbar ist, belasse ich diesen Teil.

Kurze Erklärung der Codezeilen: Wir benötigen als Parameter den eigentlichen Wert, welcher übernommen werden muss als Variable value. Weiterhin übergeben wir das Zielarray allBytes, in das wir die Information ablegen müssen und schließlich noch den offset, wo dies geschehen soll. Nun schneiden wir die rechten 8 Bits heraus und übergeben sie in das Array. Danach schieben wir um 8 Bits nach rechts, um die nächsten Bits zu übergeben. Das erfolgt, solange wir noch Werte ungleich 0 in der value Variable haben. Das Errorhandling beschränkt sich darauf, dass wir prüfen, ob wir nicht außerhalb des Arraybereiches schreiben. Wenn dies der Fall ist geben wir false zurück, ansonsten true.

Kurze Erklärung der Codezeilen: Die Headerinformationen werden als Template in ein head Array vorab belegt. Sämtliche vorab festlegbaren Informationen werden hier eingetragen. Danach wird geprüft, ob die Daten des zweidimensionalen Arrays überhaupt verarbeitbar sind – was im Wesentlichen dann ein Problem ist, wenn eine der beiden Dimensionen 0 ist. Nun können wir die Byteanzahl ermitteln. Da C# uns die Daten in einem Array in Matrixform ermöglicht, müssen wir hier nur die Länge ermitteln. Bei Java muss hier eine Berechnung erfolgen. Nun ermitteln wir die Filegröße als Summe des Headers und Bodys. Alle dynamisch zu setzenden Größen platzieren wir nun mit Hilfe unserer setBytesLittleEnd() Methode in das Headerarray. Sollte hier ein Fehler passieren (also die Methode ein false zurückliefern), geben wir einfach null zurück, was somit die Indikation eines Fehlers für den Aufrufer von prepareBmp() ist. Da C# hier ein Warning generiert um den Programmierer darauf hinzuweisen, dass diese null-Rückgabe ein Problem erzeugen könnte, schreiben wir ein ! („null forgiving operator“ oder „null-toleranter Operator) hinter der null, um dem Compiler mitzuteilen, dass wir dies im Blick haben. Nun erzeugen wir das eigentliche Datenarray und belegen es sequenziell zuerst mit den Header und anschließend den Bodydaten.

Kurze Erklärung der Codezeilen: Die Höhe und Breite benötigen wir sowohl für genBmpData() als auch für prepareBmp(), weshalb wir die Werte in Variablen halten um die Konsistenz zu garantieren. Wenn data korrekt erzeugt wurde – sprich data nicht null ist, können wir die Bytes mit Hilfe der Methode File.WriteAllBytes() schreiben und eine entsprechende Erfolgsmeldung ausgeben.

Kurze Erklärung der Codezeilen: Hier ist es natürlich wichtig, zuerst die 0. Dimension mit .length zu prüfen. Erst wenn wir mindestens eine Zeile haben, können wir die Spalten der 0. Zeile – also die 1. Dimension – prüfen.

Kurze Erklärung der Codezeilen: Die Java Implementierung ist funktional bis auf das Errorhandling identisch mit der C# Methode File.WriteAllBytes(). Zuerst erzeugen wir das File, welches die Kommunikation mit dem Filesystem aufbaut. Hier können wir auch prüfen, ob das File eventuell bereits existiert. Wenn ja, dann informieren wir den User lediglich, dass wir es jetzt überschreiben. An dieser Stelle könnten wir nun problemlos eine Abfrage hinterlegen, damit der User selbst darüber entscheiden kann – der Einfachheit halber habe ich dies weggelassen. Nun erzeugen wir den FileOutputStream, der dafür verantwortlich ist die Bytedaten auf das Filesystem zu schreiben. Die Information wo dies geschehen soll, erhält der Stream vom Fileobjekt. Der boolean Parameter false zeigt an, dass wir das File überschreiben. Würde er auf true stehen, so würde der neue Inhalt am Ende des Files angehängt werden, was in unserem Fall natürlich nicht sinnvoll ist. Nun können wir das Bytearray in einem Durchgang schreiben. Das flush() Kommando soll den Schreibpuffer des FileOutputStream leeren, indem das Schreiben erzwungen wird. Dies ist an dieser Stelle eigentlich nicht notwendig, da beim Schließen dies ohnehin geschieht – ich habe ihn jedoch eingebaut, dass man sieht, wie man dies zwischen zwei Bytearrays erledigen könnte. Der FileOutputStream würde übrigens auch die Daten Byte für Byte schreiben können (also wirklich fos.write(oneByte); – wobei dies, wie bereits beim Lesen von Files erwähnt, aus Performancegesichtspunkten zu vermeiden ist. Jede einzelne Kommunikation mit dem Filesystem kostet ja Ressourcen. Java zwingt mich, die IOException abzufangen, welche bei Fehlern während des Schreibvorganges auftreten könnten. Stellen wir uns vor, wir würden auf einen USB- Stick schreiben und diesen während des Schreibvorganges abziehen, dann würde diese Exception auftreten. Im finally() Block schließen wir den Strom wieder – allerdings nur, wenn er auch tatsächlich existiert. Wenn bspw. der Pfad nicht existieren würde, dann wäre fos auf null, was wir natürlich vorher abprüfen müssen.

Kurze Erklärung der Codezeilen: C kennt weder byte, noch zweidimensionale Arrays. Insofern verwenden wir wieder unsigned char (was genau einem Byte entspricht) und das Ganze als eindimensionales Array bzw. Pointer, so wie wir es in Kapitel 7 erläutert haben. Der Zugriff auf das body Array erfolgt somit über body[r * rowWidth + c]. Die Größenangaben werden nun außerhalb ermittelt und über die Parameterliste übergeben. C organisiert den Filezugriff über einen FILE Pointer, den wir mit fopen() öffnen. Hier geben wir „w“ für Write und „b“ für Binary an – dies ist insbesondere bei Windows wichtig, da der Schreibprozess sonst als „Text“ interpretiert wird und nach jedem Byte „0xa“ ein „0xd“ gehängt wird – C versucht also ein Linefeed nach jedem Carriage Return zu ergänzen (Details zu CR und LF folgen weiter unten). Nun können wir mit Hilfe der fwrite() Funktion die Daten schreiben. fwrite() erwartet den Pointer auf das Array, die Größe des zu schreibenden Elementes (in unserem Fall die Größe des Gesamtinhaltes) und die Anzahl der Elemente (bei uns ist dies nur eines). Am Schluss müssen die beiden Arrays, welche in genBmpData() und prepareBmp() allokiert wurden, wieder freigegeben und das File geschlossen werden.

Kurze Erklärung der Codezeilen: Wir verwenden hier die kombinierte Methode zum Öffnen und Schreiben von Files inklusive eines Errorhandlers. Neben dem Filenamen benötigt die Funktion natürlich auch die Daten – hier wieder als Buffer. Als weiteren Parameter wird die Codierung benötigt – welche wir mit binary angeben. Wir schreiben also 1:1 die Binärdaten. Der dritte Parameter ist das bereits bekannte Konstrukt der „Callback Funktion“ für die Verarbeitung des „Ergebnisses“. Nach der Ausführung von writeFile() wird diese aufgerufen und ist hier lediglich für das Errorhandling zuständig. Sollte der Parameter err leer sein, so wurde die Datei geschrieben, ansonsten wir die Fehlermeldung ausgegeben.

Kurze Erklärung der Codezeilen: Wie immer ist der Python Code aufgrund des Verzichts auf viele Strukturzeichen recht kompakt. Das body Array wird als zweidimensionales Array mit fester Zeilenanzahl, jedoch ohne Spalten erzeugt. Man könnte hier zwar auch die Spalten gleich mit erzeugen lassen (body = [[for c in range(3 * width + noOfZero)] for r in range(height)]), ich wollte aber eine einfachere Möglichkeit mit append() aufzeigen, welche vor allem bei der Übernahme von head und body in das data Array der Funktion prepareBmp() (entsprechend der Java Implementierung aus Listing 13) einfacher sein wird. Die Idee bei der Nutzung von append ist, dass wenn man ein Array ohnehin Stück für Stück aufbaut, kann man die neuen Elemente einfach hinten anhängen. Durch die dynamische Erweiterbarkeit von Arrays in den Skriptsprachen ist dies mitunter sinnvoll.

Kurze Erklärung der Codezeilen: Die Python Lösung für die Filezugriffe zeigt wieder bekannte Konzepte. Das Zahlenarray muss mit bytes() in ein bytes Objekt umgewandelt werden, welches immutable ist und nur noch Bytewerte beinhaltet. In JavaScript war dies der Buffer. Danach wird das File zum Schreiben („w“) von Binärdaten („b“) geöffnet, die Bytes geschrieben und dann wieder geschlossen.

Kurze Erklärung der Codezeilen: Der obere Bereich ist wieder vergleichbar mit den vorausgegangenen Lösungen – insofern spare ich mir auch hier die Darstellung der Unterprogramme. Das Schreiben erfolgt in PHP mittels fwrite(), wobei hier ein in Byte konvertierter String benötigt wird – anders als in Python oder JavaScript, wo dies durch ein eigenes Bufferobjekt erfolgte. Die Umwandlung in die Bytedarstellung erledigen wir mittels pack(). Dadurch werden die Zahlen in eine Bytedarstellung umgewandelt und mit dem Punktoperator in die Variable $binData zusammengefügt. Dort befindet sich also der gesamte Inhalt der Datei in Binärformat als eine lange Zahlenkette – nur eben als Stringinformation. Nun öffnen wir ein File mittels fopen() und schreiben mit diese lange Zahlenkette auf das Filesystem. Am Ende wird das File nun geschlossen. Die Herangehensweise ist also vergleichbar mit Python. Wie in Java und C# gibt es hier übrigens auch eine Möglichkeit, das Öffnen, Schreiben und Schließen in einer zusammengefassten Funktion in einem Schritt zu erledigen: file_put_contents("C:\\temp\\MyBitmap.bmp", $binData);

Kurze Erklärung der Codezeilen: Wie oben erwähnt übernimmt der BufferedWriter die Aufgabe des Schreibens auf Stringebene und darüberhinaus noch das Setzen des Zeilenumbruchs, der OutputStreamWriter die Codierung und der FileOutputStream die Kommunikation mit dem Filesystem. Den OutputStreamWriter können wir mit einem Parameter auf die gewünschte Codierung einstellen – in unserem Fall UTF-8. In der Schleife wird dann lediglich Zeile für Zeile mit einem Zeilenumbruch in das File geschrieben. Das Ganze wird mit einem automatischen Ressourcenmanagement erledigt, so dass wir uns das catch und finally sparen können.

Kurze Erklärung der Codezeilen: Das Vorgehen ist mit dem Text schreiben durchaus vergleichbar. Aus „Reader“ werden „Writer“ und aus „Output“ wird „Input“. Der BufferedReader liest das File nun Zeile für Zeile aus und gibt es auf der Konsole aus. Wenn der Reader am Ende des Files angekommen ist, liefert readLine() null zurück, womit wir die Leseschleife abbrechen können.

Kurze Erklärung der Codezeilen: fopen() öffnet das File im Lesemodus („r“). Die für den Buffer maximalen Bytes sollten als Konstante definiert werden, da wir sie sowohl für die Erzeugung des Buffers, als auch für die fgets() Funktion benötigen. Die Tatsache, dass C die Arraylänge nicht ohne weiteres bestimmen kann, macht dies wieder nötig. Da wir vorab nicht wissen, wie lang der Text im File sein wird, müssen wir über eine Schleife den Lesevorgang solange wiederholen, bis fgets() ein false (bzw. 0) zurückliefert, was das Ende des Files indiziert.

Kurze Erklärung der Codezeilen: Nach dem Öffnen des Files im Schreibmodus („w“) wird lediglich der String geschrieben. Zeilenumbrüche müssen hier als „\n“ codiert enthalten sein – wir setzen die Zeielnumbrüche also nicht beim Schreiben wie in Java, wo wir den content als Stringarray erhalten haben. Da in C ein String ohnehin nur ein Array von char ist, ist es nicht wirklich sinnvoll content als Stringarray umzusetzen.

Bei einigen Systemen müssen wir die Ausgabe von stdout erstmal auf UTF-8 umstellen. Dies ist nur dann notwendig, wenn Python in der Konsolenausgabe nicht UTF-8 verwendet. Ansonsten sollte der Code selbster-klärend sein.