Merge pull request #270 from Libvisual/c++11-override-final

kaixiong · web-flow · commit 91cf50918421 · 2023-02-13T21:29:13.000+08:00
Core (lv-tool): Apply 'override' and 'final' to classes.
diff --git a/libvisual/tools/lv-tool/display/display.hpp b/libvisual/tools/lv-tool/display/display.hpp
@@ -31,7 +31,8 @@
 
 class DisplayDriver;
 
-class Display {
+class Display final
+{
 public:
 
     explicit Display (std::string const& driver_name);
@@ -74,7 +75,7 @@ class Display {
     const std::unique_ptr<Impl> m_impl;
 };
 
-class DisplayLock
+class DisplayLock final
 {
 public:
 
diff --git a/libvisual/tools/lv-tool/display/display_driver_factory.hpp b/libvisual/tools/lv-tool/display/display_driver_factory.hpp
@@ -34,7 +34,7 @@ typedef std::function<DisplayDriver* (Display& display)> DisplayDriverCreator;
 
 typedef std::vector<std::string> DisplayDriverList;
 
-class DisplayDriverFactory
+class DisplayDriverFactory final
 {
 public:
 
diff --git a/libvisual/tools/lv-tool/display/sdl_driver.cpp b/libvisual/tools/lv-tool/display/sdl_driver.cpp
@@ -55,7 +55,7 @@ namespace {
 
   void get_nearest_resolution (int& width, int& height);
 
-  class SDLDriver
+  class SDLDriver final
       : public DisplayDriver
   {
   public:
@@ -72,16 +72,16 @@ namespace {
           , m_running         (false)
       {}
 
-      virtual ~SDLDriver ()
+      ~SDLDriver () override
       {
           close ();
       }
 
-      virtual LV::VideoPtr create (VisVideoDepth depth,
-                                   VisVideoAttrOptions const* vidoptions,
-                                   unsigned int width,
-                                   unsigned int height,
-                                   bool resizable)
+      LV::VideoPtr create (VisVideoDepth depth,
+                           VisVideoAttrOptions const* vidoptions,
+                           unsigned int width,
+                           unsigned int height,
+                           bool resizable) override
       {
 
           int videoflags = 0;
@@ -151,7 +151,7 @@ namespace {
           return m_screen_video;
       }
 
-      virtual void close ()
+      void close () override
       {
           if (!m_running)
               return;
@@ -163,24 +163,24 @@ namespace {
           m_running = false;
       }
 
-      virtual void lock ()
+      void lock () override
       {
           if (SDL_MUSTLOCK (m_screen))
               SDL_LockSurface (m_screen);
       }
 
-      virtual void unlock ()
+      void unlock () override
       {
           if (SDL_MUSTLOCK (m_screen) == SDL_TRUE)
               SDL_UnlockSurface (m_screen);
       }
 
-      virtual bool is_fullscreen () const
+      bool is_fullscreen () const override
       {
           return m_screen->flags & SDL_FULLSCREEN;
       }
 
-      virtual void set_fullscreen (bool fullscreen, bool autoscale)
+      void set_fullscreen (bool fullscreen, bool autoscale) override
       {
           if (fullscreen) {
               if (!(m_screen->flags & SDL_FULLSCREEN)) {
@@ -211,17 +211,17 @@ namespace {
           }
       }
 
-      virtual LV::VideoPtr get_video () const
+      LV::VideoPtr get_video () const override
       {
           return m_screen_video;
       }
 
-      virtual void set_title(std::string const& title)
+      void set_title(std::string const& title) override
       {
           SDL_WM_SetCaption (title.c_str(), nullptr);
       }
 
-      virtual void update_rect (LV::Rect const& rect)
+      void update_rect (LV::Rect const& rect) override
       {
           if (m_screen->format->BitsPerPixel == 8) {
               auto const& pal = m_display.get_video ()->get_palette ();
@@ -246,7 +246,7 @@ namespace {
               SDL_UpdateRect (m_screen, rect.x, rect.y, rect.width, rect.height);
       }
 
-      virtual void drain_events (VisEventQueue& eventqueue)
+      void drain_events (VisEventQueue& eventqueue) override
       {
           // Visible or not
 
diff --git a/libvisual/tools/lv-tool/display/stdout_driver.cpp b/libvisual/tools/lv-tool/display/stdout_driver.cpp
@@ -36,7 +36,7 @@
 
 namespace {
 
-  class StdoutDriver
+  class StdoutDriver final
       : public DisplayDriver
   {
   public:
@@ -46,16 +46,16 @@ namespace {
           (void)display;
       }
 
-      virtual ~StdoutDriver ()
+      ~StdoutDriver () override
       {
           close ();
       }
 
-      virtual LV::VideoPtr create (VisVideoDepth depth,
-                                   VisVideoAttrOptions const* vidoptions,
-                                   unsigned int width,
-                                   unsigned int height,
-                                   bool resizable)
+      LV::VideoPtr create (VisVideoDepth depth,
+                           VisVideoAttrOptions const* vidoptions,
+                           unsigned int width,
+                           unsigned int height,
+                           bool resizable) override
       {
           (void)vidoptions;
           (void)resizable;
@@ -71,55 +71,55 @@ namespace {
           return m_screen_video;
       }
 
-      virtual void close ()
+      void close () override
       {
           m_screen_video.reset ();
       }
 
-      virtual void lock ()
+      void lock () override
       {
           // nothing to do
       }
 
-      virtual void unlock ()
+      void unlock () override
       {
           // nothing to do
       }
 
-      virtual bool is_fullscreen () const
+      bool is_fullscreen () const override
       {
           return false;
       }
 
-      virtual void set_fullscreen (bool fullscreen, bool autoscale)
+      void set_fullscreen (bool fullscreen, bool autoscale) override
       {
           (void)fullscreen;
           (void)autoscale;
 
           // nothing to do
       }
 
-      virtual LV::VideoPtr get_video () const
+      LV::VideoPtr get_video () const override
       {
           return m_screen_video;
       }
 
-      virtual void set_title(std::string const& title)
+      void set_title(std::string const& title) override
       {
           (void)title;
 
           // nothing to do
       }
 
-      virtual void update_rect (LV::Rect const& rect)
+      void update_rect (LV::Rect const& rect) override
       {
           (void)rect;
 
           if (write (STDOUT_FILENO, m_screen_video->get_pixels (), m_screen_video->get_size ()) == -1)
               visual_log (VISUAL_LOG_ERROR, "Failed to write pixels to stdout");
       }
 
-      virtual void drain_events (VisEventQueue& eventqueue)
+      void drain_events (VisEventQueue& eventqueue) override
       {
           (void)eventqueue;
 
diff --git a/libvisual/tools/lv-tool/display/stdout_sdl_driver.cpp b/libvisual/tools/lv-tool/display/stdout_sdl_driver.cpp
@@ -66,7 +66,7 @@ namespace {
 
   void get_nearest_resolution (int& width, int& height);
 
-  class StdoutSDLDriver
+  class StdoutSDLDriver final
       : public DisplayDriver
   {
   public:
@@ -83,16 +83,16 @@ namespace {
           , m_running         (false)
       {}
 
-      virtual ~StdoutSDLDriver ()
+      ~StdoutSDLDriver () override
       {
           close ();
       }
 
-      virtual LV::VideoPtr create (VisVideoDepth depth,
-                                   VisVideoAttrOptions const* vidoptions,
-                                   unsigned int width,
-                                   unsigned int height,
-                                   bool resizable)
+      LV::VideoPtr create (VisVideoDepth depth,
+                           VisVideoAttrOptions const* vidoptions,
+                           unsigned int width,
+                           unsigned int height,
+                           bool resizable) override
       {
 
           int videoflags = 0;
@@ -170,7 +170,7 @@ namespace {
           return m_screen_video;
       }
 
-      virtual void close ()
+      void close () override
       {
           if (!m_running)
               return;
@@ -180,24 +180,24 @@ namespace {
           m_running = false;
       }
 
-      virtual void lock ()
+      void lock () override
       {
           if (SDL_MUSTLOCK (m_screen))
               SDL_LockSurface (m_screen);
       }
 
-      virtual void unlock ()
+      void unlock () override
       {
           if (SDL_MUSTLOCK (m_screen) == SDL_TRUE)
               SDL_UnlockSurface (m_screen);
       }
 
-      virtual bool is_fullscreen () const
+      bool is_fullscreen () const override
       {
           return m_screen->flags & SDL_FULLSCREEN;
       }
 
-      virtual void set_fullscreen (bool fullscreen, bool autoscale)
+      void set_fullscreen (bool fullscreen, bool autoscale) override
       {
           if (fullscreen) {
               if (!(m_screen->flags & SDL_FULLSCREEN)) {
@@ -228,17 +228,17 @@ namespace {
           }
       }
 
-      virtual LV::VideoPtr get_video () const
+      LV::VideoPtr get_video () const override
       {
           return m_screen_video;
       }
 
-      virtual void set_title(std::string const& title)
+      void set_title(std::string const& title) override
       {
           SDL_WM_SetCaption (title.c_str(), nullptr);
       }
 
-      virtual void update_rect (LV::Rect const& rect)
+      void update_rect (LV::Rect const& rect) override
       {
           if (m_screen->format->BitsPerPixel == 8) {
               auto const& pal = m_display.get_video ()->get_palette ();
@@ -291,7 +291,7 @@ namespace {
           }
       }
 
-      virtual void drain_events (VisEventQueue& eventqueue)
+      void drain_events (VisEventQueue& eventqueue) override
       {
           // Visible or not
 
diff --git a/libvisual/tools/lv-tool/lv-tool.cpp b/libvisual/tools/lv-tool/lv-tool.cpp
@@ -90,7 +90,7 @@ namespace {
   };
 
   /** Class to manage LV's lifecycle */
-  class Libvisual
+  class Libvisual final
   {
   public:
 

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ typedef std::function<DisplayDriver* (Display& display)> DisplayDriverCreator;`
`34`	`34`
`35`	`35`	`typedef std::vector<std::string> DisplayDriverList;`
`36`	`36`
`37`		`-class DisplayDriverFactory`
	`37`	`+class DisplayDriverFactory final`
`38`	`38`	`{`
`39`	`39`	`public:`
`40`	`40`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ namespace {`
`55`	`55`
`56`	`56`	`void get_nearest_resolution (int& width, int& height);`
`57`	`57`
`58`		`- class SDLDriver`
	`58`	`+ class SDLDriver final`
`59`	`59`	`: public DisplayDriver`
`60`	`60`	`{`
`61`	`61`	`public:`
`@@ -72,16 +72,16 @@ namespace {`
`72`	`72`	`, m_running (false)`
`73`	`73`	`{}`
`74`	`74`
`75`		`- virtual ~SDLDriver ()`
	`75`	`+ ~SDLDriver () override`
`76`	`76`	`{`
`77`	`77`	`close ();`
`78`	`78`	`}`
`79`	`79`
`80`		`- virtual LV::VideoPtr create (VisVideoDepth depth,`
`81`		`- VisVideoAttrOptions const* vidoptions,`
`82`		`- unsigned int width,`
`83`		`- unsigned int height,`
`84`		`- bool resizable)`
	`80`	`+ LV::VideoPtr create (VisVideoDepth depth,`
	`81`	`+ VisVideoAttrOptions const* vidoptions,`
	`82`	`+ unsigned int width,`
	`83`	`+ unsigned int height,`
	`84`	`+ bool resizable) override`
`85`	`85`	`{`
`86`	`86`
`87`	`87`	`int videoflags = 0;`
`@@ -151,7 +151,7 @@ namespace {`
`151`	`151`	`return m_screen_video;`
`152`	`152`	`}`
`153`	`153`
`154`		`- virtual void close ()`
	`154`	`+ void close () override`
`155`	`155`	`{`
`156`	`156`	`if (!m_running)`
`157`	`157`	`return;`
`@@ -163,24 +163,24 @@ namespace {`
`163`	`163`	`m_running = false;`
`164`	`164`	`}`
`165`	`165`
`166`		`- virtual void lock ()`
	`166`	`+ void lock () override`
`167`	`167`	`{`
`168`	`168`	`if (SDL_MUSTLOCK (m_screen))`
`169`	`169`	`SDL_LockSurface (m_screen);`
`170`	`170`	`}`
`171`	`171`
`172`		`- virtual void unlock ()`
	`172`	`+ void unlock () override`
`173`	`173`	`{`
`174`	`174`	`if (SDL_MUSTLOCK (m_screen) == SDL_TRUE)`
`175`	`175`	`SDL_UnlockSurface (m_screen);`
`176`	`176`	`}`
`177`	`177`
`178`		`- virtual bool is_fullscreen () const`
	`178`	`+ bool is_fullscreen () const override`
`179`	`179`	`{`
`180`	`180`	`return m_screen->flags & SDL_FULLSCREEN;`
`181`	`181`	`}`
`182`	`182`
`183`		`- virtual void set_fullscreen (bool fullscreen, bool autoscale)`
	`183`	`+ void set_fullscreen (bool fullscreen, bool autoscale) override`
`184`	`184`	`{`
`185`	`185`	`if (fullscreen) {`
`186`	`186`	`if (!(m_screen->flags & SDL_FULLSCREEN)) {`
`@@ -211,17 +211,17 @@ namespace {`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`
`214`		`- virtual LV::VideoPtr get_video () const`
	`214`	`+ LV::VideoPtr get_video () const override`
`215`	`215`	`{`
`216`	`216`	`return m_screen_video;`
`217`	`217`	`}`
`218`	`218`
`219`		`- virtual void set_title(std::string const& title)`
	`219`	`+ void set_title(std::string const& title) override`
`220`	`220`	`{`
`221`	`221`	`SDL_WM_SetCaption (title.c_str(), nullptr);`
`222`	`222`	`}`
`223`	`223`
`224`		`- virtual void update_rect (LV::Rect const& rect)`
	`224`	`+ void update_rect (LV::Rect const& rect) override`
`225`	`225`	`{`
`226`	`226`	`if (m_screen->format->BitsPerPixel == 8) {`
`227`	`227`	`auto const& pal = m_display.get_video ()->get_palette ();`
`@@ -246,7 +246,7 @@ namespace {`
`246`	`246`	`SDL_UpdateRect (m_screen, rect.x, rect.y, rect.width, rect.height);`
`247`	`247`	`}`
`248`	`248`
`249`		`- virtual void drain_events (VisEventQueue& eventqueue)`
	`249`	`+ void drain_events (VisEventQueue& eventqueue) override`
`250`	`250`	`{`
`251`	`251`	`// Visible or not`
`252`	`252`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@`
`36`	`36`
`37`	`37`	`namespace {`
`38`	`38`
`39`		`- class StdoutDriver`
	`39`	`+ class StdoutDriver final`
`40`	`40`	`: public DisplayDriver`
`41`	`41`	`{`
`42`	`42`	`public:`
`@@ -46,16 +46,16 @@ namespace {`
`46`	`46`	`(void)display;`
`47`	`47`	`}`
`48`	`48`
`49`		`- virtual ~StdoutDriver ()`
	`49`	`+ ~StdoutDriver () override`
`50`	`50`	`{`
`51`	`51`	`close ();`
`52`	`52`	`}`
`53`	`53`
`54`		`- virtual LV::VideoPtr create (VisVideoDepth depth,`
`55`		`- VisVideoAttrOptions const* vidoptions,`
`56`		`- unsigned int width,`
`57`		`- unsigned int height,`
`58`		`- bool resizable)`
	`54`	`+ LV::VideoPtr create (VisVideoDepth depth,`
	`55`	`+ VisVideoAttrOptions const* vidoptions,`
	`56`	`+ unsigned int width,`
	`57`	`+ unsigned int height,`
	`58`	`+ bool resizable) override`
`59`	`59`	`{`
`60`	`60`	`(void)vidoptions;`
`61`	`61`	`(void)resizable;`
`@@ -71,55 +71,55 @@ namespace {`
`71`	`71`	`return m_screen_video;`
`72`	`72`	`}`
`73`	`73`
`74`		`- virtual void close ()`
	`74`	`+ void close () override`
`75`	`75`	`{`
`76`	`76`	`m_screen_video.reset ();`
`77`	`77`	`}`
`78`	`78`
`79`		`- virtual void lock ()`
	`79`	`+ void lock () override`
`80`	`80`	`{`
`81`	`81`	`// nothing to do`
`82`	`82`	`}`
`83`	`83`
`84`		`- virtual void unlock ()`
	`84`	`+ void unlock () override`
`85`	`85`	`{`
`86`	`86`	`// nothing to do`
`87`	`87`	`}`
`88`	`88`
`89`		`- virtual bool is_fullscreen () const`
	`89`	`+ bool is_fullscreen () const override`
`90`	`90`	`{`
`91`	`91`	`return false;`
`92`	`92`	`}`
`93`	`93`
`94`		`- virtual void set_fullscreen (bool fullscreen, bool autoscale)`
	`94`	`+ void set_fullscreen (bool fullscreen, bool autoscale) override`
`95`	`95`	`{`
`96`	`96`	`(void)fullscreen;`
`97`	`97`	`(void)autoscale;`
`98`	`98`
`99`	`99`	`// nothing to do`
`100`	`100`	`}`
`101`	`101`
`102`		`- virtual LV::VideoPtr get_video () const`
	`102`	`+ LV::VideoPtr get_video () const override`
`103`	`103`	`{`
`104`	`104`	`return m_screen_video;`
`105`	`105`	`}`
`106`	`106`
`107`		`- virtual void set_title(std::string const& title)`
	`107`	`+ void set_title(std::string const& title) override`
`108`	`108`	`{`
`109`	`109`	`(void)title;`
`110`	`110`
`111`	`111`	`// nothing to do`
`112`	`112`	`}`
`113`	`113`
`114`		`- virtual void update_rect (LV::Rect const& rect)`
	`114`	`+ void update_rect (LV::Rect const& rect) override`
`115`	`115`	`{`
`116`	`116`	`(void)rect;`
`117`	`117`
`118`	`118`	`if (write (STDOUT_FILENO, m_screen_video->get_pixels (), m_screen_video->get_size ()) == -1)`
`119`	`119`	`visual_log (VISUAL_LOG_ERROR, "Failed to write pixels to stdout");`
`120`	`120`	`}`
`121`	`121`
`122`		`- virtual void drain_events (VisEventQueue& eventqueue)`
	`122`	`+ void drain_events (VisEventQueue& eventqueue) override`
`123`	`123`	`{`
`124`	`124`	`(void)eventqueue;`
`125`	`125`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ namespace {`
`66`	`66`
`67`	`67`	`void get_nearest_resolution (int& width, int& height);`
`68`	`68`
`69`		`- class StdoutSDLDriver`
	`69`	`+ class StdoutSDLDriver final`
`70`	`70`	`: public DisplayDriver`
`71`	`71`	`{`
`72`	`72`	`public:`
`@@ -83,16 +83,16 @@ namespace {`
`83`	`83`	`, m_running (false)`
`84`	`84`	`{}`
`85`	`85`
`86`		`- virtual ~StdoutSDLDriver ()`
	`86`	`+ ~StdoutSDLDriver () override`
`87`	`87`	`{`
`88`	`88`	`close ();`
`89`	`89`	`}`
`90`	`90`
`91`		`- virtual LV::VideoPtr create (VisVideoDepth depth,`
`92`		`- VisVideoAttrOptions const* vidoptions,`
`93`		`- unsigned int width,`
`94`		`- unsigned int height,`
`95`		`- bool resizable)`
	`91`	`+ LV::VideoPtr create (VisVideoDepth depth,`
	`92`	`+ VisVideoAttrOptions const* vidoptions,`
	`93`	`+ unsigned int width,`
	`94`	`+ unsigned int height,`
	`95`	`+ bool resizable) override`
`96`	`96`	`{`
`97`	`97`
`98`	`98`	`int videoflags = 0;`
`@@ -170,7 +170,7 @@ namespace {`
`170`	`170`	`return m_screen_video;`
`171`	`171`	`}`
`172`	`172`
`173`		`- virtual void close ()`
	`173`	`+ void close () override`
`174`	`174`	`{`
`175`	`175`	`if (!m_running)`
`176`	`176`	`return;`
`@@ -180,24 +180,24 @@ namespace {`
`180`	`180`	`m_running = false;`
`181`	`181`	`}`
`182`	`182`
`183`		`- virtual void lock ()`
	`183`	`+ void lock () override`
`184`	`184`	`{`
`185`	`185`	`if (SDL_MUSTLOCK (m_screen))`
`186`	`186`	`SDL_LockSurface (m_screen);`
`187`	`187`	`}`
`188`	`188`
`189`		`- virtual void unlock ()`
	`189`	`+ void unlock () override`
`190`	`190`	`{`
`191`	`191`	`if (SDL_MUSTLOCK (m_screen) == SDL_TRUE)`
`192`	`192`	`SDL_UnlockSurface (m_screen);`
`193`	`193`	`}`
`194`	`194`
`195`		`- virtual bool is_fullscreen () const`
	`195`	`+ bool is_fullscreen () const override`
`196`	`196`	`{`
`197`	`197`	`return m_screen->flags & SDL_FULLSCREEN;`
`198`	`198`	`}`
`199`	`199`
`200`		`- virtual void set_fullscreen (bool fullscreen, bool autoscale)`
	`200`	`+ void set_fullscreen (bool fullscreen, bool autoscale) override`
`201`	`201`	`{`
`202`	`202`	`if (fullscreen) {`
`203`	`203`	`if (!(m_screen->flags & SDL_FULLSCREEN)) {`
`@@ -228,17 +228,17 @@ namespace {`
`228`	`228`	`}`
`229`	`229`	`}`
`230`	`230`
`231`		`- virtual LV::VideoPtr get_video () const`
	`231`	`+ LV::VideoPtr get_video () const override`
`232`	`232`	`{`
`233`	`233`	`return m_screen_video;`
`234`	`234`	`}`
`235`	`235`
`236`		`- virtual void set_title(std::string const& title)`
	`236`	`+ void set_title(std::string const& title) override`
`237`	`237`	`{`
`238`	`238`	`SDL_WM_SetCaption (title.c_str(), nullptr);`
`239`	`239`	`}`
`240`	`240`
`241`		`- virtual void update_rect (LV::Rect const& rect)`
	`241`	`+ void update_rect (LV::Rect const& rect) override`
`242`	`242`	`{`
`243`	`243`	`if (m_screen->format->BitsPerPixel == 8) {`
`244`	`244`	`auto const& pal = m_display.get_video ()->get_palette ();`
`@@ -291,7 +291,7 @@ namespace {`
`291`	`291`	`}`
`292`	`292`	`}`
`293`	`293`
`294`		`- virtual void drain_events (VisEventQueue& eventqueue)`
	`294`	`+ void drain_events (VisEventQueue& eventqueue) override`
`295`	`295`	`{`
`296`	`296`	`// Visible or not`
`297`	`297`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ namespace {`
`90`	`90`	`};`
`91`	`91`
`92`	`92`	`/** Class to manage LV's lifecycle */`
`93`		`- class Libvisual`
	`93`	`+ class Libvisual final`
`94`	`94`	`{`
`95`	`95`	`public:`
`96`	`96`