Rename from_* methods to overloaded hash method

Author: mikedld

include/haval.h

@@ -83,11 +83,11 @@ class haval
     std::string end();
 
     // hash a block
-    static std::string from_data(const void* data, size_type data_len);
+    static std::string hash(const void* data, size_type data_len);
     // hash a string
-    static std::string from_string(const std::string& data);
+    static std::string hash(const std::string& data);
     // hash a stream
-    static std::string from_stream(std::istream& stream);
+    static std::string hash(std::istream& stream);
 
 private:
     void hash_block();

include/haval.hpp

@@ -731,7 +731,7 @@ void haval<pass_cnt, fpt_len>::hash_block()
 
 // hash a block
 template<unsigned int pass_cnt, unsigned int fpt_len>
-std::string haval<pass_cnt, fpt_len>::from_data(const void* data, size_type data_len)
+std::string haval<pass_cnt, fpt_len>::hash(const void* data, size_type data_len)
 {
     haval<pass_cnt, fpt_len> context;
     context.start();
@@ -741,14 +741,14 @@ std::string haval<pass_cnt, fpt_len>::from_data(const void* data, size_type data
 
 // hash a string
 template<unsigned int pass_cnt, unsigned int fpt_len>
-std::string haval<pass_cnt, fpt_len>::from_string(const std::string& data)
+std::string haval<pass_cnt, fpt_len>::hash(const std::string& data)
 {
-    return from_data(data.data(), data.size());
+    return hash(data.data(), data.size());
 }
 
 // hash a stream
 template<unsigned int pass_cnt, unsigned int fpt_len>
-std::string haval<pass_cnt, fpt_len>::from_stream(std::istream& stream)
+std::string haval<pass_cnt, fpt_len>::hash(std::istream& stream)
 {
     haval<pass_cnt, fpt_len> context;
     context.start();

src/havalapp.cpp

@@ -131,11 +131,11 @@ void usage(unsigned int pass_cnt, unsigned int fpt_len)
 template<unsigned int pass_cnt, unsigned int fpt_len>
 int main_impl(int argc, char* argv[])
 {
-    using hash = haval::haval<pass_cnt, fpt_len>;
+    using hasher = haval::haval<pass_cnt, fpt_len>;
 
     if (argc <= 1) {
         // filter
-        std::cout << to_hex(hash::from_stream(std::cin)) << std::endl;
+        std::cout << to_hex(hasher::hash(std::cin)) << std::endl;
     }
 
     for (int i = 1; i < argc; i++) {
@@ -147,7 +147,7 @@ int main_impl(int argc, char* argv[])
         } else if (arg.compare(0, 2, "-m") == 0) {
             // hash string
             const std::string data = arg.substr(2);
-            std::cout << "HAVAL(" << std::quoted(data) << ") = " << to_hex(hash::from_string(data)) << std::endl;
+            std::cout << "HAVAL(" << std::quoted(data) << ") = " << to_hex(hasher::hash(data)) << std::endl;
         } else if (arg == "-s") {
             // test speed
             haval_speed<pass_cnt, fpt_len>();
@@ -166,7 +166,7 @@ int main_impl(int argc, char* argv[])
             if (!f.good()) {
                 std::cout << arg << " can not be opened !" << std::endl;
             } else {
-                std::cout << "HAVAL(" << arg << ") = " << to_hex(hash::from_stream(f)) << std::endl;
+                std::cout << "HAVAL(" << arg << ") = " << to_hex(hasher::hash(f)) << std::endl;
             }
         }
     }

test/havaltest.cpp

@@ -73,20 +73,20 @@ void verify_result(const char* data, const std::string& got_str, const char* exp
     std::cout << std::endl;
 }
 
-template<typename hash>
+template<typename hasher>
 void test_string(const char* data, const char* result)
 {
-    verify_result(data, hash::from_string(data), result, 0);
+    verify_result(data, hasher::hash(data), result, 0);
 }
 
-template<typename hash>
+template<typename hasher>
 void test_file(const char* filename, const char* result)
 {
     std::ifstream f(filename, std::ios::in | std::ios::binary);
     if (!f.good()) {
         std::cout << filename << " cannot be opened! Skipping test..." << std::endl;
     } else {
-        verify_result(filename, hash::from_stream(f), result, 1);
+        verify_result(filename, hasher::hash(f), result, 1);
     }
 }
 
@@ -101,18 +101,18 @@ void test(
         const char* result6,
         const char* result7)
 {
-    using hash = haval::haval<pass_cnt, fpt_len>;
+    using hasher = haval::haval<pass_cnt, fpt_len>;
 
     std::cout << "HAVAL certification data (PASS=" << pass_cnt << ", FPTLEN=" << fpt_len << "):" << std::endl;
 
-    test_string<hash>("", result1);
-    test_string<hash>("a", result2);
-    test_string<hash>("HAVAL", result3);
-    test_string<hash>("0123456789", result4);
-    test_string<hash>("abcdefghijklmnopqrstuvwxyz", result5);
-    test_string<hash>("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", result6);
+    test_string<hasher>("", result1);
+    test_string<hasher>("a", result2);
+    test_string<hasher>("HAVAL", result3);
+    test_string<hasher>("0123456789", result4);
+    test_string<hasher>("abcdefghijklmnopqrstuvwxyz", result5);
+    test_string<hasher>("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", result6);
 
-    test_file<hash>("pi.frac", result7);
+    test_file<hasher>("pi.frac", result7);
 
     std::cout << std::endl;
 }