songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Uniformize indentation / code (no real changes)

This commit is contained in:
Mael Rouxel-Labbé 2020-01-20 11:05:59 +01:00
parent 85e7eb1fab
commit 0e82e7f9ee
1 changed files with 276 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

335
Stream_support/include/CGAL/IO/io.h
View File

@ -20,46 +20,42 @@
#include <CGAL/disable_warnings.h> #include <CGAL/disable_warnings.h>
#include <CGAL/assertions.h>
#include <CGAL/tags.h>
#include <CGAL/IO/io_tags.h>
#include <CGAL/IO/Color.h>
#include <CGAL/Fraction_traits.h>
#include <cstdio> #include <cstdio>
#include <cctype> #include <cctype>
#include <string> #include <string>
#include <locale> #include <locale>
#include <iostream> #include <iostream>
#include <CGAL/tags.h>
#include <CGAL/IO/io_tags.h>
#include <CGAL/IO/Color.h>
#include <CGAL/assertions.h>
#include <CGAL/Fraction_traits.h>
namespace CGAL { namespace CGAL {
namespace IO { namespace IO {
class Static { class Static
{
public: public:
static int get_mode() static int get_mode()
{ {
static const int mode = std::ios::xalloc(); static const int mode = std::ios::xalloc();
return mode; return mode;
} }
}; };
enum Mode {ASCII = 0, PRETTY, BINARY}; enum Mode {ASCII = 0, PRETTY, BINARY};
} } // namespace IO
template <typename Dummy> template <typename Dummy>
struct IO_rep_is_specialized_aux struct IO_rep_is_specialized_aux
{ {
static const bool is_specialized = true; static const bool is_specialized = true;
}; };
template< class Dummy > template< class Dummy >
const bool IO_rep_is_specialized_aux<Dummy>::is_specialized; const bool IO_rep_is_specialized_aux<Dummy>::is_specialized;
@ -68,6 +64,7 @@ struct IO_rep_is_not_specialized_aux
{ {
static const bool is_specialized = false; static const bool is_specialized = false;
}; };
template< class Dummy > template< class Dummy >
const bool IO_rep_is_not_specialized_aux<Dummy>::is_specialized; const bool IO_rep_is_not_specialized_aux<Dummy>::is_specialized;
@ -75,8 +72,11 @@ typedef IO_rep_is_specialized_aux<void> IO_rep_is_specialized;
typedef IO_rep_is_not_specialized_aux<void> IO_rep_is_not_specialized; typedef IO_rep_is_not_specialized_aux<void> IO_rep_is_not_specialized;
template <class T, class F = ::CGAL::Null_tag > template <class T, class F = ::CGAL::Null_tag >
class Output_rep : public IO_rep_is_not_specialized { class Output_rep
: public IO_rep_is_not_specialized
{
const T& t; const T& t;
public: public:
//! initialize with a const reference to \a t. //! initialize with a const reference to \a t.
Output_rep( const T& tt) : t(tt) {} Output_rep( const T& tt) : t(tt) {}
@ -88,22 +88,15 @@ public:
\brief stream output of the \c Output_rep calls its \c operator(). \brief stream output of the \c Output_rep calls its \c operator().
*/ */
template <class T, class F> template <class T, class F>
std::ostream& std::ostream& operator<<( std::ostream& out, Output_rep<T,F> rep) { return rep( out); }
operator<<( std::ostream& out, Output_rep<T,F> rep) {
return rep( out);
}
//! generic IO output format manipulator. //! generic IO output format manipulator.
template <class T> template <class T>
Output_rep<T> Output_rep<T> oformat(const T& t) { return Output_rep<T>(t); }
oformat( const T& t) { return Output_rep<T>(t); }
//! generic IO output format manipulator with formatting tag. //! generic IO output format manipulator with formatting tag.
template <class T, class F> template <class T, class F>
Output_rep<T,F> Output_rep<T,F> oformat( const T& t, F) { return Output_rep<T,F>(t); }
oformat( const T& t, F) { return Output_rep<T,F>(t); }
/*!\brief /*!\brief
* input functor class created by the generic IO input manipulator. * input functor class created by the generic IO input manipulator.
@ -113,20 +106,28 @@ oformat( const T& t, F) { return Output_rep<T,F>(t); }
* for external types not supporting our stream IO format. * for external types not supporting our stream IO format.
*/ */
template <class T> template <class T>
class Input_rep : public IO_rep_is_not_specialized { class Input_rep
: public IO_rep_is_not_specialized
{
T& t; T& t;
public: public:
//! initialize with a reference to \a t. //! initialize with a reference to \a t.
Input_rep( T& tt) : t(tt) {} Input_rep( T& tt) : t(tt) {}
//! perform the input, calls \c operator\>\> by default. //! perform the input, calls \c operator\>\> by default.
std::istream& operator()( std::istream& in) const { return (in >> t); } std::istream& operator()( std::istream& in) const { return (in >> t); }
}; };
#if CGAL_FORCE_IFORMAT_DOUBLE || \ #if CGAL_FORCE_IFORMAT_DOUBLE || \
( ( _MSC_VER > 1600 ) && ( _MSC_VER < 1910 ) && (! defined( CGAL_NO_IFORMAT_DOUBLE )) ) ( ( _MSC_VER > 1600 ) && ( _MSC_VER < 1910 ) && (! defined( CGAL_NO_IFORMAT_DOUBLE )) )
template <> template <>
class Input_rep<double> : public IO_rep_is_specialized { class Input_rep<double>
: public IO_rep_is_specialized
{
double& t; double& t;
public: public:
//! initialize with a reference to \a t. //! initialize with a reference to \a t.
Input_rep( double& tt) : t(tt) {} Input_rep( double& tt) : t(tt) {}
@ -142,43 +143,61 @@ public:
buffer.reserve(32); buffer.reserve(32);
char_type c; char_type c;
do { do
{
const int_type i = is.get(); const int_type i = is.get();
if(i == traits_type::eof()) { if(i == traits_type::eof())
return is; return is;
}
c = static_cast<char_type>(i); c = static_cast<char_type>(i);
}while (std::isspace(c)); }
if(c == '-'){ while (std::isspace(c));
if(c == '-')
{
buffer += '-'; buffer += '-';
} else if(c != '+'){ }
else if(c != '+')
{
is.unget(); is.unget();
} }
do {
for(;;)
{
const int_type i = is.get(); const int_type i = is.get();
if(i == traits_type::eof()) { if(i == traits_type::eof())
{
is.clear(is.rdstate() & ~std::ios_base::failbit); is.clear(is.rdstate() & ~std::ios_base::failbit);
break; break;
} }
c = static_cast<char_type>(i); c = static_cast<char_type>(i);
if(std::isdigit(c) || (c =='.') || (c =='E') || (c =='e') || (c =='+') || (c =='-')){ if(std::isdigit(c) || (c =='.') || (c =='E') || (c =='e') || (c =='+') || (c =='-'))
{
buffer += c; buffer += c;
}else{ }
else
{
is.unget(); is.unget();
break; break;
} }
}while(true); }
if(sscanf_s(buffer.c_str(), "%lf", &t) != 1) {
if(sscanf_s(buffer.c_str(), "%lf", &t) != 1)
{
// if a 'buffer' does not contain a double, set the fail bit. // if a 'buffer' does not contain a double, set the fail bit.
is.setstate(std::ios_base::failbit); is.setstate(std::ios_base::failbit);
} }
return is; return is;
} }
}; };
template <> template <>
class Input_rep<float> { class Input_rep<float>
{
float& t; float& t;
public: public:
//! initialize with a reference to \a t. //! initialize with a reference to \a t.
Input_rep( float& tt) : t(tt) {} Input_rep( float& tt) : t(tt) {}
@ -194,36 +213,52 @@ public:
buffer.reserve(32); buffer.reserve(32);
char_type c; char_type c;
do { do
{
const int_type i = is.get(); const int_type i = is.get();
if(i == traits_type::eof()) { if(i == traits_type::eof())
return is; return is;
}
c = static_cast<char_type>(i); c = static_cast<char_type>(i);
}while (std::isspace(c)); }
if(c == '-'){ while (std::isspace(c));
if(c == '-')
{
buffer += '-'; buffer += '-';
} else if(c != '+'){ }
else if(c != '+')
{
is.unget(); is.unget();
} }
do {
for(;;)
{
const int_type i = is.get(); const int_type i = is.get();
if(i == traits_type::eof()) { if(i == traits_type::eof())
{
is.clear(is.rdstate() & ~std::ios_base::failbit); is.clear(is.rdstate() & ~std::ios_base::failbit);
break; break;
} }
c = static_cast<char_type>(i); c = static_cast<char_type>(i);
if(std::isdigit(c) || (c =='.') || (c =='E') || (c =='e') || (c =='+') || (c =='-')){ if(std::isdigit(c) || (c =='.') || (c =='E') || (c =='e') || (c =='+') || (c =='-'))
{
buffer += c; buffer += c;
}else{ }
else
{
is.unget(); is.unget();
break; break;
} }
}while(true); }
if(sscanf_s(buffer.c_str(), "%f", &t) != 1) {
if(sscanf_s(buffer.c_str(), "%f", &t) != 1)
{
// if a 'buffer' does not contain a double, set the fail bit. // if a 'buffer' does not contain a double, set the fail bit.
is.setstate(std::ios_base::failbit); is.setstate(std::ios_base::failbit);
} }
return is; return is;
} }
}; };
@ -233,38 +268,29 @@ public:
\brief stream input to the \c Input_rep calls its \c operator(). \brief stream input to the \c Input_rep calls its \c operator().
*/ */
template <class T> template <class T>
std::istream& std::istream& operator>>( std::istream& in, Input_rep<T> rep) { return rep(in); }
operator>>( std::istream& in, Input_rep<T> rep) {
return rep( in);
}
//! generic IO input format manipulator. //! generic IO input format manipulator.
template <class T> template <class T>
Input_rep<T> Input_rep<T> iformat( T& t) { return Input_rep<T>(t); }
iformat( T& t) { return Input_rep<T>(t); }
template <class T, class F = Null_tag > template <class T, class F = Null_tag >
class Benchmark_rep { class Benchmark_rep
{
const T& t; const T& t;
public: public:
//! initialize with a const reference to \a t. //! initialize with a const reference to \a t.
Benchmark_rep( const T& tt) : t(tt) {} Benchmark_rep( const T& tt) : t(tt) {}
//! perform the output, calls \c operator\<\< by default. //! perform the output, calls \c operator\<\< by default.
std::ostream& operator()( std::ostream& out) const { std::ostream& operator()( std::ostream& out) const { return out << t; }
return out << t;
}
// static function to get the benchmark name // static function to get the benchmark name
static std::string get_benchmark_name() { static std::string get_benchmark_name() { return ""; }
return "";
}
}; };
template <class T, class F> template <class T, class F>
std::ostream& operator<<( std::ostream& out, Benchmark_rep<T,F> rep) { std::ostream& operator<<( std::ostream& out, Benchmark_rep<T,F> rep) { return rep( out); }
return rep( out);
}
template <class T> template <class T>
Benchmark_rep<T> bmformat( const T& t) { return Benchmark_rep<T>(t); } Benchmark_rep<T> bmformat( const T& t) { return Benchmark_rep<T>(t); }
@ -272,116 +298,74 @@ Benchmark_rep<T> bmformat( const T& t) { return Benchmark_rep<T>(t); }
template <class T, class F> template <class T, class F>
Benchmark_rep<T,F> bmformat( const T& t, F) { return Benchmark_rep<T,F>(t); } Benchmark_rep<T,F> bmformat( const T& t, F) { return Benchmark_rep<T,F>(t); }
CGAL_EXPORT IO::Mode get_mode(std::ios& i);
CGAL_EXPORT CGAL_EXPORT IO::Mode set_ascii_mode(std::ios& i);
IO::Mode
get_mode(std::ios& i);
CGAL_EXPORT CGAL_EXPORT IO::Mode set_binary_mode(std::ios& i);
IO::Mode
set_ascii_mode(std::ios& i);
CGAL_EXPORT CGAL_EXPORT IO::Mode set_pretty_mode(std::ios& i);
IO::Mode
set_binary_mode(std::ios& i);
CGAL_EXPORT CGAL_EXPORT IO::Mode set_mode(std::ios& i, IO::Mode m);
IO::Mode
set_pretty_mode(std::ios& i);
CGAL_EXPORT CGAL_EXPORT bool is_pretty(std::ios& i);
IO::Mode
set_mode(std::ios& i, IO::Mode m);
CGAL_EXPORT CGAL_EXPORT bool is_ascii(std::ios& i);
bool
is_pretty(std::ios& i);
CGAL_EXPORT
bool
is_ascii(std::ios& i);
CGAL_EXPORT
bool
is_binary(std::ios& i);
CGAL_EXPORT bool is_binary(std::ios& i);
template < class T > template < class T >
inline inline void write(std::ostream& os, const T& t, const io_Read_write&)
void
write(std::ostream& os, const T& t, const io_Read_write&)
{ {
os.write(reinterpret_cast<const char*>(&t), sizeof(t)); os.write(reinterpret_cast<const char*>(&t), sizeof(t));
} }
template < class T > template < class T >
inline inline void write(std::ostream& os, const T& t, const io_Operator&)
void
write(std::ostream& os, const T& t, const io_Operator&)
{ {
os << oformat(t); os << oformat(t);
} }
template < class T > template < class T >
inline inline void write(std::ostream& os, const T& t, const io_Extract_insert&)
void
write(std::ostream& os, const T& t, const io_Extract_insert&)
{ {
insert(os, t); insert(os, t);
} }
template < class T > template < class T >
inline inline void write(std::ostream& os, const T& t)
void
write(std::ostream& os, const T& t)
{ {
write(os, t, typename Io_traits<T>::Io_tag()); write(os, t, typename Io_traits<T>::Io_tag());
} }
template < class T > template < class T >
inline inline void read(std::istream& is, T& t, const io_Read_write&)
void
read(std::istream& is, T& t, const io_Read_write&)
{ {
is.read(reinterpret_cast<char*>(&t), sizeof(t)); is.read(reinterpret_cast<char*>(&t), sizeof(t));
} }
template < class T > template < class T >
inline inline void read(std::istream& is, T& t, const io_Operator&)
void
read(std::istream& is, T& t, const io_Operator&)
{ {
is >> iformat(t); is >> iformat(t);
} }
template < class T > template < class T >
inline inline void read(std::istream& is, T& t, const io_Extract_insert&)
void
read(std::istream& is, T& t, const io_Extract_insert&)
{ {
extract(is, t); extract(is, t);
} }
template < class T > template < class T >
inline inline void read(std::istream& is, T& t)
void
read(std::istream& is, T& t)
{ {
read(is, t, typename Io_traits<T>::Io_tag()); read(is, t, typename Io_traits<T>::Io_tag());
} }
inline std::ostream& operator<<( std::ostream& out, const Color& col)
inline {
std::ostream& operator<<( std::ostream& out, const Color& col) switch(get_mode(out))
{ {
switch(get_mode(out)) {
case IO::ASCII : case IO::ASCII :
return out << static_cast<int>(col.red()) << ' ' return out << static_cast<int>(col.red()) << ' '
<< static_cast<int>(col.green()) << ' ' << static_cast<int>(col.green()) << ' '
@ -398,12 +382,13 @@ std::ostream& operator<<( std::ostream& out, const Color& col)
} }
} }
inline inline std::istream &operator>>(std::istream &is, Color& col)
std::istream &operator>>(std::istream &is, Color& col)
{ {
unsigned char r = 0, g = 0, b = 0, a = 0; unsigned char r = 0, g = 0, b = 0, a = 0;
int ir = 0, ig = 0, ib = 0, ia = 0; int ir = 0, ig = 0, ib = 0, ia = 0;
switch(get_mode(is)) {
switch(get_mode(is))
{
case IO::ASCII : case IO::ASCII :
is >> ir >> ig >> ib >> ia; is >> ir >> ig >> ib >> ia;
r = (unsigned char)ir; r = (unsigned char)ir;
@ -422,60 +407,61 @@ std::istream &operator>>(std::istream &is, Color& col)
std::cerr << "Stream must be in ascii or binary mode" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl;
break; break;
} }
col = Color(r,g,b,a); col = Color(r,g,b,a);
return is; return is;
} }
CGAL_EXPORT CGAL_EXPORT const char* mode_name( IO::Mode m );
const char* mode_name( IO::Mode m );
// From polynomial.h TODO: Where to put this? // From polynomial.h TODO: Where to put this?
CGAL_EXPORT CGAL_EXPORT void swallow(std::istream &is, char d);
void swallow(std::istream &is, char d);
CGAL_EXPORT
void swallow(std::istream &is, const std::string& s );
CGAL_EXPORT void swallow(std::istream &is, const std::string& s );
namespace internal { namespace internal {
inline
void eat_white_space(std::istream &is) inline void eat_white_space(std::istream &is)
{ {
std::istream::int_type c; std::istream::int_type c;
do { do
{
c = is.peek(); c = is.peek();
if(c== std::istream::traits_type::eof()) if(c== std::istream::traits_type::eof())
{
return; return;
else { }
else
{
std::istream::char_type cc= static_cast<std::istream::char_type>(c); std::istream::char_type cc= static_cast<std::istream::char_type>(c);
if ( std::isspace(cc, std::locale::classic()) ) { if(std::isspace(cc, std::locale::classic()))
{
is.get(); is.get();
// since peek succeeded, this should too // since peek succeeded, this should too
CGAL_assertion(!is.fail()); CGAL_assertion(!is.fail());
} else { }
else
{
return; return;
} }
} }
} while (true); }
while (true);
} }
inline bool is_space(const std::istream& /*is*/, std::istream::int_type c)
inline
bool is_space (const std::istream& /*is*/, std::istream::int_type c)
{ {
return (c == std::istream::traits_type::eof()) || return (c == std::istream::traits_type::eof()) ||
std::isspace(static_cast<std::istream::char_type>(c), std::isspace(static_cast<std::istream::char_type>(c),
std::locale::classic() ); std::locale::classic() );
} }
inline inline bool is_eof(const std::istream& /*is*/, std::istream::int_type c)
bool is_eof (const std::istream& /*is*/, std::istream::int_type c)
{ {
return c == std::istream::traits_type::eof(); return c == std::istream::traits_type::eof();
} }
inline inline bool is_digit(const std::istream& /*is*/, std::istream::int_type c)
bool is_digit (const std::istream& /*is*/, std::istream::int_type c)
{ {
CGAL_assertion(c != std::istream::traits_type::eof()); CGAL_assertion(c != std::istream::traits_type::eof());
return std::isdigit(static_cast<std::istream::char_type>(c), return std::isdigit(static_cast<std::istream::char_type>(c),
@ -494,15 +480,12 @@ void eat_white_space(std::istream &is)
return is.peek(); return is.peek();
} }
template <typename ET> template <typename ET>
inline void read_float_or_quotient(std::istream & is, ET& et) inline void read_float_or_quotient(std::istream & is, ET& et)
{ {
is >> et; is >> et;
} }
template <typename Int, typename Rat> template <typename Int, typename Rat>
inline void read_float_or_quotient(std::istream& is, Rat &z) inline void read_float_or_quotient(std::istream& is, Rat &z)
{ {
@ -524,36 +507,47 @@ inline void read_float_or_quotient(std::istream& is, Rat &z)
bool digits = false; // for fp-case: are there any digits at all? bool digits = false; // for fp-case: are there any digits at all?
c = internal::peek(is); c = internal::peek(is);
if (c != '.') { if(c != '.')
{
// is there a sign? // is there a sign?
if (c == '-' || c == '+') { if(c == '-' || c == '+')
{
is.get(); is.get();
negative = (c == '-'); negative = (c == '-');
internal::eat_white_space(is); internal::eat_white_space(is);
c=internal::peek(is); c=internal::peek(is);
} }
// read n (could be empty) // read n (could be empty)
while (!internal::is_eof(is, c) && internal::is_digit(is, c)) { while (!internal::is_eof(is, c) && internal::is_digit(is, c))
{
digits = true; digits = true;
n = n*10 + (c-zero); n = n*10 + (c-zero);
is.get(); is.get();
c = internal::peek(is); c = internal::peek(is);
} }
// are we done? // are we done?
if (internal::is_eof(is, c) || internal::is_space(is, c)) { if(internal::is_eof(is, c) || internal::is_space(is, c))
{
is.flags(old_flags); is.flags(old_flags);
if(digits && !is.fail()) if(digits && !is.fail())
z = negative? compose(-n,1): compose(n,1); z = negative? compose(-n,1): compose(n,1);
return; return;
} }
} else }
else
{
n = 0; n = 0;
}
// now we have read n, we are not done, and c is the next character // now we have read n, we are not done, and c is the next character
// in the stream // in the stream
if (c == '/' || c == '.') { if(c == '/' || c == '.')
{
is.get(); is.get();
if (c == '/') { if(c == '/')
{
// rational case // rational case
is >> d; is >> d;
is.flags(old_flags); is.flags(old_flags);
@ -563,7 +557,8 @@ inline void read_float_or_quotient(std::istream& is, Rat &z)
} }
// floating point case; read number after '.' (may be empty) // floating point case; read number after '.' (may be empty)
while (true) { for(;;)
{
c = internal::peek(is); c = internal::peek(is);
if(internal::is_eof(is, c) || !internal::is_digit(is, c)) if(internal::is_eof(is, c) || !internal::is_digit(is, c))
break; break;
@ -578,13 +573,15 @@ inline void read_float_or_quotient(std::istream& is, Rat &z)
// now we have read all digits after '.', and c is the next character; // now we have read all digits after '.', and c is the next character;
// read the exponential part (optional) // read the exponential part (optional)
int e = 0; int e = 0;
if (c == 'e' || c == 'E') { if(c == 'e' || c == 'E')
{
is.get(); is.get();
is >> e; is >> e;
} }
// now construct the Gmpq // now construct the Gmpq
if (!digits) { if(!digits)
{
// illegal floating-point number // illegal floating-point number
is.setstate(std::ios_base::failbit); is.setstate(std::ios_base::failbit);
is.flags(old_flags); is.flags(old_flags);
@ -596,18 +593,16 @@ inline void read_float_or_quotient(std::istream& is, Rat &z)
while (e--) n *= 10; while (e--) n *= 10;
else else
while (e++) d *= 10; while (e++) d *= 10;
is.flags(old_flags); is.flags(old_flags);
if(!is.fail()) if(!is.fail())
z = (negative ? compose(-n,d) : compose(n,d)); z = (negative ? compose(-n,d) : compose(n,d));
} }
} // namespace internal } // namespace internal
} // namespace CGAL } // namespace CGAL
#ifdef CGAL_HEADER_ONLY #ifdef CGAL_HEADER_ONLY
#include <CGAL/IO/io_impl.h> #include <CGAL/IO/io_impl.h>
#endif // CGAL_HEADER_ONLY #endif // CGAL_HEADER_ONLY