Implementing One-to-Many Relationships
I wrote a set of classes that allows to implement One-to-Many
relationships in C++ in a quite simple and efficient way. I thought
that the members of this group would probably have many comments to make
in order to improve the code.
In the following, the Owner class is the one that owns a set of
instances from another User class. The User instances point to their
Owner, and the Owner has the list of all the Users. The default
behavior when an Owner is deleted is that all its Users are deleted.
When a User is deleted, the Owner is notified.
Thanks to the CRTP[1] idiom, all of this can be implemented solely with
Owner and User inheriting from two template classes, and User calling a
constructor of its parent class, without using more memory than required
(a pointer to the Owner in the User, a container for all the Users in
the Owner).
Here is an example of usage (see [5] for the full example code)
=================================
class Named {
public:
Named(const std::string& name)
: _name(name) {}
const std::string& name() const {
return _name;
}
~Named() {
std::cout << "Object '" << _name << "' destroyed" << std::endl;
}
private:
std::string _name;
};
class User
: public RelationUser<Owner, User>
, public Named {
public:
User(Owner* owner, const std::string& name)
: RelationUser<Owner,User>(owner)
, Named(name)
{}
};
class Owner
: public RelationOwner<RelationUser<Owner, User> > {
public:
void show();
};
void Owner::show() {
std::cout << "Users of Owner: ";
for (Owner::iterator it (begin()); it != end(); ++it) {
std::cout << (*it)->name() << " ";
}
std::cout << std::endl;
}
void test() {
Owner* owner (new Owner());
User* user1 (new User(owner, "1"));
User* user2 (new User(owner, "2"));
User* user3 (new User(owner, "3"));
owner->show();
delete user2;
owner->show();
delete owner; // All users deleted
}
=================================
This gives the following output:
Users of Owner: 1 2 3
User '2' destroyed
Users of Owner: 1 3
User '1' destroyed
User '3' destroyed
A paper[3], first published in C Vu, a journal of ACCU[2], is available.
It describes the complete implementation, that allows multiple
relations between the same classes, changing the behavior of the
template classes, etc.
The code itself is reproduced at the bottom of this message, and is
available in [4]. An example of usage is in [5].
All comments welcome.
[1] http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
[2] http://accu.org/index.php
[3] http://xavier.nodet.free.fr/Relations/relations.pdf
[4] http://xavier.nodet.free.fr/Relations/relations.h
[5] http://xavier.nodet.free.fr/Relations/example.cpp
== File: relations.h ==
#include <algorithm>
#include <iostream>
#include <set>
#include <vector>
namespace relations {
// The default Policy class used to determine what
// happens to the owned objects
// when the owner is destroyed.
struct DefaultEnder {
template <class L>
void operator()(L* l) { delete l; }
};
// A Policy class to be used to determine what
// happens to the owned objects when the owner is
// destroyed. This one does nothing. Note that
// the back-pointer is set to 0 by the owner prior
// to the call to operator()
struct DoNothing {
template <class L>
void operator()(L*) {}
};
// A Policy class to specify the container to use
// in the owner: std::set
template <class L>
struct SetValuesPolicy {
typedef std::set<L*> Container;
static void insert(Container& c, L* l) {
c.insert(l);
}
static void remove(Container& c, L* l) {
c.erase(l);
}
static bool has(Container& c, L* l) {
return c.find(l) != c.end();
}
};
// Base class for Policy classes to specify
// std::vector to use in the owner.
template <class L>
struct VectorValuesPolicyBase {
typedef std::vector<L*> Container;
static void remove(Container& c, L* l) {
c.erase(std::remove(c.begin(), c.end(), l),
c.end());
}
static bool has(Container& c, L* l) {
find(c.begin(), c.end(), l) != c.end();
}
// elem and nbElem should probably only be
// provided for containers that implement those
// operations in O(1)
static L* elem(const Container& c, size_t i) {
return c[i];
}
static size_t nbElem(const Container& c) {
return c.size();
}
};
// A Policy class to specify the container to use
// in the owner: an std::vector where insertion is
// checked to avoid inserting again the same object
template <class L>
struct VectorValuesPolicy
: public VectorValuesPolicyBase<L>
{
static void insert(Container& c, L* l) {
Container::iterator it =
find(c.begin(), c.end(), l);
if (it == c.end()) { c.push_back(l); }
}
};
// A Policy class to specify the container to use
// in the owner: an std::vector with no checking
// on insertion
template <class L>
struct VectorNoCheckValuesPolicy
: public VectorValuesPolicyBase<L>
{
static void insert(Container& c, L* l) {
c.push_back(l);
}
};
// Inherit from RelationOwner to give to your
// class the possibility to own objects in a
// one-to-many relation.
template <class RelUser>
class RelationOwner {
friend RelUser;
public:
typedef typename
RelUser::_Owner _Owner;
typedef typename
RelUser::_User _User;
typedef typename
RelUser::_Policy _Policy;
typedef typename
RelUser::_UserEnder _UserEnder;
typedef typename
_Policy::Container _Container;
typedef typename
_Container::const_iterator iterator;
// Destructor of owner notifies all the owned
// objects and then calls the user-provided
// Policy class.
~RelationOwner() {
_Container temp;
swap(_users, temp);
for (iterator it (temp.begin());
it != temp.end(); ++it) {
static_cast<RelUser*>(*it)->reset();
_UserEnder()(*it);
}
}
// All the remaining methods will typically be
// wrapped into methods of the derived Owner
// class to hide the implementation of the
// relation
bool has(_User* owned) const {
return _Policy::has(_users,owned);
}
iterator begin() const {
return _users.begin();
}
iterator end() const {
return _users.end();
}
_User* user(int i) const {
return _Policy::elem(_users,i);
}
size_t nbUsers() const {
return _Policy::nbElem(_users);
}
// Returns a vector of all the users
std::vector<_User*> users() const {
std::vector<_User*> result;
std::copy(_users.begin(), _users.end(),
std::back_inserter(result));
return result;
}
// Returns a vector of all the users
// that verify a predicate
template <typename Pred>
std::vector<_User*> users(Pred pred) const {
std::vector<_User*> result;
for (iterator it (_users.begin());
it != _users.end(); ++it) {
if (pred(*it)) {
result.push_back(*it);
}
}
return result;
}
// Do something to each user
template <typename Func>
void for_each_user(Func f) {
for (_Container::iterator it (_users.begin());
it != _users.end(); ++it) {
f(*it);
}
}
private: // Changes are made through the users
void attach(_User* owned) {
_Policy::insert(_users,owned);
}
void detach(_User* owned) {
_Policy::remove(_users,owned);
}
private:
_Container _users;
};
// Base class for the objects owned in the
// relation:
// - Owner and User inherit from RelationOwner
// and RelationUser.
// - The RelId marker type allows to distinguish
// relations that would otherwise have the same
// set of template parameters.
// - Policy allow to define the container used
// in RelationOwner
// - UserEnder defines what happens to the owned
// objects when the owner instance is destroyed
//
template <class Owner, class User,
class RelId = void,
class Policy = SetValuesPolicy<User>,
class UserEnder = DefaultEnder >
class RelationUser {
typedef Owner _Owner;
typedef User _User;
typedef Policy _Policy;
typedef UserEnder _UserEnder;
typedef RelId _RelationId;
typedef RelationUser<Owner,User,RelId,
Policy,UserEnder> _RelUser;
typedef RelationOwner<_RelUser> _RelOwner;
// Give access to the typedefs above
friend _RelOwner;
public:
explicit RelationUser(_Owner* owner)
: _owner(0)
{ reset(owner); }
~RelationUser() { detach(); }
_Owner* owner() const { return _owner; }
bool hasOwner() const { return _owner != 0; }
// Change owner
void reset(_Owner* newOwner=0) {
detach();
_owner = newOwner;
if (_owner) {
static_cast<_RelOwner*>(_owner)
->attach(user());
}
}
private:
_User* user() {
return static_cast<_User*>(this);
}
void detach() {
if (hasOwner()) {
static_cast<_RelOwner*>(_owner)
->detach(user());
}
}
private:
_Owner* _owner;
};
} // namespace
== End Of File: relations.h ==
--
Xavier Nodet
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]