Comment encapsuler au mieux les poignées de fenêtre?

Question

Je développe un système composé de nombreux sous-systèmes indépendants. Deux de ces sous-systèmes sont le sous-système Window et le sous-système GraphicsAdapter. GraphicsAdapter requiert un handle de fenêtre de bas niveau (HWND ou X11 Window Handle, selon le système d'exploitation), et le sous-système Window est un moyen de résumer ces API spécifiques au système d'exploitation.

Si le sous-système Window donnait accès à des poignées d'API de bas niveau, l'encapsulation risquait fort d'être interrompue. Et si cela permettait aux fenêtres de passer en plein écran et de revenir en arrière, mais qu'elles devaient déclencher des événements avertissant le système de ces changements, et que la poignée de bas niveau était utilisée pour passer en plein écran à son insu? Comment puis-je m'assurer que le handle sera transporté du sous-système Window vers GraphicsAdapter sans être abusé, tout en étant suffisamment flexible pour permettre l'ajout ultérieur d'autres sous-systèmes comme GraphicsAdapter, tout en conservant la sécurité du type ?

Existe-t-il un moyen d'encapsuler les handles d'une manière que Direct3D et OpenGL peuvent accéder juste assez de la poignée pour fonctionner correctement?

- modifier

En plus de poignées de transport en toute sécurité d'un sous-système à un autre, sachant que les sous-systèmes peuvent être écrits par une autre équipe de codeurs, par exemple, est-il un moyen de leur rappeler la façon dont la poignée est destiné à être utilisé?

Les commentaires sont le choix évident, mais quelque chose imposé par le compilateur est ce que je regarde vraiment ...

Answer 1

les deux HWNDs et X11 poignées de fenêtres sont des types pointeur. Vous pouvez utiliser ça à votre avantage. Faites quelque chose comme ceci:

struct WindowHandleImpl; 
typedef WindowHandleImpl *WindowHandle; 

C++ vous permet de travailler avec des pointeurs vers des types incomplets très bien - mais ne définit pas le contenu de WindowHandleImpl partout et WindowHandle est un type parfaitement opaque qui peut être passé autour de l'App sans divulguer les détails de mise en œuvre. Parce que HWND, X11 Window et WindowHandle sont tous les types de pointeurs, vous pouvez les couler librement et sans perte. Donc, chaque fois que vous avez besoin de retourner une poignée de fenêtre enveloppée à l'application, vous faites un static_cast<WindowHandle>(some_hwnd), et la même astuce fonctionne en sens inverse lorsque vous devez convertir un WindowHandle spécifié par l'application dans le type de plate-forme réelle.

Si vous avez besoin de porter sur une plate-forme qui n'utilise pas de type de pointeur pour désigner les poignées de fenêtres, vous pouvez l'insérer dans une structure/classe et y renvoyer un pointeur.

Answer 2

Expose les opérations sur la poignée par des fonctions virtuelles:

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_; 
}; 

Une façon probable de configurer le GraphicsAdapter:

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

Answer 3

Documentez la façon dont vous prévoyez l'utiliser.

Faites confiance aux autres codeurs de votre équipe.N'écrivez pas beaucoup de code en essayant d'inciter votre équipe à coder comme vous le souhaitez. Plus de code signifie plus de code à maintenir, plus de chances de bugs, plus de confusion pour la prochaine personne regardant ce code se demandant ce que le diable est en train de faire.