~mysql/mysql-server/5.7

« back to all changes in this revision

Viewing changes to storage/innobase/include/ut0ut.h

  • Committer: Annamalai Gurusami
  • Date: 2014-03-04 03:43:36 UTC
  • Revision ID: annamalai.gurusami@oracle.com-20140304034336-3rlrk9g73qbd7wbc
Bug #18320915 PROVIDE C++ OSTREAM APPROACH FOR ERROR LOGGING - AVOID
PRINTF FORMAT SPECIFIERS

Problem:

Specifying the printf format specifiers have become cumbersome.

Solution:

Use the C++ streams mechanism to avoid using printf format specifiers.  I have
given one example were the log message is written without making use of the
LSN_PF format specifier.  

rb#4684 approved by Vasil

Show diffs side-by-side

added added

removed removed

Lines of Context:
44
44
 
45
45
#include <stdarg.h>
46
46
#include <ostream>
 
47
#include <sstream>
47
48
 
48
49
/** Index name prefix in fast index creation */
49
50
#define TEMP_INDEX_PREFIX       '\377'
495
496
/*======*/
496
497
        dberr_t num);   /*!< in: error number */
497
498
 
 
499
namespace ib {
 
500
 
 
501
/** This is a wrapper class, used to print any unsigned integer type
 
502
in hexadecimal format.  The main purpose of this data type is to
 
503
overload the global operator<<, so that we can print the given
 
504
wrapper value in hex. */
 
505
struct hex {
 
506
        explicit hex(uintmax_t t): m_val(t) {}
 
507
        const uintmax_t m_val;
 
508
};
 
509
 
 
510
/** This is an overload of the global operator<< for the user defined type
 
511
ib::hex.  The unsigned value held in the ib::hex wrapper class will be printed
 
512
into the given output stream in hexadecimal format.
 
513
@param[in,out]  lhs     the output stream into which rhs is written.
 
514
@param[in]      rhs     the object to be written into lhs.
 
515
@retval reference to the output stream. */
 
516
inline
 
517
std::ostream&
 
518
operator<<(
 
519
        std::ostream&   lhs,
 
520
        const hex&      rhs)
 
521
{
 
522
        std::ios_base::fmtflags ff = lhs.flags();
 
523
        lhs << std::showbase << std::hex << rhs.m_val;
 
524
        lhs.setf(ff);
 
525
        return(lhs);
 
526
}
 
527
 
 
528
/** The class logger is the base class of all the error log related classes.
 
529
It contains a std::ostringstream object.  The main purpose of this class is
 
530
to forward operator<< to the underlying std::ostringstream object.  Do not
 
531
use this class directly, instead use one of the derived classes. */
 
532
class logger {
 
533
public:
 
534
        template<typename T>
 
535
        logger& operator<<(const T& rhs)
 
536
        {
 
537
                m_oss << rhs;
 
538
                return(*this);
 
539
        }
 
540
        std::ostringstream      m_oss;
 
541
protected:
 
542
        /* This class must not be used directly, hence making the default
 
543
        constructor protected. */
 
544
        logger() {}
 
545
};
 
546
 
 
547
/** The class info is used to emit informational log messages.  It is to be
 
548
used similar to std::cout.  But the log messages will be emitted only when
 
549
the dtor is called.  The preferred usage of this class is to make use of
 
550
unnamed temporaries as follows:
 
551
 
 
552
info() << "The server started successfully.";
 
553
 
 
554
In the above usage, the temporary object will be destroyed at the end of the
 
555
statement and hence the log message will be emitted at the end of the
 
556
statement.  If a named object is created, then the log message will be emitted
 
557
only when it goes out of scope or destroyed. */
 
558
class info : public logger {
 
559
public:
 
560
        ~info();
 
561
};
 
562
 
 
563
/** The class warn is used to emit warnings.  Refer to the documentation of
 
564
class info for further details. */
 
565
class warn : public logger {
 
566
public:
 
567
        ~warn();
 
568
};
 
569
 
 
570
/** The class error is used to emit error messages.  Refer to the
 
571
documentation of class info for further details. */
 
572
class error : public logger {
 
573
public:
 
574
        ~error();
 
575
};
 
576
 
 
577
/** The class fatal is used to emit an error message and stop the server
 
578
by crashing it.  Use this class when MySQL server needs to be stopped
 
579
immediately.  Refer to the documentation of class info for usage details. */
 
580
class fatal : public logger {
 
581
public:
 
582
        ~fatal();
 
583
};
 
584
 
 
585
} // namespace ib
 
586
 
498
587
#ifndef UNIV_NONINL
499
588
#include "ut0ut.ic"
500
589
#endif