modernization: `override` instead of virtual in all compilation units

author: Marcus Müller <mmueller@gnuradio.org> 2020-10-30 18:22:33 +0100
committer: mormj <34754695+mormj@users.noreply.github.com> 2020-11-03 14:07:23 -0500
commit: 0ddc7dbc95ca6fb4c4a62a3c027104d6dd71fc3b (patch)
tree: b454053fdc123711f3011b8a703de38e1d783ba3 /gnuradio-runtime/lib
parent: 1cfd6287635e339b313e1826fdfda23f474c91c8 (diff)
11 files changed, 125 insertions, 122 deletions
diff --git a/gnuradio-runtime/lib/block_gateway_impl.h b/gnuradio-runtime/lib/block_gateway_impl.h
index c3d53a408e..e03d45518c 100644
--- a/gnuradio-runtime/lib/block_gateway_impl.h
+++ b/gnuradio-runtime/lib/block_gateway_impl.h
@@ -36,9 +36,9 @@ public:
                      gr_vector_const_void_star& input_items,
                      gr_vector_void_star& output_items) override;
 
-    bool start(void);
-    bool stop(void);
-    void set_msg_handler_pybind(pmt::pmt_t which_port, std::string& handler_name)
+    bool start(void) override;
+    bool stop(void) override;
+    void set_msg_handler_pybind(pmt::pmt_t which_port, std::string& handler_name) override
     {
         if (msg_queue.find(which_port) == msg_queue.end()) {
             throw std::runtime_error(
@@ -52,7 +52,7 @@ protected:
     typedef std::map<pmt::pmt_t, std::string, pmt::comparator> msg_handlers_pybind_t;
     msg_handlers_pybind_t d_msg_handlers_pybind;
 
-    bool has_msg_handler(pmt::pmt_t which_port)
+    bool has_msg_handler(pmt::pmt_t which_port) override
     {
         if (d_msg_handlers_pybind.find(which_port) != d_msg_handlers_pybind.end()) {
             return true;
@@ -61,7 +61,7 @@ protected:
         }
     }
 
-    void dispatch_msg(pmt::pmt_t which_port, pmt::pmt_t msg)
+    void dispatch_msg(pmt::pmt_t which_port, pmt::pmt_t msg) override
     {
         // Is there a handler?
         if (d_msg_handlers_pybind.find(which_port) != d_msg_handlers_pybind.end()) {
diff --git a/gnuradio-runtime/lib/flat_flowgraph.h b/gnuradio-runtime/lib/flat_flowgraph.h
index 37338f6f03..83f5d1b78a 100644
--- a/gnuradio-runtime/lib/flat_flowgraph.h
+++ b/gnuradio-runtime/lib/flat_flowgraph.h
@@ -33,7 +33,7 @@ public:
     friend GR_RUNTIME_API flat_flowgraph_sptr make_flat_flowgraph();
 
     // Destruct an arbitrary gr::flat_flowgraph
-    virtual ~flat_flowgraph();
+    ~flat_flowgraph() override;
 
     // Wire list of gr::block together in new flat_flowgraph
     void setup_connections();
diff --git a/gnuradio-runtime/lib/pmt/pmt_int.h b/gnuradio-runtime/lib/pmt/pmt_int.h
index cabd44e8c2..13c42968f2 100644
--- a/gnuradio-runtime/lib/pmt/pmt_int.h
+++ b/gnuradio-runtime/lib/pmt/pmt_int.h
@@ -30,7 +30,7 @@ public:
     pmt_bool();
     //~pmt_bool(){}
 
-    bool is_bool() const { return true; }
+    bool is_bool() const override { return true; }
 };
 
 
@@ -43,7 +43,7 @@ public:
     pmt_symbol(const std::string& name);
     //~pmt_symbol(){}
 
-    bool is_symbol() const { return true; }
+    bool is_symbol() const override { return true; }
     const std::string name() { return d_name; }
 
     pmt_t next() { return d_next; } // symbol table link
@@ -58,8 +58,8 @@ public:
     pmt_integer(long value);
     //~pmt_integer(){}
 
-    bool is_number() const { return true; }
-    bool is_integer() const { return true; }
+    bool is_number() const override { return true; }
+    bool is_integer() const override { return true; }
     long value() const { return d_value; }
 };
 
@@ -71,8 +71,8 @@ public:
     pmt_uint64(uint64_t value);
     //~pmt_uint64(){}
 
-    bool is_number() const { return true; }
-    bool is_uint64() const { return true; }
+    bool is_number() const override { return true; }
+    bool is_uint64() const override { return true; }
     uint64_t value() const { return d_value; }
 };
 
@@ -84,8 +84,8 @@ public:
     pmt_real(double value);
     //~pmt_real(){}
 
-    bool is_number() const { return true; }
-    bool is_real() const { return true; }
+    bool is_number() const override { return true; }
+    bool is_real() const override { return true; }
     double value() const { return d_value; }
 };
 
@@ -97,8 +97,8 @@ public:
     pmt_complex(std::complex<double> value);
     //~pmt_complex(){}
 
-    bool is_number() const { return true; }
-    bool is_complex() const { return true; }
+    bool is_number() const override { return true; }
+    bool is_complex() const override { return true; }
     std::complex<double> value() const { return d_value; }
 };
 
@@ -108,7 +108,7 @@ public:
     pmt_null();
     //~pmt_null(){}
 
-    bool is_null() const { return true; }
+    bool is_null() const override { return true; }
 };
 
 class pmt_pair : public pmt_base
@@ -120,7 +120,7 @@ public:
     pmt_pair(const pmt_t& car, const pmt_t& cdr);
     //~pmt_pair(){};
 
-    bool is_pair() const { return true; }
+    bool is_pair() const override { return true; }
     pmt_t car() const { return d_car; }
     pmt_t cdr() const { return d_cdr; }
 
@@ -134,7 +134,7 @@ public:
     pmt_dict(const pmt_t& car, const pmt_t& cdr);
     //~pmt_dict(){};
 
-    bool is_dict() const { return true; }
+    bool is_dict() const override { return true; }
 };
 
 class pmt_vector : public pmt_base
@@ -145,7 +145,7 @@ public:
     pmt_vector(size_t len, pmt_t fill);
     //~pmt_vector();
 
-    bool is_vector() const { return true; }
+    bool is_vector() const override { return true; }
     pmt_t ref(size_t k) const;
     void set(size_t k, pmt_t obj);
     void fill(pmt_t fill);
@@ -162,7 +162,7 @@ public:
     pmt_tuple(size_t len);
     //~pmt_tuple();
 
-    bool is_tuple() const { return true; }
+    bool is_tuple() const override { return true; }
     pmt_t ref(size_t k) const;
     size_t length() const { return d_v.size(); }
 
@@ -178,7 +178,7 @@ public:
     pmt_any(const boost::any& any);
     //~pmt_any();
 
-    bool is_any() const { return true; }
+    bool is_any() const override { return true; }
     const boost::any& ref() const { return d_any; }
     void set(const boost::any& any) { d_any = any; }
 };
@@ -187,7 +187,7 @@ public:
 class pmt_uniform_vector : public pmt_base
 {
 public:
-    bool is_uniform_vector() const { return true; }
+    bool is_uniform_vector() const override { return true; }
     virtual const void* uniform_elements(size_t& len) = 0;
     virtual void* uniform_writable_elements(size_t& len) = 0;
     virtual size_t length() const = 0;
diff --git a/gnuradio-runtime/lib/pmt/pmt_unv_int.h b/gnuradio-runtime/lib/pmt/pmt_unv_int.h
index 7c05e0c8af..e3ac0495c2 100644
--- a/gnuradio-runtime/lib/pmt/pmt_unv_int.h
+++ b/gnuradio-runtime/lib/pmt/pmt_unv_int.h
@@ -29,16 +29,16 @@ public:
     pmt_u8vector(size_t k, const uint8_t* data);
     // ~pmt_u8vector();
 
-    bool is_u8vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(uint8_t); }
+    bool is_u8vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(uint8_t); }
     uint8_t ref(size_t k) const;
     void set(size_t k, uint8_t x);
     const uint8_t* elements(size_t& len);
     uint8_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -54,16 +54,16 @@ public:
     pmt_s8vector(size_t k, const int8_t* data);
     // ~pmt_s8vector();
 
-    bool is_s8vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(int8_t); }
+    bool is_s8vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(int8_t); }
     int8_t ref(size_t k) const;
     void set(size_t k, int8_t x);
     const int8_t* elements(size_t& len);
     int8_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -79,16 +79,16 @@ public:
     pmt_u16vector(size_t k, const uint16_t* data);
     // ~pmt_u16vector();
 
-    bool is_u16vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(uint16_t); }
+    bool is_u16vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(uint16_t); }
     uint16_t ref(size_t k) const;
     void set(size_t k, uint16_t x);
     const uint16_t* elements(size_t& len);
     uint16_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -104,16 +104,16 @@ public:
     pmt_s16vector(size_t k, const int16_t* data);
     // ~pmt_s16vector();
 
-    bool is_s16vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(int16_t); }
+    bool is_s16vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(int16_t); }
     int16_t ref(size_t k) const;
     void set(size_t k, int16_t x);
     const int16_t* elements(size_t& len);
     int16_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -129,16 +129,16 @@ public:
     pmt_u32vector(size_t k, const uint32_t* data);
     // ~pmt_u32vector();
 
-    bool is_u32vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(uint32_t); }
+    bool is_u32vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(uint32_t); }
     uint32_t ref(size_t k) const;
     void set(size_t k, uint32_t x);
     const uint32_t* elements(size_t& len);
     uint32_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -154,16 +154,16 @@ public:
     pmt_s32vector(size_t k, const int32_t* data);
     // ~pmt_s32vector();
 
-    bool is_s32vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(int32_t); }
+    bool is_s32vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(int32_t); }
     int32_t ref(size_t k) const;
     void set(size_t k, int32_t x);
     const int32_t* elements(size_t& len);
     int32_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -179,16 +179,16 @@ public:
     pmt_u64vector(size_t k, const uint64_t* data);
     // ~pmt_u64vector();
 
-    bool is_u64vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(uint64_t); }
+    bool is_u64vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(uint64_t); }
     uint64_t ref(size_t k) const;
     void set(size_t k, uint64_t x);
     const uint64_t* elements(size_t& len);
     uint64_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -204,16 +204,16 @@ public:
     pmt_s64vector(size_t k, const int64_t* data);
     // ~pmt_s64vector();
 
-    bool is_s64vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(int64_t); }
+    bool is_s64vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(int64_t); }
     int64_t ref(size_t k) const;
     void set(size_t k, int64_t x);
     const int64_t* elements(size_t& len);
     int64_t* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -229,16 +229,16 @@ public:
     pmt_f32vector(size_t k, const float* data);
     // ~pmt_f32vector();
 
-    bool is_f32vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(float); }
+    bool is_f32vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(float); }
     float ref(size_t k) const;
     void set(size_t k, float x);
     const float* elements(size_t& len);
     float* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -254,16 +254,16 @@ public:
     pmt_f64vector(size_t k, const double* data);
     // ~pmt_f64vector();
 
-    bool is_f64vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(double); }
+    bool is_f64vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(double); }
     double ref(size_t k) const;
     void set(size_t k, double x);
     const double* elements(size_t& len);
     double* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -279,16 +279,16 @@ public:
     pmt_c32vector(size_t k, const std::complex<float>* data);
     // ~pmt_c32vector();
 
-    bool is_c32vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(std::complex<float>); }
+    bool is_c32vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(std::complex<float>); }
     std::complex<float> ref(size_t k) const;
     void set(size_t k, std::complex<float> x);
     const std::complex<float>* elements(size_t& len);
     std::complex<float>* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -304,16 +304,16 @@ public:
     pmt_c64vector(size_t k, const std::complex<double>* data);
     // ~pmt_c64vector();
 
-    bool is_c64vector() const { return true; }
-    size_t length() const { return d_v.size(); }
-    size_t itemsize() const { return sizeof(std::complex<double>); }
+    bool is_c64vector() const override { return true; }
+    size_t length() const override { return d_v.size(); }
+    size_t itemsize() const override { return sizeof(std::complex<double>); }
     std::complex<double> ref(size_t k) const;
     void set(size_t k, std::complex<double> x);
     const std::complex<double>* elements(size_t& len);
     std::complex<double>* writable_elements(size_t& len);
-    const void* uniform_elements(size_t& len);
-    void* uniform_writable_elements(size_t& len);
-    virtual const std::string string_ref(size_t k) const;
+    const void* uniform_elements(size_t& len) override;
+    void* uniform_writable_elements(size_t& len) override;
+    const std::string string_ref(size_t k) const override;
 };
 } /* namespace pmt */
 #endif
diff --git a/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc b/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc
index e8338bbd50..a1220d7a90 100644
--- a/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc
+++ b/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc
@@ -482,8 +482,8 @@ class qa_pmt_msg_accepter_nop : public gr::messages::msg_accepter
 {
 public:
     qa_pmt_msg_accepter_nop() {}
-    ~qa_pmt_msg_accepter_nop();
-    void post(pmt::pmt_t, pmt::pmt_t) {}
+    ~qa_pmt_msg_accepter_nop() override;
+    void post(pmt::pmt_t, pmt::pmt_t) override {}
 };
 
 qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop() {}
diff --git a/gnuradio-runtime/lib/scheduler_tpb.h b/gnuradio-runtime/lib/scheduler_tpb.h
index aa116d828b..a9c47f86bf 100644
--- a/gnuradio-runtime/lib/scheduler_tpb.h
+++ b/gnuradio-runtime/lib/scheduler_tpb.h
@@ -38,17 +38,17 @@ public:
                                int max_noutput_items = 100000,
                                bool catch_exceptions = true);
 
-    ~scheduler_tpb();
+    ~scheduler_tpb() override;
 
     /*!
      * \brief Tell the scheduler to stop executing.
      */
-    void stop();
+    void stop() override;
 
     /*!
      * \brief Block until the graph is done.
      */
-    void wait();
+    void wait() override;
 };
 
 } /* namespace gr */
diff --git a/gnuradio-runtime/lib/test.h b/gnuradio-runtime/lib/test.h
index 2b8dc78252..7c9842ad4a 100644
--- a/gnuradio-runtime/lib/test.h
+++ b/gnuradio-runtime/lib/test.h
@@ -53,12 +53,12 @@ GR_RUNTIME_API test_sptr make_test(const std::string& name = std::string("test")
 class GR_RUNTIME_API test : public block
 {
 public:
-    ~test() {}
+    ~test() override {}
 
     int general_work(int noutput_items,
                      gr_vector_int& ninput_items,
                      gr_vector_const_void_star& input_items,
-                     gr_vector_void_star& output_items);
+                     gr_vector_void_star& output_items) override;
 
     // ----------------------------------------------------------------
     //		override these to define your behavior
@@ -74,7 +74,7 @@ public:
      * number of data items required on each input stream. The
      * estimate doesn't have to be exact, but should be close.
      */
-    void forecast(int noutput_items, gr_vector_int& ninput_items_required)
+    void forecast(int noutput_items, gr_vector_int& ninput_items_required) override
     {
         unsigned ninputs = ninput_items_required.size();
         for (unsigned i = 0; i < ninputs; i++)
@@ -103,7 +103,7 @@ public:
      * This check is in addition to the constraints specified by the
      * input and output gr::io_signatures.
      */
-    bool check_topology(int ninputs, int noutputs) { return d_check_topology; }
+    bool check_topology(int ninputs, int noutputs) override { return d_check_topology; }
 
     // ----------------------------------------------------------------
     /*
@@ -119,7 +119,7 @@ public:
      * returns true.  Generally speaking, you don't need to override
      * this.
      */
-    int fixed_rate_ninput_to_noutput(int ninput)
+    int fixed_rate_ninput_to_noutput(int ninput) override
     {
         return (int)((double)ninput / relative_rate());
     }
@@ -129,7 +129,7 @@ public:
      * required to produce noutput. N.B. this is only defined if
      * fixed_rate returns true.
      */
-    int fixed_rate_noutput_to_ninput(int noutput)
+    int fixed_rate_noutput_to_ninput(int noutput) override
     {
         return (int)((double)noutput * relative_rate());
     }
diff --git a/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h b/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h
index 505e76938c..fb40937d4e 100644
--- a/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h
+++ b/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h
@@ -29,7 +29,7 @@ class GR_RUNTIME_API vmcircbuf_createfilemapping : public gr::vmcircbuf
 public:
     // CREATORS
     vmcircbuf_createfilemapping(int size);
-    virtual ~vmcircbuf_createfilemapping();
+    ~vmcircbuf_createfilemapping() override;
 #ifdef HAVE_CREATEFILEMAPPING
 private:
     HANDLE d_handle;
@@ -49,19 +49,22 @@ private:
 public:
     static gr::vmcircbuf_factory* singleton();
 
-    virtual const char* name() const { return "gr::vmcircbuf_createfilemapping_factory"; }
+    const char* name() const override
+    {
+        return "gr::vmcircbuf_createfilemapping_factory";
+    }
 
     /*!
      * \brief return granularity of mapping, typically equal to page size
      */
-    virtual int granularity();
+    int granularity() override;
 
     /*!
      * \brief return a gr::vmcircbuf, or 0 if unable.
      *
      * Call this to create a doubly mapped circular buffer.
      */
-    virtual gr::vmcircbuf* make(int size);
+    gr::vmcircbuf* make(int size) override;
 };
 
 } /* namespace gr */
diff --git a/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h b/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h
index ac3a7391ba..ea5460d9f5 100644
--- a/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h
+++ b/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h
@@ -24,7 +24,7 @@ class GR_RUNTIME_API vmcircbuf_mmap_shm_open : public gr::vmcircbuf
 {
 public:
     vmcircbuf_mmap_shm_open(int size);
-    virtual ~vmcircbuf_mmap_shm_open();
+    ~vmcircbuf_mmap_shm_open() override;
 };
 
 /*!
@@ -38,19 +38,19 @@ private:
 public:
     static gr::vmcircbuf_factory* singleton();
 
-    virtual const char* name() const { return "gr::vmcircbuf_mmap_shm_open_factory"; }
+    const char* name() const override { return "gr::vmcircbuf_mmap_shm_open_factory"; }
 
     /*!
      * \brief return granularity of mapping, typically equal to page size
      */
-    virtual int granularity();
+    int granularity() override;
 
     /*!
      * \brief return a gr::vmcircbuf, or 0 if unable.
      *
      * Call this to create a doubly mapped circular buffer.
      */
-    virtual gr::vmcircbuf* make(int size);
+    gr::vmcircbuf* make(int size) override;
 };
 
 } /* namespace gr */
diff --git a/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h b/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h
index d847c53014..326656fa7d 100644
--- a/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h
+++ b/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h
@@ -24,7 +24,7 @@ class GR_RUNTIME_API vmcircbuf_mmap_tmpfile : public gr::vmcircbuf
 {
 public:
     vmcircbuf_mmap_tmpfile(int size);
-    virtual ~vmcircbuf_mmap_tmpfile();
+    ~vmcircbuf_mmap_tmpfile() override;
 };
 
 /*!
@@ -38,19 +38,19 @@ private:
 public:
     static gr::vmcircbuf_factory* singleton();
 
-    virtual const char* name() const { return "gr::vmcircbuf_mmap_tmpfile_factory"; }
+    const char* name() const override { return "gr::vmcircbuf_mmap_tmpfile_factory"; }
 
     /*!
      * \brief return granularity of mapping, typically equal to page size
      */
-    virtual int granularity();
+    int granularity() override;
 
     /*!
      * \brief return a gr::vmcircbuf, or 0 if unable.
      *
      * Call this to create a doubly mapped circular buffer.
      */
-    virtual gr::vmcircbuf* make(int size);
+    gr::vmcircbuf* make(int size) override;
 };
 
 } /* namespace gr */
diff --git a/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h b/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h
index 67530ec4ab..4f20a4618b 100644
--- a/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h
+++ b/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h
@@ -24,7 +24,7 @@ class GR_RUNTIME_API vmcircbuf_sysv_shm : public gr::vmcircbuf
 {
 public:
     vmcircbuf_sysv_shm(int size);
-    virtual ~vmcircbuf_sysv_shm();
+    ~vmcircbuf_sysv_shm() override;
 };
 
 /*!
@@ -38,19 +38,19 @@ private:
 public:
     static gr::vmcircbuf_factory* singleton();
 
-    virtual const char* name() const { return "gr::vmcircbuf_sysv_shm_factory"; }
+    const char* name() const override { return "gr::vmcircbuf_sysv_shm_factory"; }
 
     /*!
      * \brief return granularity of mapping, typically equal to page size
      */
-    virtual int granularity();
+    int granularity() override;
 
     /*!
      * \brief return a gr::vmcircbuf, or 0 if unable.
      *
      * Call this to create a doubly mapped circular buffer.
      */
-    virtual gr::vmcircbuf* make(int size);
+    gr::vmcircbuf* make(int size) override;
 };
 
 } /* namespace gr */
author	Marcus Müller <mmueller@gnuradio.org>	2020-10-30 18:22:33 +0100
committer	mormj <34754695+mormj@users.noreply.github.com>	2020-11-03 14:07:23 -0500
commit	0ddc7dbc95ca6fb4c4a62a3c027104d6dd71fc3b (patch)
tree	b454053fdc123711f3011b8a703de38e1d783ba3 /gnuradio-runtime/lib
parent	1cfd6287635e339b313e1826fdfda23f474c91c8 (diff)