No replies to this topic

[Buttacup]

I'm making something of an 'atom' based communications system whereupon all modular and base_type entity interactions are conducted via generic pathways. Messages are being reduced to their least form transmitted unpacked and executed from within the receiving container. I'm implementing using the form of stl but specialized and not templated as I'm using virtualization and the two do not go together well! Anyway I'm wondering if there is any advice anyone can give before I begin to crunch? I am hoping to achieve a very dynamical almost a but is a reduced database.....

prelims on what it is I'm looking at at the moment:

INetVar*

    //---------- NETWORKED VARIABLE ----------//
    MIDL_INTERFACE("00000000-0000-0000-0000-000000000000")
    INetVar : public virtual IUnknown
    {
    public:
        virtual MODULE STDMETHODCALLTYPE Reciprocant() PURE;
        virtual DIRECTIVE STDMETHODCALLTYPE Directive() PURE;
        virtual BASE_TYPE STDMETHODCALLTYPE ReferencedBaseType() PURE;
        virtual IBaseVarSubres* STDMETHODCALLTYPE Data() PURE;
        
    private:
        INetVar& operator=(const INetVar&);
    };

    //---------- NETWORKED VARIABLE SUB RESOURCE ----------//
    MIDL_INTERFACE("00000000-0000-0000-0000-000000000000")
    IBaseVarSubres : public virtual IUnknown
    {
    public:
        virtual HRESULT    STDMETHODCALLTYPE GetHR() PURE;
        virtual void    STDMETHODCALLTYPE SetHR( HRESULT hr ) PURE;

    private:
        IBaseVarSubres& operator=(const IBaseVarSubres&);
    };

    MIDL_INTERFACE("00000000-0000-0000-0000-000000000000")
    IModuleInstruction : public IBaseVarSubres
    {
    public:
        virtual LPCWSTR STDMETHODCALLTYPE ModuleDLL() PURE;
        virtual NAME_SEMANTIC* STDMETHODCALLTYPE ModuleScriptFile() PURE;

    private:
        IModuleInstruction& operator=(const IModuleInstruction&);
    };

IContained:

    //---------- CONTAINED ----------//
    MIDL_INTERFACE("00000000-0000-0000-0000-000000000000") 
    IContained : public IRequest, public virtual IUnknown
    {
    public:
        virtual HRESULT STDMETHODCALLTYPE Load( INetVar* pVar ) PURE;
        virtual HRESULT STDMETHODCALLTYPE Unload( INetVar* pVar ) PURE;
        virtual HRESULT STDMETHODCALLTYPE Delete( INetVar* pVar ) PURE;
        virtual HRESULT STDMETHODCALLTYPE PublicInterface( INetVar* pVar ) PURE;
        virtual HRESULT STDMETHODCALLTYPE GetDataMember( INetVar* pVar ) PURE;
        virtual HRESULT STDMETHODCALLTYPE SetDataMember( INetVar* pVar ) PURE;
        virtual HRESULT STDMETHODCALLTYPE RunScript( INetVar* pVar ) PURE;
        
    private:
        IContained& operator=(const IContained&);
    };

early Contained(under construction):

    class DECLSPEC_UUID("00000000-0000-0000-0000-000000000000")
    DynamicalResource
    {
    public:
        DynamicalResource(){}

    };

    class DECLSPEC_UUID("00000000-0000-0000-0000-000000000000")
    MemmoryManager
    {
    public:
        MemmoryManager(MODULE in_type, SIZE_T reserve) : module_type(in_type), reserved(reserve)
        {
            ppModules = new IBaseModule*[reserve];
        }

        HRESULT Cache(IBaseModule** index, LPCWSTR name);

    private:
        MODULE module_type;
        SIZE_T reserved;

        NAME_SEMANTIC Index[50];
        IBaseModule** ppModules;
    };

    class DECLSPEC_UUID("00000000-0000-0000-0000-000000000000")
    Contained : public IContained
    {
    public:
        Contained(MODULE in_type);
        ~Contained();

        virtual void STDMETHODCALLTYPE SetRelay( IRelay** ppCommunicate );
        
        virtual HRESULT STDMETHODCALLTYPE Load( INetVar* pVar );
        virtual HRESULT STDMETHODCALLTYPE Unload( INetVar* pVar );
        virtual HRESULT STDMETHODCALLTYPE Delete( INetVar* pVar );
        virtual HRESULT STDMETHODCALLTYPE PublicInterface( INetVar* pVar );
        virtual HRESULT STDMETHODCALLTYPE GetDataMember( INetVar* pVar );
        virtual HRESULT STDMETHODCALLTYPE SetDataMember( INetVar* pVar );
        virtual HRESULT STDMETHODCALLTYPE RunScript( INetVar* pVar );

        virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject);
        virtual ULONG STDMETHODCALLTYPE AddRef(void);
        virtual ULONG STDMETHODCALLTYPE Release(void);

    private:
        MODULE module_type;
        MemmoryManager* pMemmoryManager;

        IRelay* pRelay;

        IPublicInterface* pPublicInterface;
                
        ULONG _refcount;
    };

note: IModuleInstruction is used for the new, unload and delete methods to serialize/deserialize a module in and out of existence.... this is not the BaseSubVarRes used to runscript.... I do not believe that would be appropriate as the dll would not be required at this point! This is mainly relevant because naming convention is by the XML serial file and not the DLL... should probably change that name it's misleading... Just sayin' o-o

Edited by Buttacup, 23 March 2010 - 07:44 PM.