#include <string>

class NotificationClient {
public:
        //virtual void notify(const Notification& wm);
        virtual void notify(const int& wm);
};

void NotificationClient::notify(const int& wm)
{
}

class Object_base : public NotificationClient {
private:
        friend class DynamicRequest;
        friend class ObjectManager;
        bool _deleteOk;                         // ensure that "delete" is not called manually

protected:
        /**
         * ObjectInternalData contains private data structures for
         *  - Object_base
         *  - Object_stub
         *  - Object_skel
         *
         * This is an optimization over adding each of them private data pointers,
         * which would lead to some more bloat.
         */
        class ObjectInternalData *_internalData;

        struct ObjectStreamInfo;

        Object_base();
        virtual ~Object_base();
};

Object_base::Object_base()
{
}

Object_base::~Object_base()
{
}

class Object_skel : virtual public Object_base {
private:
        long _remoteSendCount;          // don't kill objects just sent to other server
};

class SynthModule_base : virtual public Object_base {
public:
        virtual void start() = 0;
        virtual void stop() = 0;
};

class SynthModule_skel : virtual public SynthModule_base, virtual public Object_skel {
public:
        SynthModule_skel();
};

SynthModule_skel::SynthModule_skel()
{
}

class StdSynthModulePrivate;

class StdSynthModule : virtual public SynthModule_base {
private:
        StdSynthModulePrivate *d;

protected:
        long samplingRate;
        float samplingRateFloat;

public:
        StdSynthModule();

        void start();
        void stop();
};

void StdSynthModule::start()
{
}

void StdSynthModule::stop()
{
}

StdSynthModule::StdSynthModule()
{
}

class DynamicSkeletonBase {
private:
        Object_skel *skel;

protected:
        DynamicSkeletonBase(Object_skel *skel, const std::string& interfacename);
        virtual ~DynamicSkeletonBase();
};

DynamicSkeletonBase::DynamicSkeletonBase(Object_skel *skel, const std::string& interfacename)
{
	this->skel = skel;
}

DynamicSkeletonBase::~DynamicSkeletonBase()
{
}

template<class Parent_skel>
class DynamicSkeleton : virtual public Parent_skel, public DynamicSkeletonBase
{
public:
        /**
         * constructor
         */
        DynamicSkeleton(const std::string& interface)
           : DynamicSkeletonBase(this, interface)
        {
		printf("%x\n", this);
                //
        }
};

typedef DynamicSkeleton<SynthModule_skel> SynthModule_dskel;

class Structure_impl : virtual public SynthModule_dskel,
                       virtual public StdSynthModule {
protected:
    int structureObjects;

public:
    Structure_impl(int structure, int factories);
};

Structure_impl::Structure_impl(int i, int j)
	: SynthModule_dskel("foo")
{
}

main()
{
	new Structure_impl(1,5);
}