cchar_t* ColoredFruit::_IColoredFruit_name() {
   static char buf[80];
   sprintf( buf, "%s %s", self().IColored::color_get(), self().IFruit::kind() );
   return buf;
}

V>А вообще, спасибо за иллюстрацию применения mixin-ов. Это было очень любопытно

struct IObject {
   const char* _IObject_fullName_get() = 0;
}

struct MyApple :
    Apple<MyApple>,
    Colored<MyApple>,
    ColoredFruit<MyApple>,
    Part<IObject,MyApple>
{
    const char* _IObject_fullName_get() {
        static char buf[100];
        sprintf( buf,"%s %s Fruit", color_get(), kind() );
        return buf; // red apple fruit
    }
};

class LinuxWindow;
class Win32Window;
class DBView;

var dbvLnx as (LinuxWindow,DBView)
var dbvWin as (Win32Window,DBView)

// Тяжелый класс (не шаблонный)
class MyObject : public IFoo, public IXoo, public IZoo, public IMoo {
protected:
// этот класс требует для своей работы следующие интерфейсы:
    virtual IxFoo& _MyObject_IxFoo() = 0;
    virtual IxZoo& _MyObject_IxZoo() = 0;

public:

    // 500 функций опущено
};

// Легкая шаблонная обертка
template <class T>
struct TMyObject : Part<MyObject,T> {
// этот код гарантирует поддержку классом Т интерфейсов IxFoo, IxZoo
    IxFoo& _MyObject_IxFoo() { return self(); }
    IxZoo& _MyObject_IxFoo() { return self(); }
};

// Теперь можно собирать по кусочкам:
struct Test1 :
    TMyObject<Test>,
    TMyIxFooImpl<Test1>,
    TMyIxZooImpl<Test2>
{
    // ..............
};

struct Test2 :
    TMyObject<Test2>,
    TMy_Another_IxFoo_And_IxZoo_Impl_in_single_class<Test2>
{
    // ..............
};

// Кусок класса который пишет Иванов
class CIvanovFinalPart : public IIvanovPart {
protected:
    virtual ISidorovPart &_CIvanovPart_SidorovPart() = 0;
    virtual IPetrovPart &_CIvanovPart_SidorovPart() = 0;
};

// Реализация для тестирования
struct CIVanovTest :
    TIvanovFinalPart<CIVanovTest>,
    TSidorovDummyPart<CIVanovTest>,
    TPetrovDummyPart<CIVanovTest>
{
    // .......................
};

// окончательная реализация:
class CFinalUltimateClass :
    public TIvanovFinalPart<CFinalUltimateClass>,
    public TSidorovFinalPart<CFinalUltimateClass>,
    public TPetrovFinalPart<CFinalUltimateClass>
{
    // .. здесь могут быть решены мелкие проблеммы
};

struct MyApple ...

struct MyMango ...

struct MyOrange ...

struct MyHome ...

// ... и т.д.

K>class LinuxWindow;
K>class Win32Window;
K>class DBView;

K>var dbvLnx as (LinuxWindow,DBView)
K>var dbvWin as (Win32Window,DBView)
K>

class CFruit { // Фрукт
 var Kind as string;
 function name() as string {
   if Result = NULL { // Отдаёмся на откуп "наследникам"
     Result = Kind;
   }
 }
}

class CColored { // Нечто цветное
 var Color as string;
}

function (CFruit, CColored)::name() as string { // Доопределяем функцию CFruit::name()
  Result = Color + " " + Kind;
}

procedure TestColoredFruits(Other as CFruit) {  // Тестовая процедурка
 Var Fruit as CFruit,
     Colored as CColored,
     ColoredFruit as (CColored, CFruit);
 Fruit.Kind = "Mango";
 ColoredFruit.Kind = "Apple";
 ColoredFruit.Color = "Green";

 App.MsgBox(Fruit.name()); // "Mango"
 App.MsgBox(ColoredFruit.name()); // "Green Apple"
 App.MsgBox(Other.name()); // Зависит от того, что прислали.
     // Может выдать, например, "Plum" или "Yellow Banana"

 // А теперь нам хочется закричать страшным голосом, если Other зелёный
 ifcast Other as CColored { // такой специальный оператор
  if lower(Other.Color) = "green" { // здесь компилятор уже знает, что у Other есть Color
   App.MsgBox("Фууууу! Какая гадость! " + Other.name() + "!");
  }
 }
}

class CQuality {
 var Sort as String;
}

function (CFruit, CQuality)::name() as string { // Тоже доопределяем функцию CFruit::name()
  Result = Sort + " " + Kind;
}

var AllTogather as (CColored, CFruit, CQuality);
AllTogather.Kind = "Grape";
AllTogather.Color = "Red";
AllTogather.Quality = "Rotten";
App.MsgBox(AllTogather.name());

template<class I, class T>struct InterfaceCheck{};
#define INTERFACE_CHECK(cur, test)\
STATIC_CHECK(Loki::SuperSubclass<test, T>::value, if_class_is_##cur##_then_it_must_be_##test)

template <class I, class T>
struct Part
    :I
{
    T& self() { return *static_cast<T*>(this); }
private:
    typedef InterfaceCheck<I, T> dummy;
};

struct IColored{};
struct IFruit{};

struct IColoredFruit{};
template<class T>
struct InterfaceCheck<IColoredFruit, T>
{
    INTERFACE_CHECK(IColoredFruit, IColored)
    INTERFACE_CHECK(IColoredFruit, IFruit)
};

V>Может быть это мне показалось с непривычки, но когда один template наползает на другой template и юзает его через третий template, мне становится дурно. А ошибки в этом ловить...

template <class T>
struct Self{
    T& self() { return *static_cast<T*>(this); }
};

template <class T>
struct Mango:Self<T>, IFruit {
    cchar_t* _IFruit_kind() { return "mango"; }
};
struct ColoredImpl:IColored//Толстая реализация
{
    std::string    _m_color;

    cchar_t* _IColored_color_get() { return _m_color.c_str(); }
    void _IColored_color_set( cchar_t *color ) { _m_color = color; }
};
template <class T>
struct Colored :Self<T>, ColoredImpl{};

V>struct MyApple ...
V>struct MyMango ...
V>struct MyOrange ...
V>struct MyHome ...
V>// ... и т.д.
V>

K>class LinuxWindow;
K>class Win32Window;
K>class DBView;

K>var dbvLnx as (LinuxWindow,DBView)
K>var dbvWin as (Win32Window,DBView)
K>

V>class CFruit { // Фрукт
V> var Kind as string;
V> function name() as string {
V>   if Result = NULL { // Отдаёмся на откуп "наследникам"
V>     Result = Kind;
V>   }
V> }
V>}

V>class CColored { // Нечто цветное
V> var Color as string;
V>}

V>function (CFruit, CColored)::name() as string { // Доопределяем функцию CFruit::name()
V>  Result = Color + " " + Kind;
V>}
V>

function (CFruit, CColored)::name() as string { // Доопределяем функцию CFruit::name()
  Result = this->CColored::Color + " " + this->CFruit::Kind;
}

V>class CQuality {
V> var Sort as String;
V>}

V>function (CFruit, CQuality)::name() as string { // Тоже доопределяем функцию CFruit::name()
V>  Result = Sort + " " + Kind;
V>}
V>

V>var AllTogather as (CColored, CFruit, CQuality);
V>AllTogather.Kind = "Grape";
V>AllTogather.Color = "Red";
V>AllTogather.Quality = "Rotten";
V>App.MsgBox(AllTogather.name());
V>

V>"Red Grape" или "Rotten Grape" ?

struct MyApple :
    Apple<MyApple>,
    Colored<MyApple>,
    ColoredFruit<MyApple>,
    Part<IObject,MyApple>
{
    string _IObject_fullName_get() {
        return color_get() + " " + kind() + " fruit";
    }
};

interface IBark {
  void Bark();
}
interface ICreature {
  void Live();
}
interface IGadget {
  void Execute();
}

class LiveDog : public ICreature, IBark {};
class ElectronicDog : public IGadget, IBark {};

присутствия возможности задания перечня классов непосредственно для каждого объекта

  class _useonceforIbo_ : piblic IGadget, IBark{} *Ibo = new _useonceforIbo_();

  class _useonceforIbo_ : piblic IGadget, IBark{} *Ibo = new _useonceforIbo_();
  class _useonceforIbo2_ : piblic IGadget, IBark{} *IboSon = new _useonceforIbo2_();

Вооружившись комбинаторикой, можно вспомнить, что количество сочетаний N классов, выбранных среди K существующих (без учета порядка), равно С(K, N) = K!/(N!*(K-N)!))

class clPersistent {
  virtual void Read()=0;
  virtual void Save()=0;
}

class clOrder {
  SomeOrderMethod();
}
class clClient {
  SomeClientMethod();
}

S>  class _useonceforIbo_ : piblic IGadget, IBark{} *Ibo = new _useonceforIbo_();
S>

S>  class _useonceforIbo_ : piblic IGadget, IBark{} *Ibo = new _useonceforIbo_();
S>  class _useonceforIbo2_ : piblic IGadget, IBark{} *IboSon = new _useonceforIbo2_();
S>

            -- Структура БД
Метаданные <      
            -- Классы