Come migliori martelline incapsulare?

Question

sto sviluppando un sistema composto da molti sottosistemi indipendenti. Due di questi sottosistemi sono la finestra e il sottosistema GraphicsAdapter.

Il GraphicsAdapter richiede un handle di finestra a basso livello (HWND o X11 Window Handle, a seconda del sistema operativo), e il sottosistema finestra è un modo per astratte queste API OS specifici.

Se il sottosistema finestra dava accesso alle maniglie di basso livello API, ci sarebbe un grande potenziale per l'incapsulamento essere rotto.

E se fosse consentito finestre per andare a tutto schermo e viceversa, ma ha dovuto eventi Fuoco segnale il sistema di quei cambiamenti, e il manico di basso livello sono stati usati per levetta fullscreen a sua insaputa?

Come faccio a garantire la maniglia sarà effettuato in modo sicuro dal sottosistema Finestra per il GraphicsAdapter senza essere abusato, e ancora essere abbastanza flessibile da consentire ad altri sottosistemi come il GraphicsAdapter da aggiungere dopo, mentre allo stesso tempo mantenendo la sicurezza di tipo?

C'è un modo per incapsulare le maniglie in modo Direct3D e OpenGL potevano accedere solo abbastanza dal manico al lavoro correttamente?

- modifica

In aggiunta alle maniglie di trasporto in modo sicuro da un sottosistema all'altro, sapendo che i sottosistemi possono essere scritti da un gruppo diverso di programmatori, ad esempio, esiste un modo per ricordare loro il modo in cui la maniglia è destinato a essere utilizzato?

I commenti sono la scelta più ovvia, ma qualcosa imposto dal compilatore è quello che non vedo per ...

Answer 1

Sia hWnds e X11 Window Le maniglie sono tipi di puntatore. È possibile utilizzare questo a vostro vantaggio. Fare qualcosa di simile:

struct WindowHandleImpl;
typedef WindowHandleImpl *WindowHandle;

C ++ permette di lavorare con puntatori a tipi incompleti bene -. Basta non definire i contenuti di WindowHandleImpl ovunque e WindowHandle è un tipo perfettamente opaca che può essere passato in giro da App senza rivelare alcun dettaglio di implementazione

A causa HWND, X11 Window e WindowHandle sono tutti i tipi di puntatore, si può lanciare fra loro liberamente e senza perdita di qualità. Così ogni volta che è necessario restituire un handle di finestra avvolto per l'applicazione, si fa un static_cast<WindowHandle>(some_hwnd), e lo stesso trucco funziona al contrario quando si ha bisogno di convertire un WindowHandle app-specificata nel tipo di piattaforma attuale.

Se hai bisogno di porta per una piattaforma che non utilizza un tipo di puntatore per indicare le maniglie per finestre, si può avvolgere che in una struct / classe e di restituire un puntatore a questo.

Answer 2

Esporre le operazioni sul manico attraverso funzioni virtuali:

class GenericHandle
{
    public:
        virtual void some_operation() = 0;
};

// Windows API
class WindowsHandle : public GenericHandle
{
    public:
        virtual void some_operation()
        {
            WndOperation (handle_);
        }
    private:
        HANDLE* handle_;
};

// Some X system API
class XHandle : public GenericHandle
{
    public:
        virtual void some_operation()
        {
           XOperation (handle_);
        }
    private:
        XVOID* handle_;
};

Un modo probabile per configurare l'GraphicsAdapter:

GraphicsAdapter* ga = new GraphicsAdapter(GenericHandleFactory::get_handle(SYSTEM_ID));

Answer 3

Documento come ci si aspetta di essere utilizzato.

La fiducia gli altri codificatori sul vostro team.

Non scrivere un mucchio di codice cercando di camicia di vostra squadra nella codifica solo il modo in cui si desideri. Altri mezzi codice più codice da mantenere, più possibilità per gli insetti, più confusione per la prossima persona guardando questo codice chiedendo cosa diavolo sta facendo.