You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
268 lines
10 KiB
268 lines
10 KiB
/*
|
|
This file is part of cpp-ethereum.
|
|
|
|
cpp-ethereum is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
cpp-ethereum is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/** @file CommonIO.h
|
|
* @author Gav Wood <i@gavwood.com>
|
|
* @date 2014
|
|
*
|
|
* File & stream I/O routines.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <map>
|
|
#include <set>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <array>
|
|
#include <list>
|
|
#include <memory>
|
|
#include <vector>
|
|
#include <array>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <chrono>
|
|
#include "Common.h"
|
|
#include "Base64.h"
|
|
|
|
namespace dev
|
|
{
|
|
|
|
/// Requests the user to enter a password on the console.
|
|
std::string getPassword(std::string const& _prompt);
|
|
|
|
/// Retrieve and returns the contents of the given file.
|
|
/// If the file doesn't exist or isn't readable, returns an empty container / bytes.
|
|
bytes contents(std::string const& _file);
|
|
/// Retrieve and returns the contents of the given file as a std::string.
|
|
/// If the file doesn't exist or isn't readable, returns an empty container / bytes.
|
|
std::string contentsString(std::string const& _file);
|
|
/// Retrieve and returns the allocated contents of the given file; if @_dest is given, don't allocate, use it directly.
|
|
/// If the file doesn't exist or isn't readable, returns bytesRef(). Don't forget to delete [] the returned value's data when finished.
|
|
bytesRef contentsNew(std::string const& _file, bytesRef _dest = bytesRef());
|
|
|
|
/// Write the given binary data into the given file, replacing the file if it pre-exists.
|
|
/// Throws exception on error.
|
|
/// @param _writeDeleteRename useful not to lose any data: If set, first writes to another file in
|
|
/// the same directory and then moves that file.
|
|
void writeFile(std::string const& _file, bytesConstRef _data, bool _writeDeleteRename = false);
|
|
/// Write the given binary data into the given file, replacing the file if it pre-exists.
|
|
inline void writeFile(std::string const& _file, bytes const& _data, bool _writeDeleteRename = false) { writeFile(_file, bytesConstRef(&_data), _writeDeleteRename); }
|
|
inline void writeFile(std::string const& _file, std::string const& _data, bool _writeDeleteRename = false) { writeFile(_file, bytesConstRef(_data), _writeDeleteRename); }
|
|
|
|
/// Nicely renders the given bytes to a string, optionally as HTML.
|
|
/// @a _bytes: bytes array to be rendered as string. @a _width of a bytes line.
|
|
std::string memDump(bytes const& _bytes, unsigned _width = 8, bool _html = false);
|
|
|
|
// Stream I/O functions.
|
|
// Provides templated stream I/O for all STL collections so they can be shifted on to any iostream-like interface.
|
|
|
|
template <class S, class T> struct StreamOut { static S& bypass(S& _out, T const& _t) { _out << _t; return _out; } };
|
|
template <class S> struct StreamOut<S, uint8_t> { static S& bypass(S& _out, uint8_t const& _t) { _out << (int)_t; return _out; } };
|
|
|
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::vector<T> const& _e);
|
|
template <class T, std::size_t Z> inline std::ostream& operator<<(std::ostream& _out, std::array<T, Z> const& _e);
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::pair<T, U> const& _e);
|
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::list<T> const& _e);
|
|
template <class T1, class T2, class T3> inline std::ostream& operator<<(std::ostream& _out, std::tuple<T1, T2, T3> const& _e);
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::map<T, U> const& _e);
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::unordered_map<T, U> const& _e);
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::set<T, U> const& _e);
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::unordered_set<T, U> const& _e);
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::multimap<T, U> const& _e);
|
|
template <class _S, class _T> _S& operator<<(_S& _out, std::shared_ptr<_T> const& _p);
|
|
|
|
#ifdef _WIN32
|
|
template <class T> inline std::string toString(std::chrono::time_point<T> const& _e, std::string _format = "%Y-%m-%d %H:%M:%S")
|
|
#else
|
|
template <class T> inline std::string toString(std::chrono::time_point<T> const& _e, std::string _format = "%F %T")
|
|
#endif
|
|
{
|
|
unsigned long milliSecondsSinceEpoch = std::chrono::duration_cast<std::chrono::milliseconds>(_e.time_since_epoch()).count();
|
|
auto const durationSinceEpoch = std::chrono::milliseconds(milliSecondsSinceEpoch);
|
|
std::chrono::time_point<std::chrono::system_clock> const tpAfterDuration(durationSinceEpoch);
|
|
|
|
tm timeValue;
|
|
auto time = std::chrono::system_clock::to_time_t(tpAfterDuration);
|
|
#ifdef _WIN32
|
|
gmtime_s(&timeValue, &time);
|
|
#else
|
|
gmtime_r(&time, &timeValue);
|
|
#endif
|
|
|
|
unsigned const millisRemainder = milliSecondsSinceEpoch % 1000;
|
|
char buffer[1024];
|
|
if (strftime(buffer, sizeof(buffer), _format.c_str(), &timeValue))
|
|
return std::string(buffer) + "." + (millisRemainder < 1 ? "000" : millisRemainder < 10 ? "00" : millisRemainder < 100 ? "0" : "") + std::to_string(millisRemainder) + "Z";
|
|
return std::string();
|
|
}
|
|
|
|
template <class S, class T>
|
|
inline S& streamout(S& _out, std::vector<T> const& _e)
|
|
{
|
|
_out << "[";
|
|
if (!_e.empty())
|
|
{
|
|
StreamOut<S, T>::bypass(_out, _e.front());
|
|
for (auto i = ++_e.begin(); i != _e.end(); ++i)
|
|
StreamOut<S, T>::bypass(_out << ",", *i);
|
|
}
|
|
_out << "]";
|
|
return _out;
|
|
}
|
|
|
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::vector<T> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T, std::size_t Z>
|
|
inline S& streamout(S& _out, std::array<T, Z> const& _e)
|
|
{
|
|
_out << "[";
|
|
if (!_e.empty())
|
|
{
|
|
StreamOut<S, T>::bypass(_out, _e.front());
|
|
auto i = _e.begin();
|
|
for (++i; i != _e.end(); ++i)
|
|
StreamOut<S, T>::bypass(_out << ",", *i);
|
|
}
|
|
_out << "]";
|
|
return _out;
|
|
}
|
|
template <class T, std::size_t Z> inline std::ostream& operator<<(std::ostream& _out, std::array<T, Z> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T>
|
|
inline S& streamout(S& _out, std::list<T> const& _e)
|
|
{
|
|
_out << "[";
|
|
if (!_e.empty())
|
|
{
|
|
_out << _e.front();
|
|
for (auto i = ++_e.begin(); i != _e.end(); ++i)
|
|
_out << "," << *i;
|
|
}
|
|
_out << "]";
|
|
return _out;
|
|
}
|
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::list<T> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T, class U>
|
|
inline S& streamout(S& _out, std::pair<T, U> const& _e)
|
|
{
|
|
_out << "(" << _e.first << "," << _e.second << ")";
|
|
return _out;
|
|
}
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::pair<T, U> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T1, class T2, class T3>
|
|
inline S& streamout(S& _out, std::tuple<T1, T2, T3> const& _t)
|
|
{
|
|
_out << "(" << std::get<0>(_t) << "," << std::get<1>(_t) << "," << std::get<2>(_t) << ")";
|
|
return _out;
|
|
}
|
|
template <class T1, class T2, class T3> inline std::ostream& operator<<(std::ostream& _out, std::tuple<T1, T2, T3> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T, class U>
|
|
S& streamout(S& _out, std::map<T, U> const& _v)
|
|
{
|
|
if (_v.empty())
|
|
return _out << "{}";
|
|
int i = 0;
|
|
for (auto p: _v)
|
|
_out << (!(i++) ? "{ " : "; ") << p.first << " => " << p.second;
|
|
return _out << " }";
|
|
}
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::map<T, U> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T, class U>
|
|
S& streamout(S& _out, std::unordered_map<T, U> const& _v)
|
|
{
|
|
if (_v.empty())
|
|
return _out << "{}";
|
|
int i = 0;
|
|
for (auto p: _v)
|
|
_out << (!(i++) ? "{ " : "; ") << p.first << " => " << p.second;
|
|
return _out << " }";
|
|
}
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::unordered_map<T, U> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T>
|
|
S& streamout(S& _out, std::set<T> const& _v)
|
|
{
|
|
if (_v.empty())
|
|
return _out << "{}";
|
|
int i = 0;
|
|
for (auto p: _v)
|
|
_out << (!(i++) ? "{ " : ", ") << p;
|
|
return _out << " }";
|
|
}
|
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::set<T> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T>
|
|
S& streamout(S& _out, std::unordered_set<T> const& _v)
|
|
{
|
|
if (_v.empty())
|
|
return _out << "{}";
|
|
int i = 0;
|
|
for (auto p: _v)
|
|
_out << (!(i++) ? "{ " : ", ") << p;
|
|
return _out << " }";
|
|
}
|
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::unordered_set<T> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T>
|
|
S& streamout(S& _out, std::multiset<T> const& _v)
|
|
{
|
|
if (_v.empty())
|
|
return _out << "{}";
|
|
int i = 0;
|
|
for (auto p: _v)
|
|
_out << (!(i++) ? "{ " : ", ") << p;
|
|
return _out << " }";
|
|
}
|
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::multiset<T> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class S, class T, class U>
|
|
S& streamout(S& _out, std::multimap<T, U> const& _v)
|
|
{
|
|
if (_v.empty())
|
|
return _out << "{}";
|
|
T l;
|
|
int i = 0;
|
|
for (auto p: _v)
|
|
if (!(i++))
|
|
_out << "{ " << (l = p.first) << " => " << p.second;
|
|
else if (l == p.first)
|
|
_out << ", " << p.second;
|
|
else
|
|
_out << "; " << (l = p.first) << " => " << p.second;
|
|
return _out << " }";
|
|
}
|
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::multimap<T, U> const& _e) { streamout(_out, _e); return _out; }
|
|
|
|
template <class _S, class _T> _S& operator<<(_S& _out, std::shared_ptr<_T> const& _p) { if (_p) _out << "@" << (*_p); else _out << "nullptr"; return _out; }
|
|
|
|
// Functions that use streaming stuff.
|
|
|
|
/// Converts arbitrary value to string representation using std::stringstream.
|
|
template <class _T>
|
|
std::string toString(_T const& _t)
|
|
{
|
|
std::ostringstream o;
|
|
o << _t;
|
|
return o.str();
|
|
}
|
|
|
|
}
|
|
|