Re: H2 hide the type of data a system must use?
nguillot <nicolas.guillot@gmail.com>, on 13/08/2010 15:27:48, wrote:
Hello
The subject of this post is not really clear.
Let me try to explain:
I often have this kind of problem:
In a system, a block process some data.
The data are sent by a Sender.
They are asynchronously process by a Processor.
The result of the treatments are sent to a Receiver.
Sender
|
| data
|
\/
Processor ------ results -----> Receiver
The receiver receive results as soon as they are available, and let
say it must save them, and save some informations about the data used
to produce the result, an id for instance.
<snip old implementation and other solutions>
Thank you if you read until here, and thanks in advance for answer (I
hope).
Up to here I was thinking: "templates, templates templates", and finally
you pointed them out.
Finally, again one word: I imagined a way to do that, but it has his
problems:
we could enforce to link a data to a tag by declaring a processor
entry point like that:
Processor::ProcessData(CTaggedObject<T, Data> data);
where CTaggedObject is
template<typename Tag, typenam Obj> CTaggedObject
{
Tag tag_;
Obj Obj_;
// constrcutor with tag and object and default values...
const Tag& GetTag() const;
const Obj& GetObject() const;
// and the non const version...
}
So the processor would deal with Data to process data, and it copies
the tag without knowing the Tag type.
The result would be provided as a CTaggedObject<SameTagTypeAsData,
Result>.
What is good:
- The processor doesn't know anything about Tag type (with template
functions it should be possible)
Indeed it is.
What is not good:
- if the processor is in a separate compilation unit (library) the
compiler doesn't know the Tag type used by other compilation units,
so...
Yes, go make a search for "export templates"... there should be at least
one compiler implementing them.
If you are stuck with another compiler, you need to put your templates
in a header library, yes...
- if the processor is seen by its client (the Sender here) through
a functionnal interface, we cannot have virtual template functions!
nor template virtual function, nor function virtual template nor
function template virtual ;-)
I don't see the need for anything virtual, neither I see any difficulty
about passing polymorphic pointers or references... anyway.
All of this stuff made me fiddle with some code, and here below I'll
paste it.
As you will see, the Sender / Processor / Receiver are implemented with
templates and know nothing about the types they will be instantiated
with, they only need those classes to have an "id" member and a "value"
member.
Furthermore, they accept also assigning an id of one type to an id of
another type (assuming a valid conversion operation exists between these
two types) - the DataTemplate is in fact just a wrapper that joins two
unrelated data types to make a single packet with the interface expected
by the triad above - not much different from your CTaggedObject.
Processor is aware of the exact types it's handling via a couple of
typedefs declared into Sender and Receiver.
See if you can find something useful in it:
//-------
#include <iostream>
using namespace std;
// Sender, Processor and Receiver templates
template<class DataType> struct Sender {
typedef DataType data_type;
DataType send() {
DataType data;
cout << "sending id == [" << data.id << "]" << endl;
cout << "sending value == [" << data.value << "]" << endl;
return data;
}
};
template<class ResultType> struct Receiver {
typedef ResultType result_type;
void receive(ResultType result) {
cout << "received id == [" << result.id << "]" << endl;
cout << "received value == [" << result.value << "]" << endl;
}
};
struct Processor {
template<class SenderType, class ReceiverType>
void process(SenderType sender, ReceiverType receiver) {
typename SenderType::data_type data = sender.send();
typename ReceiverType::result_type result;
result.value = data.value;
result.value /= 3;
result.id = data.id;
cout << "transforming id from [" << data.id << "] ";
cout << "to [" << result.id << "] " << endl;
cout << "transforming value from [" << data.value << "] ";
cout << "to [" << result.value << "] " << endl;
receiver.receive(result);
}
};
// test case
template<class Value, class Id> struct DataTemplate {
Value value;
Id id;
DataTemplate() : value(100), id(42) {}
};
int main() {
Sender< DataTemplate<long, unsigned char> > sender;
Receiver< DataTemplate<double, int> > receiver;
Processor processor;
processor.process(sender, receiver);
return 0;
}
/*
output:
sending id == [*]
sending value == [100]
transforming id from [*] to [42]
transforming value from [100] to [33.3333]
received id == [42]
received value == [33.3333]
*/
//-------
--
FSC - http://userscripts.org/scripts/show/59948
http://fscode.altervista.org - http://sardinias.com