d_debug.cc

Go to the documentation of this file.

#include "config.h"

#include <iostream>
#include <fstream>
#include <string>

#include "debug.h"
#include "d_debug.h"

#ifdef DEBUG
//-----------------------------------------------------------------------------

const size_t d_debug::m_buffer_size = 1024;

d_debug::d_debug()
{
        size_t c;

        m_ok = false;

        m_buffer = new char[m_buffer_size];
        if (m_buffer == 0)
                return;

        for (c = 0; c < m_buffer_size; ++c)
                m_buffer[c] = 0;

        m_ok = true;
}

d_debug::~d_debug()
{
        if (!m_ok)
                return;
        delete[] m_buffer;
}

bool d_debug::open(const std::string& a_filename)
{
        m_in.open(a_filename.c_str());
        if (!m_in.is_open())
                return(false);
        return(true);
}

bool d_debug::close(void)
{
        if (m_in.is_open())
                m_in.close();
        return(true);
}

bool d_debug::is_open(void)
{
        return(m_in.is_open());
}

bool d_debug::get_line()
{
        if (!m_ok)
                return(false);
        mf_clear_buffer();
        if (!m_in.getline(m_buffer,m_buffer_size))
                return(false);
        try {
                m_str = std::string(m_buffer);
        }
        catch(...) {
                std::cerr 
                        << "*** ERROR: d_debug::getline() - Out of memory?" 
                        << std::endl;
                return(false);
        }
        return(true);
}

bool d_debug::str_equal(const std::string& a_str)
{
        return(m_str == a_str);
}

bool d_debug::str_begin(const std::string& a_str)
{
        if (m_str.substr(0,a_str.size()) == a_str)
                return(true);
        return(false);
}

bool d_debug::str_end(const std::string& a_str)
{
        if (m_str.substr(m_str.size()-a_str.size()) == a_str)
                return(true);
        return(false);
}

bool d_debug::str_between(
        const std::string& a_str, 
        std::string::size_type a_begin, 
        std::string::size_type a_end
        )
{
        std::string::size_type idx;

        idx = m_str.find(a_str,a_begin);
        if ((idx != std::string::npos) && (idx+a_str.size() <= a_end))
                return(true);
        return(false);
}

bool d_debug::str_wrap(const std::string& a_begin, const std::string& a_end)
{
        return(str_begin(a_begin) && str_end(a_end));
}

bool d_debug::str_sandwich(
        const std::string& a_begin, 
        const std::string& a_middle,
        const std::string& a_end
        )
{
        return(
                str_begin(a_begin)
                && str_between(a_middle,a_begin.size(),m_str.size()-a_end.size())
                && str_end(a_end)
                );
}

void d_debug::mf_clear_buffer(void)
{
        size_t c;

        for (c = 0; c < m_buffer_size; ++c)
                m_buffer[c] = 0;
}

//-----------------------------------------------------------------------------

d_debug ddbg;

//-----------------------------------------------------------------------------
#endif

---