mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-20 02:55:50 +00:00
304 lines
8.9 KiB
C++
304 lines
8.9 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of Beast: https://github.com/vinniefalco/Beast
|
|
Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#ifndef BEAST_LEXICALCAST_H_INCLUDED
|
|
#define BEAST_LEXICALCAST_H_INCLUDED
|
|
|
|
// Base class with utility functions
|
|
struct LexicalCastUtilities
|
|
{
|
|
static unsigned char const s_digitTable [256];
|
|
|
|
// strict string to integer parser
|
|
template <class IntType, class InputIterator>
|
|
static inline bool parseSigned (IntType& result, InputIterator begin, InputIterator end)
|
|
{
|
|
if (0 == std::distance (begin, end))
|
|
return false;
|
|
|
|
uint64 accum = 0;
|
|
InputIterator it = begin;
|
|
|
|
// process sign
|
|
bool negative = false;
|
|
if ('+' == *it)
|
|
{
|
|
++it;
|
|
}
|
|
else if ('-' == *it)
|
|
{
|
|
++it;
|
|
negative = true;
|
|
}
|
|
if (end == it)
|
|
return false;
|
|
|
|
// calc max of abs value
|
|
uint64 max;
|
|
if (negative)
|
|
max = static_cast <uint64> (
|
|
-(static_cast <int64> (std::numeric_limits <IntType>::min ())));
|
|
else
|
|
max = std::numeric_limits <IntType>::max ();
|
|
|
|
// process digits
|
|
while (end != it)
|
|
{
|
|
uint64 const digit = static_cast <IntType> (
|
|
s_digitTable [static_cast <unsigned int> (*it++)]);
|
|
|
|
if (0xFF == digit)
|
|
return false;
|
|
|
|
uint64 const overflow = (max - digit) / 10;
|
|
|
|
if (accum > overflow)
|
|
return false;
|
|
|
|
accum = (10 * accum) + digit;
|
|
}
|
|
|
|
if (negative)
|
|
{
|
|
result = -static_cast <IntType> (accum);
|
|
}
|
|
else
|
|
{
|
|
result = static_cast <IntType> (accum);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <class IntType, class InputIterator>
|
|
static inline bool parseUnsigned (IntType& result, InputIterator begin, InputIterator end)
|
|
{
|
|
if (0 == std::distance (begin, end))
|
|
return false;
|
|
|
|
uint64 accum = 0;
|
|
InputIterator it = begin;
|
|
uint64 const max = std::numeric_limits <IntType>::max ();
|
|
|
|
// process digits
|
|
while (end != it)
|
|
{
|
|
uint64 const digit = static_cast <IntType> (
|
|
s_digitTable [static_cast <unsigned int> (*it++)]);
|
|
|
|
if (0xFF == digit)
|
|
return false;
|
|
|
|
uint64 const overflow = (max - digit) / 10;
|
|
|
|
if (accum > overflow)
|
|
return false;
|
|
|
|
accum = (10 * accum) + digit;
|
|
}
|
|
|
|
result = static_cast <IntType> (accum);
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** This is thrown when a conversion is not possible.
|
|
Only used in the throw variants of lexicalCast.
|
|
*/
|
|
struct BadLexicalCast : public std::bad_cast
|
|
{
|
|
};
|
|
|
|
// These specializatons get called by the non-member functions to do the work
|
|
template <class Out, class In>
|
|
struct LexicalCast;
|
|
|
|
// conversion to String
|
|
template <class In>
|
|
struct LexicalCast <String, In>
|
|
{
|
|
bool operator() (String& out, int in) const { out = String (in); return true; }
|
|
bool operator() (String& out, unsigned int in) const { out = String (in); return true; }
|
|
bool operator() (String& out, short in) const { out = String (in); return true; }
|
|
bool operator() (String& out, unsigned short in) const { out = String (in); return true; }
|
|
bool operator() (String& out, int64 in) const { out = String (in); return true; }
|
|
bool operator() (String& out, uint64 in) const { out = String (in); return true; }
|
|
bool operator() (String& out, float in) const { out = String (in); return true; }
|
|
bool operator() (String& out, double in) const { out = String (in); return true; }
|
|
};
|
|
|
|
// Parse String to number
|
|
template <class Out>
|
|
struct LexicalCast <Out, String>
|
|
{
|
|
bool operator() (int& out, String const& in) const { std::string const& s (in.toStdString ()); return LexicalCastUtilities::parseSigned (out, s.begin (), s.end ()); }
|
|
bool operator() (short& out, String const& in) const { std::string const& s (in.toStdString ()); return LexicalCastUtilities::parseSigned (out, s.begin (), s.end ()); }
|
|
bool operator() (int64& out, String const& in) const { std::string const& s (in.toStdString ()); return LexicalCastUtilities::parseSigned (out, s.begin (), s.end ()); }
|
|
bool operator() (unsigned int& out, String const& in) const { std::string const& s (in.toStdString ()); return LexicalCastUtilities::parseUnsigned (out, s.begin (), s.end ()); }
|
|
bool operator() (unsigned short& out, String const& in) const { std::string const& s (in.toStdString ()); return LexicalCastUtilities::parseUnsigned (out, s.begin (), s.end ()); }
|
|
bool operator() (uint64& out, String const& in) const { std::string const& s (in.toStdString ()); return LexicalCastUtilities::parseUnsigned (out, s.begin (), s.end ()); }
|
|
bool operator() (float& out, String const& in) const { bassertfalse; return false; /* UNIMPLEMENTED! */ }
|
|
bool operator() (double& out, String const& in) const { bassertfalse; return false; /* UNIMPLEMENTED! */ }
|
|
|
|
bool operator () (bool& out, String const& in) const
|
|
{
|
|
// boost::lexical_cast is very strict, it
|
|
// throws on anything but "1" or "0"
|
|
//
|
|
if (in == "1")
|
|
{
|
|
out = true;
|
|
return true;
|
|
}
|
|
else if (in == "0")
|
|
{
|
|
out = false;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Conversion to std::string
|
|
template <class In>
|
|
struct LexicalCast <std::string, In>
|
|
{
|
|
bool operator() (std::string& out, In in) const
|
|
{
|
|
String s;
|
|
|
|
if (LexicalCast <String, In> () (s, in))
|
|
{
|
|
out = s.toStdString ();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Conversion from std::string
|
|
template <class Out>
|
|
struct LexicalCast <Out, std::string>
|
|
{
|
|
bool operator() (Out& out, std::string const& in) const
|
|
{
|
|
Out result;
|
|
|
|
if (LexicalCast <Out, String> () (result, String (in.c_str ())))
|
|
{
|
|
out = result;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Conversion from null terminated char const*
|
|
template <class Out>
|
|
struct LexicalCast <Out, char const*>
|
|
{
|
|
bool operator() (Out& out, char const* in) const
|
|
{
|
|
Out result;
|
|
|
|
if (LexicalCast <Out, String> () (result, String (in)))
|
|
{
|
|
out = result;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Conversion from null terminated char*
|
|
// The string is not modified.
|
|
template <class Out>
|
|
struct LexicalCast <Out, char*>
|
|
{
|
|
bool operator() (Out& out, char* in) const
|
|
{
|
|
Out result;
|
|
|
|
if (LexicalCast <Out, char const*> () (result, in))
|
|
{
|
|
out = result;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** Intelligently convert from one type to another.
|
|
@return `false` if there was a parsing or range error
|
|
*/
|
|
template <class Out, class In>
|
|
bool lexicalCastChecked (Out& out, In in)
|
|
{
|
|
return LexicalCast <Out, In> () (out, in);
|
|
}
|
|
|
|
/** Convert from one type to another, throw on error
|
|
|
|
An exception of type BadLexicalCast is thrown if the conversion fails.
|
|
|
|
@return The new type.
|
|
*/
|
|
template <class Out, class In>
|
|
Out lexicalCastThrow (In in)
|
|
{
|
|
Out out;
|
|
|
|
if (lexicalCastChecked (out, in))
|
|
return out;
|
|
|
|
Throw (BadLexicalCast (), __FILE__, __LINE__);
|
|
|
|
return Out ();
|
|
}
|
|
|
|
/** Convert from one type to another.
|
|
|
|
@param defaultValue The value returned if parsing fails
|
|
@return The new type.
|
|
*/
|
|
template <class Out, class In>
|
|
Out lexicalCast (In in, Out defaultValue = Out ())
|
|
{
|
|
Out out;
|
|
|
|
if (lexicalCastChecked (out, in))
|
|
return out;
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
#endif
|