---

tRelation.h

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/* POLiTe - Persistent Object Library Test                                     */
/*                                        Ph.D. Thesis by Mgr. Michal Kopecky */
/*                                                                            */
/* Charles University Prague                                                  */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* File name: ...                                                             */
/* Module: ......                                                             */
/*                                                                            */
/******************************************************************************/

#ifndef __T_RELATION_H__
#define __T_RELATION_H__

template<class L, class R> class OneToOneRelation;
template<class L, class R> class OneToManyRelation;
template<class L, class R> class ManyToOneRelation;
template<class L, class R> class ManyToManyRelation;
template<class L, class R> class ChainedRelation;

// Parent Header(s)
#include <cResultBase.h>

// Other POLiTe Header(s)
#include <tRef.h>

template<class L, class R> class OneToOneRelation : public OneToOneRelationBase
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend class ChainedRelation<L,R>;

public:
        OneToOneRelation(
                const char *a_table_name,
                class Connection *a_database_connection,
                const char *a_left_column_name = NULL,
                const char *a_right_column_name = NULL
                )
        : OneToOneRelationBase(
                L::ClassName(),
                R::ClassName(),
                a_table_name,
                a_database_connection,
                a_left_column_name,
                a_right_column_name
                )
        {};

        Result<L> *LGetAll(
                const class RefBase &right,
                const class QueRefProto &query = EQUERY
                )
        {
                return _LGetAll(new Result<L>,right,query);
        };

        Result<R> *RGetAll(
                const class RefBase &left,
                const class QueRefProto &query = EQUERY
                )
        {
                return _LGetAll(new Result<L>,left,query);
        };

        Result<L> *LGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return _LGetAll(new Result<L>,qL,qR);
        };

        Result<R> *RGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return _LGetAll(new Result<L>,qL,qR);
        };

        OneToOneRelation<R,L> operator -() const
        {
                return OneToOneRelation<R,L>(
                        _tableName,
                        _databaseConnection,
                        _rightColumnName,
                        _leftColumnName
                        );
        };

        OneToOneRelation<L,R> &operator =(const OneToOneRelation<L,R> &X)
        {
                if (this != &X)
                {
                        _leftClassName=X._leftClassName;
                        _rightClassName=X._rightClassName;
                        StrCpy(_tableName,X._tableName);
                        _databaseConnection,X._databaseConnection;
                        StrCpy(_leftColumnName,X._leftColumnName);
                        StrCpy(_rightColumnName,X._rightColumnName);
                };
                return *this;
        };

protected:
        ResultBase *_LGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the left side fulfilling query qL connected to object
                //on the right fulfilling query qR
        {
                return ChainedRelation<L,R>(*this)._LGetAll(rb,qL,qR);
        };

        ResultBase *_RGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the right side fulfilling query qR connected to object
                //on the left fulfilling query qL
        {
                return ChainedRelation<L,R>(*this)._RGetAll(rb,qL,qR);
        };
};

template<class L, class R> class OneToManyRelation : public OneToManyRelationBase
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend class ChainedRelation<L,R>;

public:
        OneToManyRelation(
                const char *a_table_name,
                class Connection *a_database_connection,
                const char *a_left_column_name = NULL,
                const char *a_right_column_name = NULL
                )
        : OneToManyRelationBase(
                L::ClassName(),
                R::ClassName(),
                a_table_name,
                a_database_connection,
                a_left_column_name,
                a_right_column_name
                )
        {};

        Result<L> *LGetAll(
                const class RefBase &right,
                const class QueRefProto &query = EQUERY
                )
        {
                return _LGetAll(new Result<L>,right,query);
        };

        Result<R> *RGetAll(
                const class RefBase &left,
                const class QueRefProto &query = EQUERY
                )
        {
                return _LGetAll(new Result<L>,left,query);
        };

        Result<L> *LGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return _LGetAll(new Result<L>,qL,qR);
        };

        Result<R> *RGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return _LGetAll(new Result<L>,qL,qR);
        };

        ManyToOneRelation<R,L> operator -() const
        {
                return ManyToOneRelation<R,L>(
                        _tableName,
                        _databaseConnection,
                        _rightColumnName,
                        _leftColumnName
                        );
        };

        OneToManyRelation<L,R> &operator =(const OneToManyRelation<L,R> &X)
        {
                if (this != &X)
                {
                        _leftClassName=X._leftClassName;
                        _rightClassName=X._rightClassName;
                        StrCpy(_tableName,X._tableName);
                        _databaseConnection,X._databaseConnection;
                        StrCpy(_leftColumnName,X._leftColumnName);
                        StrCpy(_rightColumnName,X._rightColumnName);
                };
                return *this;
        };

protected:
        ResultBase *_LGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the left side fulfilling query qL connected to object
                //on the right fulfilling query qR
        {
                return ChainedRelation<L,R>(*this)._LGetAll(rb,qL,qR);
        };

        ResultBase *_RGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the right side fulfilling query qR connected to object
                //on the left fulfilling query qL
        {
                return ChainedRelation<L,R>(*this)._RGetAll(rb,qL,qR);
        };
};

template<class L, class R> class ManyToOneRelation : public ManyToOneRelationBase
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend class ChainedRelation<L,R>;

public:
        ManyToOneRelation(
                const char *a_table_name,
                class Connection *a_database_connection,
                const char *a_left_column_name = NULL,
                const char *a_right_column_name = NULL
                )
        : ManyToOneRelationBase(
                L::ClassName(),
                R::ClassName(),
                a_table_name,
                a_database_connection,
                a_left_column_name,
                a_right_column_name
                )
        {};

        Result<L> *LGetAll(
                const class RefBase &right,
                const class QueRefProto &query = EQUERY
                )
        {
                return (Result<L> *)_LGetAll(new Result<L>,right,query);
        };

        Result<R> *RGetAll(
                const class RefBase &left,
                const class QueRefProto &query = EQUERY
                )
        {
                return (Result<R> *)_RGetAll(new Result<L>,left,query);
        };

        Result<L> *LGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return (Result<L> *)_LGetAll(new Result<L>,qL,qR);
        };

        Result<R> *RGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return (Result<R> *)_RGetAll(new Result<L>,qL,qR);
        };

        OneToManyRelation<R,L> operator -() const
        {
                return OneToManyRelation<R,L>(
                        _tableName,
                        _databaseConnection,
                        _rightColumnName,
                        _leftColumnName
                        );
        };

        ManyToOneRelation<L,R> &operator =(const ManyToOneRelation<L,R> &X)
        {
                if (this != &X)
                {
                        _leftClassName=X._leftClassName;
                        _rightClassName=X._rightClassName;
                        StrCpy(_tableName,X._tableName);
                        _databaseConnection,X._databaseConnection;
                        StrCpy(_leftColumnName,X._leftColumnName);
                        StrCpy(_rightColumnName,X._rightColumnName);
                };
                return *this;
        };

protected:
        ResultBase *_LGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the left side fulfilling query qL connected to object
                //on the right fulfilling query qR
        {
                return ChainedRelation<L,R>(*this)._LGetAll(rb,qL,qR);
        };

        ResultBase *_RGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the right side fulfilling query qR connected to object
                //on the left fulfilling query qL
        {
                return ChainedRelation<L,R>(*this)._RGetAll(rb,qL,qR);
        };
};

template<class L, class R> class ManyToManyRelation : public ManyToManyRelationBase
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend class ChainedRelation<L,R>;

public:
        ManyToManyRelation(
                const char *a_table_name,
                class Connection *a_database_connection,
                const char *a_left_column_name = NULL,
                const char *a_right_column_name = NULL
                )
        : ManyToManyRelationBase(
                L::ClassName(),
                R::ClassName(),
                a_table_name,
                a_database_connection,
                a_left_column_name,
                a_right_column_name
                )
        {};

        Result<L> *LGetAll(
                const class RefBase &right,
                const class QueRefProto &query = EQUERY
                )
        {
                return (Result<L> *)_LGetAll(new Result<L>,right,query);
        };

        Result<R> *RGetAll(
                const class RefBase &left,
                const class QueRefProto &query = EQUERY
                )
        {
                return (Result<R> *)_RGetAll(new Result<L>,left,query);
        };

        Result<L> *LGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return (Result<L> *)_LGetAll(new Result<L>,qL,qR);
        };

        Result<R> *RGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return (Result<R> *)_RGetAll(new Result<L>,qL,qR);
        };

        ManyToManyRelation<R,L> operator -() const
        {
                return ManyToManyRelation<R,L>(
                        _tableName,
                        _databaseConnection,
                        _rightColumnName,
                        _leftColumnName
                        );
        };

        ManyToManyRelation<L,R> &operator =(const ManyToManyRelation<L,R> &X)
        {
                if (this != &X)
                {
                        _leftClassName=X._leftClassName;
                        _rightClassName=X._rightClassName;
                        StrCpy(_tableName,X._tableName);
                        _databaseConnection,X._databaseConnection;
                        StrCpy(_leftColumnName,X._leftColumnName);
                        StrCpy(_rightColumnName,X._rightColumnName);
                };
                return *this;
        };

protected:
        ResultBase *_LGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the left side fulfilling query qL connected to object
                //on the right fulfilling query qR
        {
                return ChainedRelation<L,R>(*this)._LGetAll(rb,qL,qR);
        };

        ResultBase *_RGetAll(
                ResultBase * rb,
                const class QueRefProto &qL,
                const class QueRefProto &qR
        )
                //Gets all objects on the right side fulfilling query qR connected to object
                //on the left fulfilling query qL
        {
                return ChainedRelation<L,R>(*this)._RGetAll(rb,qL,qR);
        };
};

template<class L, class R> class ChainedRelation : public ChainedRelationBase
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend ChainedRelation<L,R> operator *(const QueRefProto &Q, const OneToOneRelation<L,R> &X);
friend ChainedRelation<L,R> operator *(const OneToOneRelation<L,R> &X, const QueRefProto &Q);
friend ChainedRelation<L,R> operator *(const QueRefProto &Q, const OneToManyRelation<L,R> &X);
friend ChainedRelation<L,R> operator *(const OneToManyRelation<L,R> &X, const QueRefProto &Q);
friend ChainedRelation<L,R> operator *(const QueRefProto &Q, const ManyToOneRelation<L,R> &X);
friend ChainedRelation<L,R> operator *(const ManyToOneRelation<L,R> &X, const QueRefProto &Q);
friend ChainedRelation<L,R> operator *(const QueRefProto &Q, const ManyToManyRelation<L,R> &X);
friend ChainedRelation<L,R> operator *(const ManyToManyRelation<L,R> &X, const QueRefProto &Q);
friend ChainedRelation<L,R> operator *(const QueRefProto &Q, const ChainedRelation<L,R> &X);
friend ChainedRelation<L,R> operator *(const ChainedRelation<L,R> &X, const QueRefProto &Q);

friend class OneToOneRelation<L,R>;
friend class OneToManyRelation<L,R>;
friend class ManyToOneRelation<L,R>;
friend class ManyToManyRelation<L,R>;
//friend class ChainedRelation<L,R>;

public:
        ChainedRelation(
                const char *a_table_name,
                class Connection *a_database_connection,
                const char *a_left_column_name = NULL,
                const char *a_right_column_name = NULL,
                const char *a_inner_columns = NULL,
                const int a_relnum = 1,
                const int a_qnum = 0,
                const class Query &a_left_query = EQUERY,
                const class Query &a_right_query = EQUERY
                )
        : ChainedRelationBase(
                L::ClassName(),
                R::ClassName(),
                a_table_name,
                a_database_connection,
                a_left_column_name,
                a_right_column_name,
                a_inner_columns,
                a_relnum,
                a_qnum,
                a_left_query,
                a_right_query
                )
        {};

        ChainedRelation(const OneToOneRelation<L,R> &X) : ChainedRelationBase(NULL,NULL,NULL,NULL,NULL,NULL,NULL,0,0,EQUERY,EQUERY)
        {_Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};
        ChainedRelation<L,R> &operator =(const OneToOneRelation<L,R> &X)
        {if (this!=&X) _Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};

        ChainedRelation(const OneToManyRelation<L,R> &X) : ChainedRelationBase(NULL,NULL,NULL,NULL,NULL,NULL,NULL,0,0,EQUERY,EQUERY)
        {_Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};
        ChainedRelation<L,R> &operator =(const OneToManyRelation<L,R> &X)
        {if (this!=&X) _Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};

        ChainedRelation(const ManyToOneRelation<L,R> &X) : ChainedRelationBase(NULL,NULL,NULL,NULL,NULL,NULL,NULL,0,0,EQUERY,EQUERY)
        {_Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};
        ChainedRelation<L,R> &operator =(const ManyToOneRelation<L,R> &X)
        {if (this!=&X) _Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};

        ChainedRelation(const ManyToManyRelation<L,R> &X) : ChainedRelationBase(NULL,NULL,NULL,NULL,NULL,NULL,NULL,0,0,EQUERY,EQUERY)
        {_Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};
        ChainedRelation<L,R> &operator =(const ManyToManyRelation<L,R> &X)
        {if (this!=&X) _Init(X._leftClassName,X._rightClassName,X._TableName(),X._databaseConnection,X._leftColumnName,X._rightColumnName,NULL,1,0,EQUERY,EQUERY);};

        ChainedRelation(const ChainedRelation<L,R> &X) 
        : ChainedRelationBase(
                X._leftClassName,X._rightClassName,X._tableName,X._databaseConnection,X._leftColumnName,X._rightColumnName,X._inner_columns,X._relnum,X._qnum,X._left_query,X._right_query
                )
        {};

        ChainedRelation(Proto<L> &X, Proto<R> &Y) 
        : ChainedRelationBase(
                X,Y
                )
        {};

        ChainedRelation(const ChainedRelationBase &X, const ChainedRelationBase &Y) 
        : ChainedRelationBase(
                X,Y
                )
        {
        };

        Result<L> *LGetAll(
                const class RefBase &right,
                const class QueRefProto &query = EQUERY
                )
        {
                return (Result<L> *)_LGetAll(new Result<L>,right,query);
        };

        Result<R> *RGetAll(
                const class RefBase &left,
                const class QueRefProto &query = EQUERY
                )
        {
                return (Result<R> *)_RGetAll(new Result<L>,left,query);
        };

        Result<L> *LGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return (Result<L> *)_LGetAll(new Result<L>,qL,qR);
        };

        Result<R> *RGetAll(
                const class QueRefProto &qL,
                const class QueRefProto &qR
                )
        {
                return (Result<R> *)_RGetAll(new Result<L>,qL,qR);
        };

        ChainedRelation<R,L> operator -() const
        {
                return ChainedRelation<R,L>(
                        _tableName,
                        _databaseConnection,
                        _rightColumnName,
                        _leftColumnName
                        );
        };

        ChainedRelation<L,R> &operator =(const ChainedRelation<L,R> &X)
        {
                if (this != &X)
                {
                        _leftClassName=X._leftClassName;
                        _rightClassName=X._rightClassName;
                        StrCpy(_tableName,X._tableName);
                        _databaseConnection,X._databaseConnection;
                        StrCpy(_leftColumnName,X._leftColumnName);
                        StrCpy(_rightColumnName,X._rightColumnName);
                        StrCpy(_inner_columns,X._inner_columns);
                        _relnum=X._relnum;
                        _qnum=X._qnum;
                        _left_query=X._left_query;
                        _right_query=X._right_query;
                };
                return *this;
        };
};

//Left and Right operators
template<class L,class R> Result<L> *Left(OneToOneRelation<L,R> &X,const class QueRefProto &qR = EQUERY) {return X.LGetAll(EQUERY,qR);};
template<class L,class R> Result<L> *Left(OneToManyRelation<L,R> &X,const class QueRefProto &qR = EQUERY) {return X.LGetAll(EQUERY,qR);};
template<class L,class R> Result<L> *Left(ManyToOneRelation<L,R> &X,const class QueRefProto &qR = EQUERY) {return X.LGetAll(EQUERY,qR);};
template<class L,class R> Result<L> *Left(ManyToManyRelation<L,R> &X,const class QueRefProto &qR = EQUERY) {return X.LGetAll(EQUERY,qR);};
template<class L,class R> Result<L> *Left(ChainedRelation<L,R> &X,const class QueRefProto &qR = EQUERY) {return X.LGetAll(EQUERY,qR);};
template<class L,class R> Result<R> *Right(OneToOneRelation<L,R> &X,const class QueRefProto &qL = EQUERY) {return X.RGetAll(qL,EQUERY);};
template<class L,class R> Result<R> *Right(OneToManyRelation<L,R> &X,const class QueRefProto &qL = EQUERY) {return X.RGetAll(qL,EQUERY);};
template<class L,class R> Result<R> *Right(ManyToOneRelation<L,R> &X,const class QueRefProto &qL = EQUERY) {return X.RGetAll(qL,EQUERY);};
template<class L,class R> Result<R> *Right(ManyToManyRelation<L,R> &X,const class QueRefProto &qL = EQUERY) {return X.RGetAll(qL,EQUERY);};
template<class L,class R> Result<R> *Right(ChainedRelation<L,R> &X,const class QueRefProto &qL = EQUERY) {return X.RGetAll(qL,EQUERY);};

// Relation*QueRefProto and vice versa
// i.e. right and left restrictions
template<class L, class R> ChainedRelation<L,R> operator *(const QueRefProto &Q, const OneToOneRelation<L,R> &X) {ChainedRelation<L,R> S = X; S._left_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const OneToOneRelation<L,R> &X, const QueRefProto &Q) {ChainedRelation<L,R> S = X; S._right_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const QueRefProto &Q, const OneToManyRelation<L,R> &X) {ChainedRelation<L,R> S = X; S._left_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const OneToManyRelation<L,R> &X, const QueRefProto &Q) {ChainedRelation<L,R> S = X; S._right_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const QueRefProto &Q, const ManyToOneRelation<L,R> &X) {ChainedRelation<L,R> S = X; S._left_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const ManyToOneRelation<L,R> &X, const QueRefProto &Q) {ChainedRelation<L,R> S = X; S._right_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const QueRefProto &Q, const ManyToManyRelation<L,R> &X) {ChainedRelation<L,R> S = X; S._left_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const ManyToManyRelation<L,R> &X, const QueRefProto &Q) {ChainedRelation<L,R> S = X; S._right_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const QueRefProto &Q, const ChainedRelation<L,R> &X) {ChainedRelation<L,R> S = X; S._left_query.And(Q); return S;};
template<class L, class R> ChainedRelation<L,R> operator *(const ChainedRelation<L,R> &X, const QueRefProto &Q) {ChainedRelation<L,R> S = X; S._right_query.And(Q); return S;};

// Join of two prototypes
template<class L, class R> ChainedRelation<L,R> operator *(Proto<L> &X, Proto<R> &Y) {return ChainedRelation<L,R>(X,Y);};

// Chaining operators
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ChainedRelation<L,M> &X, const ChainedRelation<N,R> &Y) {return ChainedRelation<L,R>(X,Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ChainedRelation<L,M> &X, const ManyToManyRelation<N,R> &Y) {return X*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ChainedRelation<L,M> &X, const ManyToOneRelation<N,R> &Y) {return X*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ChainedRelation<L,M> &X, const OneToManyRelation<N,R> &Y) {return X*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ChainedRelation<L,M> &X, const OneToOneRelation<N,R> &Y) {return X*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToManyRelation<L,M> &X, const ChainedRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToManyRelation<L,M> &X, const ManyToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToManyRelation<L,M> &X, const ManyToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToManyRelation<L,M> &X, const OneToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToManyRelation<L,M> &X, const OneToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToOneRelation<L,M> &X, const ChainedRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToOneRelation<L,M> &X, const ManyToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToOneRelation<L,M> &X, const ManyToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToOneRelation<L,M> &X, const OneToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const ManyToOneRelation<L,M> &X, const OneToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToManyRelation<L,M> &X, const ChainedRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToManyRelation<L,M> &X, const ManyToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToManyRelation<L,M> &X, const ManyToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToManyRelation<L,M> &X, const OneToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToManyRelation<L,M> &X, const OneToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToOneRelation<L,M> &X, const ChainedRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToOneRelation<L,M> &X, const ManyToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToOneRelation<L,M> &X, const ManyToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToOneRelation<L,M> &X, const OneToManyRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};
template<class L, class M, class N, class R> ChainedRelation<L,R> operator *(const OneToOneRelation<L,M> &X, const OneToOneRelation<N,R> &Y) {return ChainedRelation<L,M>(X)*ChainedRelation<N,R>(Y);};

#endif //__T_RELATION_H__

---