Use override

2 files changed, 38 insertions, 20 deletions

diff --git a/staging_vespalib/src/vespa/vespalib/objects/identifiable.h b/staging_vespalib/src/vespa/vespalib/objects/identifiable.h
index 5d68c781046..93953847814 100644
--- a/staging_vespalib/src/vespa/vespalib/objects/identifiable.h
+++ b/staging_vespalib/src/vespa/vespalib/objects/identifiable.h
@@ -16,11 +16,6 @@
  *
  */
 
-#include <string>
-#include <vector>
-#include <memory>
-#include <typeinfo>
-
 #define CID_Identifiable 1
 
 #include "ids.h"
@@ -34,12 +29,19 @@
 #define IDENTIFIABLE_CLASSID_NS2(ns1, ns2, cclass) CID_##ns1##_##ns2##_##cclass
 #define IDENTIFIABLE_CLASSID_NS3(ns1, ns2, ns3, cclass) CID_##ns1##_##ns2##_##ns3##_##cclass
 
-#define DECLARE_IDENTIFIABLE_BASE_COMMON(cclass) \
+#define DECLARE_IDENTIFIABLE_STATIC_BASE_COMMON(cclass) \
   static  vespalib::Identifiable::RuntimeInfo  _RTInfo; \
   static  vespalib::Identifiable::RuntimeClass _RTClass; \
   static const std::type_info & typeId() { return typeid(cclass); } \
   static bool tryCast(const vespalib::Identifiable * v) { return dynamic_cast<const cclass *>(v) != NULL; } \
-  static cclass *identifyClassAsIdentifiable() { return NULL; } /* no implementation */ \
+  static cclass *identifyClassAsIdentifiable() { return NULL; } /* no implementation */
+
+#define DECLARE_IDENTIFIABLE_BASE_COMMON(cclass) \
+  DECLARE_IDENTIFIABLE_STATIC_BASE_COMMON(cclass) \
+  const vespalib::Identifiable::RuntimeClass & getClass() const override;
+
+#define DECLARE_IDENTIFIABLE_BASE_COMMON_ROOT(cclass) \
+  DECLARE_IDENTIFIABLE_STATIC_BASE_COMMON(cclass) \
   virtual const vespalib::Identifiable::RuntimeClass & getClass() const;
 
 #define DECLARE_IDENTIFIABLE_BASE(cclass, classid) \
@@ -47,20 +49,36 @@
    enum { classId=classid };                       \
   DECLARE_IDENTIFIABLE_BASE_COMMON(cclass)
 
+#define DECLARE_IDENTIFIABLE_BASE_ROOT(cclass, classid) \
+  public:                                          \
+   enum { classId=classid };                       \
+  DECLARE_IDENTIFIABLE_BASE_COMMON_ROOT(cclass)
+
 #define DECLARE_IDENTIFIABLE_ABSTRACT(cclass)               DECLARE_IDENTIFIABLE_BASE(cclass, IDENTIFIABLE_CLASSID(cclass))
 #define DECLARE_IDENTIFIABLE_ABSTRACT_NS(ns, cclass)        DECLARE_IDENTIFIABLE_BASE(ns::cclass, IDENTIFIABLE_CLASSID_NS(ns, cclass))
 #define DECLARE_IDENTIFIABLE_ABSTRACT_NS2(ns1, ns2, cclass) DECLARE_IDENTIFIABLE_BASE(ns1::ns2::cclass, IDENTIFIABLE_CLASSID_NS2(ns1, ns2, cclass))
 #define DECLARE_IDENTIFIABLE_ABSTRACT_NS3(ns1, ns2, ns3, cclass) DECLARE_IDENTIFIABLE_BASE(ns1::ns2::ns3::cclass, IDENTIFIABLE_CLASSID_NS3(ns1, ns2, ns3, cclass))
 
-#define DECLARE_IDENTIFIABLE_COMMON(cclass)                                      \
-  virtual void assign(const vespalib::Identifiable & rhs);                      \
+#define DECLARE_IDENTIFIABLE_STATIC_COMMON(cclass)                               \
   static cclass *       create()               { return new cclass(); }          \
   static Identifiable * createAsIdentifiable() { return cclass::create(); }
 
+#define DECLARE_IDENTIFIABLE_COMMON(cclass)                  \
+  void assign(const vespalib::Identifiable & rhs) override;  \
+  DECLARE_IDENTIFIABLE_STATIC_COMMON(cclass)
+
+#define DECLARE_IDENTIFIABLE_COMMON_ROOT(cclass)            \
+  virtual void assign(const vespalib::Identifiable & rhs);  \
+  DECLARE_IDENTIFIABLE_STATIC_COMMON(cclass)
+
 #define DECLARE_IDENTIFIABLE(cclass)                                             \
   DECLARE_IDENTIFIABLE_BASE(cclass, IDENTIFIABLE_CLASSID(cclass))                \
   DECLARE_IDENTIFIABLE_COMMON(cclass)
 
+#define DECLARE_IDENTIFIABLE_ROOT(cclass)                                             \
+  DECLARE_IDENTIFIABLE_BASE_ROOT(cclass, IDENTIFIABLE_CLASSID(cclass))                \
+  DECLARE_IDENTIFIABLE_COMMON_ROOT(cclass)
+
 #define DECLARE_IDENTIFIABLE_NS(ns, cclass)                                      \
   DECLARE_IDENTIFIABLE_BASE(ns::cclass, IDENTIFIABLE_CLASSID_NS(ns, cclass))     \
   DECLARE_IDENTIFIABLE_COMMON(ns::cclass)
@@ -171,7 +189,7 @@ public:
         stringref getName() const override { return stringref(_rt->_name); }
         RuntimeInfo * _rt;
     };
-    DECLARE_IDENTIFIABLE(Identifiable);
+    DECLARE_IDENTIFIABLE_ROOT(Identifiable);
     Identifiable() { }
     Identifiable(Identifiable &&) = default;
     Identifiable & operator = (Identifiable &&) = default;
diff --git a/staging_vespalib/src/vespa/vespalib/util/polymorphicarrays.h b/staging_vespalib/src/vespa/vespalib/util/polymorphicarrays.h
index f57cd84c91a..696c55f9ae3 100644
--- a/staging_vespalib/src/vespa/vespalib/util/polymorphicarrays.h
+++ b/staging_vespalib/src/vespa/vespalib/util/polymorphicarrays.h
@@ -109,10 +109,10 @@ public:
         virtual ~Factory() { }
     };
     explicit ComplexArrayT(typename Factory::UP factory) : _array(), _factory(factory.release()) { }
-    virtual ~ComplexArrayT() { }
-    virtual const B & operator [] (size_t i) const { return *_array[i]; }
-    virtual B & operator [] (size_t i) { return *_array[i]; }
-    virtual void resize(size_t sz) {
+    ~ComplexArrayT() { }
+    const B & operator [] (size_t i) const override { return *_array[i]; }
+    B & operator [] (size_t i) override { return *_array[i]; }
+    void resize(size_t sz) override {
         _array.resize(sz);
         for (auto & cp : _array) {
             if ( cp.get() == nullptr) {
@@ -120,12 +120,12 @@ public:
             }
         }
     }
-    virtual void reserve(size_t sz) { _array.reserve(sz); }
-    virtual void clear() { _array.clear(); }
-    virtual IArrayT<B> * clone() const { return new ComplexArrayT<B>(*this); }
-    virtual size_t size() const { return _array.size(); }
-    virtual iterator erase(iterator it)  { _array.erase(_array.begin() + (it - this->begin())); return it; }
-    virtual void push_back(const B & v) { _array.push_back(v.clone()); }
+    void reserve(size_t sz) override { _array.reserve(sz); }
+    void clear() override { _array.clear(); }
+    IArrayT<B> * clone() const override { return new ComplexArrayT<B>(*this); }
+    size_t size() const override { return _array.size(); }
+    iterator erase(iterator it) override  { _array.erase(_array.begin() + (it - this->begin())); return it; }
+    void push_back(const B & v) override { _array.push_back(v.clone()); }
 private:
     typedef vespalib::CloneablePtr<B> CP;
     std::vector<CP> _array;