Line data    Source code

       1             : /*
       2             :     This file is part of cpp-ethereum.
       3             : 
       4             :     cpp-ethereum is free software: you can redistribute it and/or modify
       5             :     it under the terms of the GNU General Public License as published by
       6             :     the Free Software Foundation, either version 3 of the License, or
       7             :     (at your option) any later version.
       8             : 
       9             :     cpp-ethereum is distributed in the hope that it will be useful,
      10             :     but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             :     GNU General Public License for more details.
      13             : 
      14             :     You should have received a copy of the GNU General Public License
      15             :     along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
      16             : */
      17             : /** @file CommonData.cpp
      18             :  * @author Gav Wood <i@gavwood.com>
      19             :  * @date 2014
      20             :  */
      21             : 
      22             : #include "CommonData.h"
      23             : 
      24             : #include <stdexcept>
      25             : 
      26             : using namespace std;
      27             : using namespace dev;
      28             : 
      29             : namespace {
      30             : int
      31           0 : fromHexChar(char _i) noexcept
      32             : {
      33           0 :     if (_i >= '0' && _i <= '9')
      34           0 :         return _i - '0';
      35           0 :     if (_i >= 'a' && _i <= 'f')
      36           0 :         return _i - 'a' + 10;
      37           0 :     if (_i >= 'A' && _i <= 'F')
      38           0 :         return _i - 'A' + 10;
      39           0 :     return -1;
      40             : }
      41             : } // namespace
      42             : 
      43             : bool
      44           0 : dev::isHex(string const& _s) noexcept
      45             : {
      46           0 :     auto it = _s.begin();
      47           0 :     if (_s.compare(0, 2, "0x") == 0)
      48           0 :         it += 2;
      49           0 :     return std::all_of(it, _s.end(), [](char c) { return fromHexChar(c) != -1; });
      50             : }
      51             : 
      52             : bytes
      53           0 : dev::fromHex(std::string const& _s, WhenError _throw)
      54             : {
      55           0 :     unsigned s = (_s.size() >= 2 && _s[0] == '0' && _s[1] == 'x') ? 2 : 0;
      56           0 :     std::vector<uint8_t> ret;
      57           0 :     ret.reserve((_s.size() - s + 1) / 2);
      58             : 
      59           0 :     if (_s.size() % 2) {
      60           0 :         int h = fromHexChar(_s[s++]);
      61           0 :         if (h != -1)
      62           0 :             ret.push_back(h);
      63           0 :         else if (_throw == WhenError::Throw)
      64           0 :             throw std::runtime_error("BadHexCharacter");
      65             :         else
      66           0 :             return bytes();
      67             :     }
      68           0 :     for (unsigned i = s; i < _s.size(); i += 2) {
      69           0 :         int h = fromHexChar(_s[i]);
      70           0 :         int l = fromHexChar(_s[i + 1]);
      71           0 :         if (h != -1 && l != -1)
      72           0 :             ret.push_back((uint8_t)(h * 16 + l));
      73           0 :         else if (_throw == WhenError::Throw)
      74           0 :             throw std::runtime_error("BadHexCharacter");
      75             :         else
      76           0 :             return bytes();
      77             :     }
      78           0 :     return ret;
      79           0 : }
      80             : 
      81             : bytes
      82           0 : dev::asNibbles(bytesConstRef const& _s)
      83             : {
      84           0 :     std::vector<uint8_t> ret;
      85           0 :     ret.reserve(_s.size() * 2);
      86           0 :     for (auto i : _s) {
      87           0 :         ret.push_back(i / 16);
      88           0 :         ret.push_back(i % 16);
      89             :     }
      90           0 :     return ret;
      91           0 : }