Remove vbegin and vend in favor of std::begin and std::end

10 files changed, 49 insertions, 53 deletions

diff --git a/src/HttpHeader.cc b/src/HttpHeader.cc
index 4f046fce..33a4ea43 100644
--- a/src/HttpHeader.cc
+++ b/src/HttpHeader.cc
@@ -273,11 +273,11 @@ const char* INTERESTING_HEADER_NAMES[] = {
 
 int idInterestingHeader(const char* hdName)
 {
-  const char** i = std::lower_bound(vbegin(INTERESTING_HEADER_NAMES),
-                                    vend(INTERESTING_HEADER_NAMES),
+  const char** i = std::lower_bound(std::begin(INTERESTING_HEADER_NAMES),
+                                    std::end(INTERESTING_HEADER_NAMES),
                                     hdName, util::strless);
-  if(i != vend(INTERESTING_HEADER_NAMES) && strcmp(*i, hdName) == 0 ) {
-    return i - vbegin(INTERESTING_HEADER_NAMES);
+  if(i != std::end(INTERESTING_HEADER_NAMES) && strcmp(*i, hdName) == 0 ) {
+    return i - std::begin(INTERESTING_HEADER_NAMES);
   } else {
     return HttpHeader::MAX_INTERESTING_HEADER;
   }
diff --git a/src/LibgcryptMessageDigestImpl.cc b/src/LibgcryptMessageDigestImpl.cc
index 23ae1389..4460c684 100644
--- a/src/LibgcryptMessageDigestImpl.cc
+++ b/src/LibgcryptMessageDigestImpl.cc
@@ -73,19 +73,22 @@ CHashFuncEntry hashFuncs[] = {
 std::shared_ptr<MessageDigestImpl> MessageDigestImpl::create
 (const std::string& hashType)
 {
-  int hashFunc = getHashFunc(vbegin(hashFuncs), vend(hashFuncs), hashType);
+  int hashFunc = getHashFunc(std::begin(hashFuncs), std::end(hashFuncs),
+                             hashType);
   return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(hashFunc));
 }
 
 bool MessageDigestImpl::supports(const std::string& hashType)
 {
-  return vend(hashFuncs) != std::find_if(vbegin(hashFuncs), vend(hashFuncs),
-                                         CFindHashFunc(hashType));
+  return std::end(hashFuncs) != std::find_if(std::begin(hashFuncs),
+                                             std::end(hashFuncs),
+                                             CFindHashFunc(hashType));
 }
 
 size_t MessageDigestImpl::getDigestLength(const std::string& hashType)
 {
-  int hashFunc = getHashFunc(vbegin(hashFuncs), vend(hashFuncs), hashType);
+  int hashFunc = getHashFunc(std::begin(hashFuncs), std::end(hashFuncs),
+                             hashType);
   return gcry_md_get_algo_dlen(hashFunc);
 }
 
diff --git a/src/LibnettleMessageDigestImpl.cc b/src/LibnettleMessageDigestImpl.cc
index 5f49648d..9919ffcd 100644
--- a/src/LibnettleMessageDigestImpl.cc
+++ b/src/LibnettleMessageDigestImpl.cc
@@ -76,20 +76,21 @@ std::shared_ptr<MessageDigestImpl> MessageDigestImpl::create
 (const std::string& hashType)
 {
   const nettle_hash* hashInfo =
-    getHashFunc(vbegin(hashFuncs), vend(hashFuncs), hashType);
+    getHashFunc(std::begin(hashFuncs), std::end(hashFuncs), hashType);
   return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(hashInfo));
 }
 
 bool MessageDigestImpl::supports(const std::string& hashType)
 {
-  return vend(hashFuncs) != std::find_if(vbegin(hashFuncs), vend(hashFuncs),
-                                         CFindHashFunc(hashType));
+  return std::end(hashFuncs) != std::find_if(std::begin(hashFuncs),
+                                             std::end(hashFuncs),
+                                             CFindHashFunc(hashType));
 }
 
 size_t MessageDigestImpl::getDigestLength(const std::string& hashType)
 {
   const nettle_hash* hashInfo =
-    getHashFunc(vbegin(hashFuncs), vend(hashFuncs), hashType);
+    getHashFunc(std::begin(hashFuncs), std::end(hashFuncs), hashType);
   return hashInfo->digest_size;
 }
 
diff --git a/src/LibsslMessageDigestImpl.cc b/src/LibsslMessageDigestImpl.cc
index 8a024041..00f7f596 100644
--- a/src/LibsslMessageDigestImpl.cc
+++ b/src/LibsslMessageDigestImpl.cc
@@ -82,20 +82,23 @@ CHashFuncEntry hashFuncs[] = {
 std::shared_ptr<MessageDigestImpl> MessageDigestImpl::create
 (const std::string& hashType)
 {
-  const EVP_MD* hashFunc = getHashFunc(vbegin(hashFuncs), vend(hashFuncs),
+  const EVP_MD* hashFunc = getHashFunc(std::begin(hashFuncs),
+                                       std::end(hashFuncs),
                                        hashType);
   return std::shared_ptr<MessageDigestImpl>(new MessageDigestImpl(hashFunc));
 }
 
 bool MessageDigestImpl::supports(const std::string& hashType)
 {
-  return vend(hashFuncs) != std::find_if(vbegin(hashFuncs), vend(hashFuncs),
-                                         CFindHashFunc(hashType));
+  return std::end(hashFuncs) != std::find_if(std::begin(hashFuncs),
+                                             std::end(hashFuncs),
+                                             CFindHashFunc(hashType));
 }
 
 size_t MessageDigestImpl::getDigestLength(const std::string& hashType)
 {
-  const EVP_MD* hashFunc = getHashFunc(vbegin(hashFuncs), vend(hashFuncs),
+  const EVP_MD* hashFunc = getHashFunc(std::begin(hashFuncs),
+                                       std::end(hashFuncs),
                                        hashType);
   return EVP_MD_size(hashFunc);
 }
diff --git a/src/MessageDigest.cc b/src/MessageDigest.cc
index 1acb0b8b..e4557f8c 100644
--- a/src/MessageDigest.cc
+++ b/src/MessageDigest.cc
@@ -91,10 +91,9 @@ bool MessageDigest::supports(const std::string& hashType)
 std::vector<std::string> MessageDigest::getSupportedHashTypes()
 {
   std::vector<std::string> rv;
-  for (HashTypeEntry *i = vbegin(hashTypes), *eoi = vend(hashTypes);
-       i != eoi; ++i) {
-    if (MessageDigestImpl::supports(i->hashType)) {
-      rv.push_back(i->hashType);
+  for (const auto& i : hashTypes) {
+    if (MessageDigestImpl::supports(i.hashType)) {
+      rv.push_back(i.hashType);
     }
   }
   return rv;
@@ -134,11 +133,13 @@ public:
 
 bool MessageDigest::isStronger(const std::string& lhs, const std::string& rhs)
 {
-  HashTypeEntry* lEntry = std::find_if(vbegin(hashTypes), vend(hashTypes),
+  HashTypeEntry* lEntry = std::find_if(std::begin(hashTypes),
+                                       std::end(hashTypes),
                                        FindHashTypeEntry(lhs));
-  HashTypeEntry* rEntry = std::find_if(vbegin(hashTypes), vend(hashTypes),
+  HashTypeEntry* rEntry = std::find_if(std::begin(hashTypes),
+                                       std::end(hashTypes),
                                        FindHashTypeEntry(rhs));
-  if(lEntry == vend(hashTypes) || rEntry == vend(hashTypes)) {
+  if(lEntry == std::end(hashTypes) || rEntry == std::end(hashTypes)) {
     return false;
   }
   return lEntry->strength > rEntry->strength;
diff --git a/src/OptionHandlerFactory.cc b/src/OptionHandlerFactory.cc
index 57b052d1..aa4809fb 100644
--- a/src/OptionHandlerFactory.cc
+++ b/src/OptionHandlerFactory.cc
@@ -220,8 +220,7 @@ std::vector<OptionHandler*> OptionHandlerFactory::createOptionHandlers()
                       (PREF_CONSOLE_LOG_LEVEL,
                        TEXT_CONSOLE_LOG_LEVEL,
                        V_NOTICE,
-                       std::vector<std::string>
-                       (vbegin(logLevels), vend(logLevels))));
+                       {std::begin(logLevels), std::end(logLevels)}));
     op->addTag(TAG_ADVANCED);
     handlers.push_back(op);
   }
@@ -479,8 +478,7 @@ std::vector<OptionHandler*> OptionHandlerFactory::createOptionHandlers()
                       (PREF_LOG_LEVEL,
                        TEXT_LOG_LEVEL,
                        V_DEBUG,
-                       std::vector<std::string>
-                       (vbegin(logLevels), vend(logLevels))));
+                       {std::begin(logLevels), std::end(logLevels)}));
     op->addTag(TAG_ADVANCED);
     op->setChangeGlobalOption(true);
     handlers.push_back(op);
diff --git a/src/TimeA2.cc b/src/TimeA2.cc
index 0410cb5d..836b7e58 100644
--- a/src/TimeA2.cc
+++ b/src/TimeA2.cc
@@ -226,9 +226,8 @@ Time Time::parseHTTPDate(const std::string& datetime)
     &parseAsctime,
     &parseRFC850Ext,
   };
-  for(Time (**funcsp)(const std::string&) = &funcs[0];
-      funcsp != vend(funcs); ++funcsp) {
-    Time t = (*funcsp)(datetime);
+  for(auto func : funcs) {
+    Time t = func(datetime);
     if(t.good()) {
       return t;
     }
diff --git a/src/array_fun.h b/src/array_fun.h
index b2b1cb7c..ed562ed8 100644
--- a/src/array_fun.h
+++ b/src/array_fun.h
@@ -53,18 +53,6 @@ char (&char_array_ref_fun(T (&)[0u]))[0u];
 // To calculate size of array at compile time, we use macro here.
 #define A2_ARRAY_LEN(X) sizeof(char_array_ref_fun(X))
 
-template<typename T, size_t N>
-T* vbegin(T (&a)[N])
-{
-  return a;
-}
-
-template<typename T, size_t N>
-T* vend(T (&a)[N])
-{
-  return a+N;
-}
-
 template<typename T>
 class array_ptr {
 private:
diff --git a/src/help_tags.cc b/src/help_tags.cc
index 9b32729f..e61e79b5 100644
--- a/src/help_tags.cc
+++ b/src/help_tags.cc
@@ -71,11 +71,12 @@ const char* strHelpTag(uint32_t tag)
 
 uint32_t idHelpTag(const char* tagName)
 {
-  for(const char** p = vbegin(HELP_TAG_NAMES), ** eop = vend(HELP_TAG_NAMES);
-      p != eop; ++p) {
-    if(strcmp(*p, tagName) == 0) {
-      return p - vbegin(HELP_TAG_NAMES);
+  uint32_t id = 0;
+  for(auto p : HELP_TAG_NAMES) {
+    if(strcmp(p, tagName) == 0) {
+      return id;
     }
+    ++id;
   }
   return MAX_HELP_TAG;
 }
diff --git a/src/util.cc b/src/util.cc
index ae348fef..d5a3463f 100644
--- a/src/util.cc
+++ b/src/util.cc
@@ -295,14 +295,16 @@ bool inRFC3986ReservedChars(const char c)
     ':' , '/' , '?' , '#' , '[' , ']' , '@',
     '!' , '$' , '&' , '\'' , '(' , ')',
     '*' , '+' , ',' , ';' , '=' };
-  return std::find(vbegin(reserved), vend(reserved), c) != vend(reserved);
+  return std::find(std::begin(reserved), std::end(reserved), c)
+    != std::end(reserved);
 }
 
 bool inRFC3986UnreservedChars(const char c)
 {
   static const char unreserved[] = { '-', '.', '_', '~' };
   return isAlpha(c) || isDigit(c) ||
-    std::find(vbegin(unreserved), vend(unreserved), c) != vend(unreserved);
+    std::find(std::begin(unreserved), std::end(unreserved), c)
+    != std::end(unreserved);
 }
 
 bool inRFC2978MIMECharset(const char c)
@@ -313,7 +315,7 @@ bool inRFC2978MIMECharset(const char c)
     '`', '{', '}', '~'
   };
   return isAlpha(c) || isDigit(c) ||
-    std::find(vbegin(chars), vend(chars), c) != vend(chars);
+    std::find(std::begin(chars), std::end(chars), c) != std::end(chars);
 }
 
 bool inRFC2616HttpToken(const char c)
@@ -323,7 +325,7 @@ bool inRFC2616HttpToken(const char c)
     '^', '_', '`', '|', '~'
   };
   return isAlpha(c) || isDigit(c) ||
-    std::find(vbegin(chars), vend(chars), c) != vend(chars);
+    std::find(std::begin(chars), std::end(chars), c) != std::end(chars);
 }
 
 bool inRFC5987AttrChar(const char c)
@@ -1663,9 +1665,9 @@ std::string escapePath(const std::string& s)
     unsigned char c = *i;
     if(in(c, 0x00u, 0x1fu) || c == 0x7fu
 #ifdef __MINGW32__
-       || std::find(vbegin(WIN_INVALID_PATH_CHARS),
-                    vend(WIN_INVALID_PATH_CHARS),
-                    c) != vend(WIN_INVALID_PATH_CHARS)
+       || std::find(std::begin(WIN_INVALID_PATH_CHARS),
+                    std::end(WIN_INVALID_PATH_CHARS),
+                    c) != std::end(WIN_INVALID_PATH_CHARS)
 #endif // __MINGW32__
        ){
       d += fmt("%%%02X", c);