Most probably what I am asking for already has been
answered somewhere, still I was not able to find:-(
I want to encapsulate a class ( a primitive type for
the beginning ) to behave like a lvalue, but instead
of living in process memory being forwarded to some
remote store.
I believe an lvalue needs to be able to be convertible
to its wrapped type on reading, and providing an
assign function (operator =) for writing.
The following snippet illustrates the idea:
#include <iostream>
#include <map>
#include <string>
// a model of the store on the remote end
std::map<std::string, intstore;
// the call to the remote store sets a value
void set(std::string key, int val)
{
store[key] = val;
}
// this call to the remote store reads a value
int get(std::string key)
{
return store[key];
}
// the template wraps a native type
template<class T>
class remote_lval
{
public:
remote_lval(std::string key)
: key_(key)
{}
operator T()
{
return get(key_);
}
T operator = (T val)
{
set(key_, val);
return val;
}
private:
const std::string key_;
};
int main
(
int argc
, char* argv[]
)
{
remote_lval<intfoo("foo");
int bar;
int baz;
remote_lval<intfoobar("foobar");
remote_lval<int>& hmm(foobar);
foobar = baz = foo = bar = 42;
std::cout << foobar << ", " << baz << ", " << foo << ", " << bar <<
", " << hmm << std::endl;
foobar = foo + baz;
std::cout << foobar << ", " << baz << ", " << foo << ", " << bar <<
", " << hmm << std::endl;
return 0;
}
Altough the above code apparently works, I am not sure if I am
overseeing something important. I intend to extend the idea to
make the key_ a pos_type into a stream and be able to treat file
space like a memory space. I know that there will be issues of
caching and concurrency, but for the beginning I want to get the
lval wrapper right.
If anyone thinks what I am trying to do is a bad idea, I would be very
glad to learn the reasoning "why" it is a bad idea, before going
any further.
Thank you for your kind attention.
Roland aka. speedsnail
