message.cpp

This software aims to create an applet and panel tools to manage a wireless interface card, such as

//
// Message.cpp
//
// $Id: //poco/Main/Foundation/src/Message.cpp#5 $
//
// Copyright (c) 2004, Guenter Obiltschnig/Applied Informatics.
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 
// 3. Redistributions in any form must be accompanied by information on
//    how to obtain complete source code for this software and any
//    accompanying software that uses this software.  The source code
//    must either be included in the distribution or be available for no
//    more than the cost of distribution plus a nominal fee, and must be
//    freely redistributable under reasonable conditions.  For an
//    executable file, complete source code means the source code for all
//    modules it contains.  It does not include source code for modules or
//    files that typically accompany the major components of the operating
//    system on which the executable file runs.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//


#include "Foundation/Message.h"
#include "Foundation/Exception.h"
#include "Foundation/Process.h"


Foundation_BEGIN


Message::Message(): _prio(PRIO_FATAL), _pMap(0)
{
	_pid = Process::id();
}


Message::Message(const std::string& source, const std::string& text, Priority prio): _source(source), _text(text), _prio(prio), _pMap(0), _pid(0)
{
	_pid = Process::id();
}


Message::Message(const Message& msg)
{
	_source = msg._source;
	_text   = msg._text;
	_prio   = msg._prio;
	_time   = msg._time;
	_thread = msg._thread;
	_pid    = msg._pid;
	if (msg._pMap)
		_pMap = new StringMap(*msg._pMap);
	else
		_pMap = 0;
}


Message::Message(const Message& msg, const std::string& text)
{
	_source = msg._source;
	_text   = text;
	_prio   = msg._prio;
	_time   = msg._time;
	_thread = msg._thread;
	_pid    = msg._pid;
	if (msg._pMap)
		_pMap = new StringMap(*msg._pMap);
	else
		_pMap = 0;
}


Message::~Message()
{
	delete _pMap;
}


Message& Message::operator = (const Message& msg)
{
	if (this == &msg) return *this;
	
	_source = msg._source;
	_text   = msg._text;
	_prio   = msg._prio;
	_time   = msg._time;
	_thread = msg._thread;
	_pid    = msg._pid;
	if (msg._pMap)
		_pMap = new StringMap(*msg._pMap);
	else
		_pMap = 0;
		
	return *this;
}


void Message::setSource(const std::string& src)
{
	_source = src;
}


void Message::setText(const std::string& text)
{
	_text = text;
}


void Message::setPriority(Priority prio)
{
	_prio = prio;
}


void Message::setTime(const Timestamp& t)
{
	_time = t;
}


const Timestamp& Message::getTime() const
{
	return _time;
}


void Message::setThread(const std::string& thread)
{
	_thread = thread;
}


const std::string& Message::getThread() const
{
	return _thread;
}


void Message::setPid(long pid)
{
	_pid = pid;
}


long Message::getPid() const
{
	return _pid;
}


const std::string& Message::operator [] (const std::string& param) const
{
	if (_pMap)
		return (*_pMap)[param];
	else
		throw NotFoundException();
}


std::string& Message::operator [] (const std::string& param)
{
	if (!_pMap)
		_pMap = new StringMap;
	return (*_pMap)[param];
}


Foundation_END