stream verarbeiten

VirtualDreams

Hallo,

ich suche nach einer möglichkeit (nicht boost ) einen stream zu verarbeiten nach dem prinzip

Stream<VerarbeitungsAlgo> s;
cout << s << "irgendwelche daten";
//oder 
foo << s << bar

wobei cout und "irgendwelchen daten" durch eine beliebiges Objekt ersetzt werden können. zB fstream, char-array, string usw.
Außerdem kann sich die größe des Ausagbestreams verkleinern oder vergrößern.

Ich möchte also in s den Inhalt verändern.

Welchen Ansatz müsste ich dabei verfolgen bzw kleine Beispiel sources wären sehr hilfreich.

Simon2

? Warum sollte das ein "Stream" sein müssen ?
Für mich hat diese "Filterfunktion" nicht viel mit einem "Stream" gemeion ...
Einfach eine "AlgoKlasse" definieren und den mit operator<<() geeignet überladen ...

Andererseits finde ich den Vorteil ggü. der "klassischen Form" nicht wirklich überwältigend:

VerarbeitungsAlgo s; // oder einfach eine geeignete Funktion s
cout << s("irgendwelche daten");
//oder
foo << s(bar);

Man muss nur darauf achten, dass für das Ergebnis von s (sei es nun eine Funktion oder ein Funktor) ein geeigneter operator<<() definiert ist ... aber das ist auch schnell selbst gemacht.

Die Idee eines "generellen Algorithmus'" halte ich sowieso für nicht allzu hilfreich. Wie soll ein Algorithmus aussehen, der TCP-Connections, Autos und Kundenkontakte gleichartig verarbeiten kann ?

Gruß,

Simon2.

VirtualDreams

Der algo soll in etwa gleichwertige Dinge verarbeiten können und irgendwie in die stream Klassen integriert werden. Im konkretem geht es dabei um verschiedene Verschlüsslungsalgos, die als Parameter übergeben werden sollen. Machen tun sie ja alle das gleiche, nämlich verschlüsseln oder entschlüsseln.

Es geht mir hierbei primär um die Ansätze wie man mit meiner Methode lösen könnte.

Dravere

Achso, du meinst eine Verschlüsselungsengine. Wie wäre es mit sowas:

Encryptor<AlgoType> encryptor;
std::string toEncrypt("Hello");
std::string encrypted;

encryptor(toEncrypt.begin(), toEncrypt.end(), std::back_inserter(encrypted));

std::cout << encrypted << std::endl;

// Und die Klasse Encryptor irgendwie so:
template<typename AlgoTypeT>
class Encryptor
{
public:
  template<typename InIterT, typename OutIterT>
  void operator ()(InIterT first, InIterT last, OutIterT out)
  {
    AlgoTypeT algo;

    for(; first != last; ++first, ++out)
    { *out = algo.encrypt(*first); }
  }
};

Oder sowas ähnliches ...?

Grüssli

VirtualDreams

So in der Art sieht das schon gut aus. Perfekt wäre es jetzt noch wenn der Algo über die Blockgrößen selbst entscheiden könnte. Ich hab ja auch schon ein wenig selbst angefangen, komme aber damit nicht so wirklich weiter.

#pragma once
#include <iostream>
#include <string>
#include "tea.h"
#include "rc4.h"

namespace crypt
{
	template<class algo>
	class CipherBuffer: public algo
	{
		private:
			algo theAlgo;

		public:
			CipherBuffer(const algo &theAlgo)	{};
			~CipherBuffer()						{};
	};

	///instanz vom user
	template<class algo>
	class CipherStream: public CipherBuffer<algo>
	{
		public:
			CipherStream(const algo &theAlgo = algo());
			~CipherStream();

	};

	template<class algo>
	CipherStream<algo>::CipherStream(const algo &theAlgo): CipherBuffer<algo>(theAlgo)
	{

	}

	template<class algo>
	CipherStream<algo>::~CipherStream()
	{

	}
}

#pragma once
#include <iostream>
#include <string>

namespace crypt
{
	class RC4
	{
		private:

		public:
			RC4()	{};
			~RC4()	{};

			void operator<< (std::string &s)
			{
				std::cout << s << std::endl;
			};
	};
}

#include <iostream>
#include <string>

#include "cipher.h"

#include <stdio.h>

using namespace std;
using namespace crypt;

int main(int argc, char **argv)
{
	string s = "Test";
	CipherStream<RC4> rc4;

	rc4 << s;

	system("pause");
	return 0;
}