Custom IO Device/de: Difference between revisions

From Qt Wiki
Jump to navigation Jump to search
No edit summary
 
m (Wieland moved page Custom IO Device German to Custom IO Device/de: Proper localization)
 
(6 intermediate revisions by one other user not shown)
Line 1: Line 1:
{{Cleanup | reason=Auto-imported from ExpressionEngine.}}
[[Category:Snippets]]
[[Category:Snippets]]
[[Category:German]]
[[Category:German]]
Line 4: Line 6:
'''German''' | [[Custom_IO_Device|English]]
'''German''' | [[Custom_IO_Device|English]]


[toc align_right="yes" depth="2"]


= Wie man ein benutzerdefiniertes I/O-Gerät schreibt =
= Wie man ein benutzerdefiniertes I/O-Gerät schreibt =


Dies ist eine Portierung des Artikels "Qt Quarterly 12 about writing a custom QIODevice":http://doc.qt.nokia.com/qq/qq12-iodevice.html
Dies ist eine Portierung des Artikels [http://doc.qt.nokia.com/qq/qq12-iodevice.html Qt Quarterly 12 about writing a custom QIODevice]


* Hinweis: Ein etwas komplexeres Beispiel findet sich in [[Simple_Crypt_IO_Device]]
* Hinweis: Ein etwas komplexeres Beispiel findet sich in [[Simple_Crypt_IO_Device]]
Line 18: Line 19:
<code>
<code>
  QFile file("output.dat");
  QFile file("output.dat");
  CryptDevice cryptDevice(&amp;file)
  CryptDevice cryptDevice(&file)
  QTextStream out(&amp;cryptDevice);
  QTextStream out(&cryptDevice);
  cryptDevice.open(QIODevice::WriteOnly);
  cryptDevice.open(QIODevice::WriteOnly);
  out << "Hello World";
  out << "Hello World";
</code>
</code>


Zur möglichen Verwendung siehe auch unseren Beispiel-Code in git "qtdevnet-wiki-mvc/qtdevnet-custom-iodevice":http://www.gitorious.org/qtdevnet-wiki-mvc/qtdevnet-custom-iodevice .
Zur möglichen Verwendung siehe auch unseren Beispiel-Code in git [http://www.gitorious.org/qtdevnet-wiki-mvc/qtdevnet-custom-iodevice qtdevnet-wiki-mvc/qtdevnet-custom-iodevice] .


&amp;#32;


=== Verschlüsselung ===
=== Verschlüsselung ===
Line 33: Line 34:
  QByteArray dataArray;
  QByteArray dataArray;


QBuffer bufferUsedLikeAFile(&amp;dataArray);
QBuffer bufferUsedLikeAFile(&dataArray);
  CryptDevice deviceFilter(&amp;bufferUsedLikeAFile);
  CryptDevice deviceFilter(&bufferUsedLikeAFile);
  deviceFilter.open(QIODevice::WriteOnly);
  deviceFilter.open(QIODevice::WriteOnly);
  QTextStream stream(&amp;deviceFilter);
  QTextStream stream(&deviceFilter);
  QString szText = rawText->toPlainText();
  QString szText = rawText->toPlainText();
  stream << szText;
  stream << szText;
</code>
</code>


&amp;#32;


=== Entschlüsselung ===
=== Entschlüsselung ===


<code>
<code>
  QBuffer bufferUsedLikeAFile(&amp;dataArray);
  QBuffer bufferUsedLikeAFile(&dataArray);
  CryptDevice deviceFilter(&amp;bufferUsedLikeAFile);
  CryptDevice deviceFilter(&bufferUsedLikeAFile);
  deviceFilter.open(QIODevice::ReadOnly);
  deviceFilter.open(QIODevice::ReadOnly);
  QTextStream stream(&amp;deviceFilter);
  QTextStream stream(&deviceFilter);
  QString szText = stream.readAll();
  QString szText = stream.readAll();
  decryptedText->setPlainText(szText);
  decryptedText->setPlainText(szText);
Line 69: Line 70:
Unsere ''CryptDevice''-Klasse wird ein sequenzielles I/O-Gerät. Ob es synchron oder asynchron arbeitet, hängt vom darunter liegenden QIODevice ab.
Unsere ''CryptDevice''-Klasse wird ein sequenzielles I/O-Gerät. Ob es synchron oder asynchron arbeitet, hängt vom darunter liegenden QIODevice ab.


h2. Quelltext
== Quelltext ==
 
Die Klassendefinition sieht folgendermaßen aus:
Die Klassendefinition sieht folgendermaßen aus:



Latest revision as of 13:16, 28 June 2015

This article may require cleanup to meet the Qt Wiki's quality standards. Reason: Auto-imported from ExpressionEngine.
Please improve this article if you can. Remove the {{cleanup}} tag and add this page to Updated pages list after it's clean.

German | English


Wie man ein benutzerdefiniertes I/O-Gerät schreibt

Dies ist eine Portierung des Artikels Qt Quarterly 12 about writing a custom QIODevice

Benutzung:

Der folgende Code-Schnipsel zeigt, wie man das benutzerdefinierte I/O-Gerät benutzen würde, um Daten zu verschlüsseln und das Ergebnis in einer Datei zu speichern:

 QFile file("output.dat");
 CryptDevice cryptDevice(&file)
 QTextStream out(&cryptDevice);
 cryptDevice.open(QIODevice::WriteOnly);
 out << "Hello World";

Zur möglichen Verwendung siehe auch unseren Beispiel-Code in git qtdevnet-wiki-mvc/qtdevnet-custom-iodevice .


Verschlüsselung

 QByteArray dataArray;

QBuffer bufferUsedLikeAFile(&dataArray);
 CryptDevice deviceFilter(&bufferUsedLikeAFile);
 deviceFilter.open(QIODevice::WriteOnly);
 QTextStream stream(&deviceFilter);
 QString szText = rawText->toPlainText();
 stream << szText;


Entschlüsselung

 QBuffer bufferUsedLikeAFile(&dataArray);
 CryptDevice deviceFilter(&bufferUsedLikeAFile);
 deviceFilter.open(QIODevice::ReadOnly);
 QTextStream stream(&deviceFilter);
 QString szText = stream.readAll();
 decryptedText->setPlainText(szText);

Das Beispiel-Bild aus dem Testprogramm:

Test app

Das benutzerdefinierte I/O-Gerät

Das Schreiben eines benutzerdefinierten I/O-Gerätes in Qt 4 umfasst das Erstellen einer von QIODevice abgeleiteten Klasse und das Reimplementieren einiger virtueller Funktionen.

Im Vergleich zu Qt 3 gibt dabei einen großen Unterschied: Man muss nur noch 2 Funktionen neu schreiben:

  • qint64 QIODevice::readData ( char * data, qint64 maxSize )
  • qint64 QIODevice::writeData ( const char * data, qint64 maxSize )

Unsere CryptDevice-Klasse wird ein sequenzielles I/O-Gerät. Ob es synchron oder asynchron arbeitet, hängt vom darunter liegenden QIODevice ab.

Quelltext

Die Klassendefinition sieht folgendermaßen aus:

class CryptDevice : public QIODevice
{
 Q_OBJECT
public:
 CryptDevice(QIODevice* deviceToUse, QObject* parent = 0);
 bool open(OpenMode mode);
 void close();
 bool isSequential() const;
protected:
 qint64 readData(char* data, qint64 maxSize);
 qint64 writeData(const char* data, qint64 maxSize);
private:
 QIODevice* underlyingDevice;
 Q_DISABLE_COPY(CryptDevice)
};

Die Definition des Constructors ist ganz einfach:

CryptDevice::CryptDevice(QIODevice* deviceToUse, QObject* parent) :
 QIODevice(parent),
 underlyingDevice(deviceToUse)
{
}

Weil wir ein sequenzielles Gerät haben wollen, reimplementieren wir isSequential:

bool CryptDevice::isSequential() const
{
 return true;
}

in

open()

öffnen wir das darunter liegende Gerät, falls es nicht schon geöffnet ist, und setzetn den Gerätezustand auf mode.

bool CryptDevice::open(OpenMode mode)
{
 bool underlyingOk;
 if (underlyingDevice->isOpen())
 underlyingOk = (underlyingDevice->openMode() != mode);
 else
 underlyingOk = underlyingDevice->open(mode);

if (underlyingOk)
 {
 setOpenMode(mode);
 return true;
 }
 return false;
}

Das Schließen ist trivial.

void CryptDevice::close()
{
 underlyingDevice->close();
 setOpenMode(NotOpen);
}

Um einen Block zu lesen, rufen wir von dem darunter liegenden Gerät

read()

auf. Am Ende verknüpfen wir alle gelesenen Bytes XOR mit der magischen Konstante 0x5E.

qint64 CryptDevice::readData(char* data, qint64 maxSize)
{
 qint64 deviceRead = underlyingDevice->read(data, maxSize);
 if (deviceRead == 1)
 return -1;
 for (qint64 i = 0; i < deviceRead; +''i)
 data[i] = data[i] ^ 0x5E;

 return deviceRead;
}

Um einen Block zu schreiben, erzeugen wir einen temporären Puffer mit unseren ge-XOR-ten Daten. Eine effizientere Implementierung würde einen 4096-Byte-Puffer auf dem Stack nutzen und

write()

mehrfach aufrufen, wenn die Größe der Daten die des Puffers übersteigt.

qint64 CryptDevice::writeData(const char* data, qint64 maxSize)
{
 QByteArray buffer((int)maxSize, 0);
 for (int i = 0; i < (int)maxSize;''+i)
 buffer[i] = data[i] ^ 0x5E;
 return underlyingDevice->write(buffer.data(), maxSize);
}