uhd

//

// Copyright 2011 Ettus Research LLC

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

//

#include <uhd/utils/msg.hpp>

#include <uhd/utils/log.hpp>

#include <uhd/utils/static.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/foreach.hpp>

#include <boost/tokenizer.hpp>

#include <sstream>

#include <iostream>

/***********************************************************************

 * Helper functions

 **********************************************************************/

#define tokenizer(inp, sep) \

    boost::tokenizer<boost::char_separator<char> > \

    (inp, boost::char_separator<char>(sep))

static void msg_to_cout(const std::string &msg){

    std::stringstream ss;

    static bool just_had_a_newline = true;

    BOOST_FOREACH(char ch, msg){

        if (just_had_a_newline){

            just_had_a_newline = false;

            ss << "-- ";

        }

        if (ch == '\n'){

            just_had_a_newline = true;

        }

        ss << ch;

    }

    std::cout << ss.str() << std::flush;

}

static void msg_to_cerr(const std::string &title, const std::string &msg){

    std::stringstream ss;

    ss << std::endl << title << ":" << std::endl;

    BOOST_FOREACH(const std::string &line, tokenizer(msg, "\n")){

        ss << "    " << line << std::endl;

    }

    std::cerr << ss.str() << std::flush;

}

/***********************************************************************

 * Global settings for the messenger

 **********************************************************************/

static boost::mutex msg_mutex;

static std::ostringstream msg_ss;

static uhd::msg::type_t msg_type;

static uhd::msg::handler_t msg_handler;

/***********************************************************************

 * Setup the message handlers

 **********************************************************************/

void uhd::msg::register_handler(const handler_t &handler){

    msg_mutex.lock();

    msg_handler = handler;

    msg_mutex.unlock();

}

static void default_msg_handler(uhd::msg::type_t type, const std::string &msg){

    switch(type){

    case uhd::msg::fastpath:

        std::cerr << msg << std::flush;

        break;

    case uhd::msg::status:

        msg_to_cout(msg);

        UHD_LOG << "Status message" << std::endl << msg;

        break;

    case uhd::msg::warning:

        msg_to_cerr("UHD Warning", msg);

        UHD_LOG << "Warning message" << std::endl << msg;

        break;

    case uhd::msg::error:

        msg_to_cerr("UHD Error", msg);

        UHD_LOG << "Error message" << std::endl << msg;

        break;

    }

}

UHD_STATIC_BLOCK(msg_register_default_handler){

    uhd::msg::register_handler(&default_msg_handler);

}

/***********************************************************************

 * The message object implementation

 **********************************************************************/

uhd::msg::_msg::_msg(const type_t type){

    msg_mutex.lock();

    msg_type = type;

}

uhd::msg::_msg::~_msg(void){

    msg_handler(msg_type, msg_ss.str());

    msg_ss.str(""); //clear for next call

    msg_mutex.unlock();

}

std::ostream & uhd::msg::_msg::operator()(void){

    return msg_ss;

}