Use CXX11_OVERRIDE

1 files changed, 57 insertions, 49 deletions

diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h
index c7d232ed..f74adf03 100644
--- a/src/UnknownLengthPieceStorage.h
+++ b/src/UnknownLengthPieceStorage.h
@@ -68,45 +68,46 @@ public:
    * Returns true if the peer has a piece that localhost doesn't have.
    * Otherwise returns false.
    */
-  virtual bool hasMissingPiece(const std::shared_ptr<Peer>& peer);
+  virtual bool hasMissingPiece(const std::shared_ptr<Peer>& peer)
+    CXX11_OVERRIDE;
 
   virtual void getMissingPiece
   (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
    const std::shared_ptr<Peer>& peer,
-   cuid_t cuid);
+   cuid_t cuid) CXX11_OVERRIDE;
 
   virtual void getMissingPiece
   (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
    const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
-   cuid_t cuid);
+   cuid_t cuid) CXX11_OVERRIDE;
 
   virtual void getMissingFastPiece
   (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
    const std::shared_ptr<Peer>& peer,
-   cuid_t cuid);
+   cuid_t cuid) CXX11_OVERRIDE;
 
   virtual void getMissingFastPiece
   (std::vector<std::shared_ptr<Piece> >& pieces,
    size_t minMissingBlocks,
    const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
-   cuid_t cuid);
+   cuid_t cuid) CXX11_OVERRIDE;
 
   virtual std::shared_ptr<Piece> getMissingPiece
   (const std::shared_ptr<Peer>& peer,
-   cuid_t cuid);
+   cuid_t cuid) CXX11_OVERRIDE;
 
   virtual std::shared_ptr<Piece> getMissingPiece
   (const std::shared_ptr<Peer>& peer,
    const std::vector<size_t>& excludedIndexes,
-   cuid_t cuid);
+   cuid_t cuid) CXX11_OVERRIDE;
 #endif // ENABLE_BITTORRENT
 
-  virtual bool hasMissingUnusedPiece();
+  virtual bool hasMissingUnusedPiece() CXX11_OVERRIDE;
 
   /**
    * Returns a missing piece if available. Otherwise returns 0;
@@ -115,7 +116,7 @@ public:
   (size_t minSplitSize,
    const unsigned char* ignoreBitfield,
    size_t length,
-   cuid_t cuid);
+   cuid_t cuid) CXX11_OVERRIDE;
 
   /**
    * Returns a missing piece whose index is index.
@@ -123,63 +124,66 @@ public:
    * then returns 0.
    * Also returns 0 if any of missing piece is not available.
    */
-  virtual std::shared_ptr<Piece> getMissingPiece(size_t index, cuid_t cuid);
+  virtual std::shared_ptr<Piece> getMissingPiece(size_t index, cuid_t cuid)
+    CXX11_OVERRIDE;
 
   /**
    * Returns the piece denoted by index.
    * No status of the piece is changed in this method.
    */
-  virtual std::shared_ptr<Piece> getPiece(size_t index);
+  virtual std::shared_ptr<Piece> getPiece(size_t index) CXX11_OVERRIDE;
 
   /**
    * Tells that the download of the specfied piece completes.
    */
-  virtual void completePiece(const std::shared_ptr<Piece>& piece);
+  virtual void completePiece(const std::shared_ptr<Piece>& piece)
+    CXX11_OVERRIDE;
 
   /**
    * Tells that the download of the specified piece is canceled.
    */
-  virtual void cancelPiece(const std::shared_ptr<Piece>& piece, cuid_t cuid);
+  virtual void cancelPiece(const std::shared_ptr<Piece>& piece, cuid_t cuid)
+    CXX11_OVERRIDE;
 
   /**
    * Returns true if the specified piece is already downloaded.
    * Otherwise returns false.
    */
-  virtual bool hasPiece(size_t index);
+  virtual bool hasPiece(size_t index) CXX11_OVERRIDE;
 
-  virtual bool isPieceUsed(size_t index);
+  virtual bool isPieceUsed(size_t index) CXX11_OVERRIDE;
 
-  virtual int64_t getTotalLength()
+  virtual int64_t getTotalLength() CXX11_OVERRIDE
   {
     return totalLength_;
   }
 
-  virtual int64_t getFilteredTotalLength()
+  virtual int64_t getFilteredTotalLength() CXX11_OVERRIDE
   {
     return totalLength_;
   }
 
-  virtual int64_t getCompletedLength()
+  virtual int64_t getCompletedLength() CXX11_OVERRIDE
   {
     // TODO we have to return actual completed length here?
     return totalLength_;
   }
 
-  virtual int64_t getFilteredCompletedLength()
+  virtual int64_t getFilteredCompletedLength() CXX11_OVERRIDE
   {
     return getCompletedLength();
   }
 
-  virtual void setupFileFilter() {}
+  virtual void setupFileFilter() CXX11_OVERRIDE {}
 
-  virtual void clearFileFilter() {}
+  virtual void clearFileFilter() CXX11_OVERRIDE {}
 
   /**
    * Returns true if download has completed.
    * If file filter is enabled, then returns true if those files have
    * downloaded.
    */
-  virtual bool downloadFinished()
+  virtual bool downloadFinished() CXX11_OVERRIDE
   {
     return downloadFinished_;
   }
@@ -188,7 +192,7 @@ public:
    * Returns true if all files have downloaded.
    * The file filter is ignored.
    */
-  virtual bool allDownloadFinished()
+  virtual bool allDownloadFinished() CXX11_OVERRIDE
   {
     return downloadFinished();
   }
@@ -197,48 +201,48 @@ public:
    * Initializes DiskAdaptor.
    * TODO add better documentation here.
    */
-  virtual void initStorage();
+  virtual void initStorage() CXX11_OVERRIDE;
 
-  virtual const unsigned char* getBitfield()
+  virtual const unsigned char* getBitfield() CXX11_OVERRIDE
   {
     return 0;
   }
 
   virtual void setBitfield(const unsigned char* bitfield,
-                           size_t bitfieldLength) {}
+                           size_t bitfieldLength) CXX11_OVERRIDE {}
 
-  virtual size_t getBitfieldLength()
+  virtual size_t getBitfieldLength() CXX11_OVERRIDE
   {
     return 0;
   }
 
-  virtual bool isSelectiveDownloadingMode()
+  virtual bool isSelectiveDownloadingMode() CXX11_OVERRIDE
   {
     return false;
   }
 
-  virtual bool isEndGame()
+  virtual bool isEndGame() CXX11_OVERRIDE
   {
     return false;
   }
 
-  virtual void enterEndGame() {}
+  virtual void enterEndGame() CXX11_OVERRIDE {}
 
-  virtual void setEndGamePieceNum(size_t num) {}
+  virtual void setEndGamePieceNum(size_t num) CXX11_OVERRIDE {}
 
-  virtual std::shared_ptr<DiskAdaptor> getDiskAdaptor();
+  virtual std::shared_ptr<DiskAdaptor> getDiskAdaptor() CXX11_OVERRIDE;
 
-  virtual WrDiskCache* getWrDiskCache() { return 0; }
+  virtual WrDiskCache* getWrDiskCache() CXX11_OVERRIDE { return 0; }
 
-  virtual void flushWrDiskCacheEntry() {}
+  virtual void flushWrDiskCacheEntry() CXX11_OVERRIDE {}
 
-  virtual int32_t getPieceLength(size_t index);
+  virtual int32_t getPieceLength(size_t index) CXX11_OVERRIDE;
 
   /**
    * Adds piece index to advertise to other commands. They send have message
    * based on this information.
    */
-  virtual void advertisePiece(cuid_t cuid, size_t index) {}
+  virtual void advertisePiece(cuid_t cuid, size_t index) CXX11_OVERRIDE {}
 
   /**
    * Returns piece index which is not advertised by the caller command and
@@ -247,54 +251,58 @@ public:
   virtual void
   getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                             cuid_t myCuid, const Timer& lastCheckTime)
+    CXX11_OVERRIDE
   {}
 
   /**
    * Removes have entry if specified seconds have elapsed since its
    * registration.
    */
-  virtual void removeAdvertisedPiece(time_t elapsed) {}
+  virtual void removeAdvertisedPiece(time_t elapsed) CXX11_OVERRIDE {}
 
   /**
    * Sets all bits in bitfield to 1.
    */
-  virtual void markAllPiecesDone();
+  virtual void markAllPiecesDone() CXX11_OVERRIDE;
 
-  virtual void markPiecesDone(int64_t length);
+  virtual void markPiecesDone(int64_t length) CXX11_OVERRIDE;
 
-  virtual void markPieceMissing(size_t index);
+  virtual void markPieceMissing(size_t index) CXX11_OVERRIDE;
 
   /**
    * Do nothing because loading in-flight piece is not supported for this
    * class.
    */
   virtual void addInFlightPiece
-  (const std::vector<std::shared_ptr<Piece> >& pieces) {}
+  (const std::vector<std::shared_ptr<Piece> >& pieces) CXX11_OVERRIDE {}
 
-  virtual size_t countInFlightPiece()
+  virtual size_t countInFlightPiece() CXX11_OVERRIDE
   {
     return 0;
   }
 
-  virtual void getInFlightPieces(std::vector<std::shared_ptr<Piece> >& pieces);
+  virtual void getInFlightPieces(std::vector<std::shared_ptr<Piece> >& pieces)
+    CXX11_OVERRIDE;
 
-  virtual void addPieceStats(size_t index) {}
+  virtual void addPieceStats(size_t index) CXX11_OVERRIDE {}
 
   virtual void addPieceStats(const unsigned char* bitfield,
-                             size_t bitfieldLength) {}
+                             size_t bitfieldLength) CXX11_OVERRIDE {}
 
   virtual void subtractPieceStats(const unsigned char* bitfield,
-                                  size_t bitfieldLength) {}
+                                  size_t bitfieldLength) CXX11_OVERRIDE {}
 
   virtual void updatePieceStats(const unsigned char* newBitfield,
                                 size_t newBitfieldLength,
-                                const unsigned char* oldBitfield) {}
+                                const unsigned char* oldBitfield)
+    CXX11_OVERRIDE
+  {}
 
-  virtual size_t getNextUsedIndex(size_t index) { return 0; }
+  virtual size_t getNextUsedIndex(size_t index) CXX11_OVERRIDE { return 0; }
 
   void setDiskWriterFactory(const std::shared_ptr<DiskWriterFactory>& diskWriterFactory);
 
-  virtual void onDownloadIncomplete() {}
+  virtual void onDownloadIncomplete() CXX11_OVERRIDE {}
 };
 
 } // namespace aria2