botan学习之二

1.typedef std::unordered_map<std::string, std::string> VarMap;  

unordered_map和map类似，都是存储的key-value的值，可以通过key快速索引到value。不同的是unordered_map不会根据key的大小进行排序，

存储时是根据key的hash值判断元素是否相同，即unordered_map内部元素是无序的，而map中的元素是按照二叉搜索树存储，进行中序遍历会得到有序遍历。

所以使用时map的key需要定义operator<。而unordered_map需要定义hash_value函数并且重载operator==。但是很多系统内置的数据类型都自带这些，

那么如果是自定义类型，那么就需要自己重载operator<或者hash_value()了。

结论：如果需要内部元素自动排序，使用map，不需要排序使用unordered_map

2. std::vector<uint8_t> Text_Based_Test::get_req_bin(const VarMap& vars,
      const std::string& key) const
   {
   auto i = vars.find(key);
   if(i == vars.end())
      {
      throw Test_Error("Test missing variable " + key);
      }

   try
      {
      return Botan::hex_decode(i->second);
      }
   catch(std::exception&)
      {
      throw Test_Error("Test invalid hex input '" + i->second + "'" +
                       + " for key " + key);
      }

   }

1 遍历map 找到需要的key；

2 auto

3 try catch 会返回执行 Botan：：hex——decode（）遇到的错误

3.  explicit 防止隐式转换，要使用固定的构造函数进行实例化

4. std::vector<std::string> Test::possible_providers(const std::string&)
   {
   return Test::provider_filter({ "base" });

   }

std::vector<std::string> Provider_Filter::filter(const std::vector<std::string>& in) const
   {
   if(m_provider.empty())
      {
      return in;
      }
   for(auto&& provider : in)
      {
      if(provider == m_provider)
         {
         return std::vector<std::string> { provider };
         }
      }
   return std::vector<std::string> {};

   }

遍历数组vector 找出m_provider ；三中返回值：1.空 2.目标对象 3. 输入对象

15594999189

55.  result.test_eq(provider, hash->name(), algo);

调用了模板函数   template<typename T>
            bool test_is_eq(const std::string& what, const T& produced, const T& expected)
               {
               std::ostringstream out;
               out << m_who << " " << what;

               if(produced == expected)
                  {
                  out << " produced expected result " << produced;
                  return test_success(out.str());
                  }
               else
                  {
                  out << " produced unexpected result '" << produced << "' expected '" << expected << "'";
                  return test_failure(out.str());
                  }

               }

const std::string& algo  ；；；T=const std::string&

std::ostringstream 定义了输出流  ：：

（1）m_who what  produced expected result  ####

（2）m_who what  produced unexpected result‘ ###’expected ‘####’