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-2007 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;
    }

#if CISST_OSTREAM_CAN_CAST_TO_VOID_PTR       
    inline operator void *(void)
    {
        return (void *)(OutputStream);
    }
#elif CISST_OSTREAM_CAN_CAST_TO_INT
    inline operator bool (void)
    {
        return OutputStream;
    }
#else
    inline operator bool(void)
    {
        return OutputStream.good();
    }
#endif

    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;

    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