cmnPrintf.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  Author(s):  Ofri Sadowsky
  Created on: 2006-02-15
 
  (C) Copyright 2006-2018 Johns Hopkins University (JHU), All Rights Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
 
*/
 

#pragma once
 
#ifndef _cmnPrintf_h
#define _cmnPrintf_h
 
#include <cisstCommon/cmnPortability.h>
 
#include <iostream>
 
// always include last
#include <cisstCommon/cmnExport.h>
 
/* Forward declarations */
class cmnPrintfParser;
 
 
#ifndef DOXYGEN
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const int number);
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const unsigned int number);
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const short number);
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const unsigned short number);
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const long number);
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const unsigned long number);
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const double number);
CISST_EXPORT bool cmnTypePrintf(cmnPrintfParser & parser, const char * text);
#endif
 

class CISST_EXPORT cmnPrintf
{
public:
    cmnPrintf(const std::string & formatStr)
        : FormatString(formatStr)
    {}

    ~cmnPrintf()
    {}

    cmnPrintf(const cmnPrintf & other):
        FormatString(other.FormatString)
    {}
 
private:
    std::string FormatString;
 
    friend class cmnPrintfParser;

    const std::string & GetFormat(void) const
    {
        return FormatString;
    }
};
 

class CISST_EXPORT cmnPrintfParser
{
 
public:
    cmnPrintfParser(std::ostream & output, const cmnPrintf & outputFormat);

    void RawOutput(const char * text)
    {
        OutputStream << text;
    }

    template<class _argType>
    inline cmnPrintfParser &
    operator << (const _argType & dataOut)
    {
        if (NextFormatTextPosition == 0)
            return *this;
        cmnTypePrintf(*this, dataOut);
        AdvanceToNextFormat();
        return *this;
    }

    inline cmnPrintfParser &
    operator << (const int dataOut)
    {
        if (NextFormatTextPosition == 0)
            return *this;
        cmnTypePrintf(*this, dataOut);
        AdvanceToNextFormat();
        return *this;
    }

    inline cmnPrintfParser &
    operator << (const std::string & dataOut)
    {
        if (NextFormatTextPosition == 0)
            return *this;
        cmnTypePrintf(*this, dataOut.c_str());
        AdvanceToNextFormat();
        return *this;
    }

    enum {BUFFER_SIZE = 256};
 
 
private:
    void DumpUntilPercent(void);

    void ProcessPercent(void);

    std::ostream & OutputStream;

    const cmnPrintf & OutputFormatter;

    char * NextFormatTextPosition;

    char NextFormatTextCharacter;

    char * FormatSequence;

    char NextTypeIdCharacter;

    inline void AdvanceToNextFormat(void)
    {
        FormatSequence = 0;
        DumpUntilPercent();
        ProcessPercent();
    }
 
public:

    static const char * TypeIdCharset;

    static const char * IntegerTypeIds;

    static const char * FloatTypeIds;

    static const char * StringTypeIds;

    static inline const char * TypeIdString(double CMN_UNUSED(value))
    {
        return FloatTypeIds;
    }

    static inline const char * TypeIdString(float CMN_UNUSED(value))
    {
        return FloatTypeIds;
    }

    static inline const char * TypeIdString(int CMN_UNUSED(value))
    {
        return IntegerTypeIds;
    }

    static inline const char * TypeIdString(unsigned int CMN_UNUSED(value))
    {
        return IntegerTypeIds;
    }

    static inline const char * TypeIdString(long CMN_UNUSED(value))
    {
        return IntegerTypeIds;
    }

    static inline const char * TypeIdString(unsigned long CMN_UNUSED(value))
    {
        return IntegerTypeIds;
    }

    template<typename _outputType>
    bool MatchOutputWithFormatChar(const _outputType & data)
    {
        const char * formatCharsForData = TypeIdString(data);
        const bool result = this->NextTypeIdCharIsOneOf(formatCharsForData);
        return result;
    }

    bool NextTypeIdCharIsOneOf(const char * typeIdCharset) const;
 
    void SuspendOutput(void)
    {
        NextFormatTextPosition = 0;
    }

    const char * GetNextFormatSequence(void) const
    {
        return FormatSequence;
    }

    char GetNextTypeIdCharacter(void) const
    {
        return NextTypeIdCharacter;
    }
};
 

inline cmnPrintfParser
operator << (std::ostream & outputStream, const cmnPrintf & formatStr)
{
    return cmnPrintfParser(outputStream, formatStr);
}
 
 
#endif  // _cmnPrintf_h