application.cpp

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

//
// Application.cpp
//
// $Id: //poco/Main/Util/src/Application.cpp#4 $
//
// Copyright (c) 2004-2005, 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 "Util/Application.h"
#include "Util/SystemConfiguration.h"
#include "Util/MapConfiguration.h"
#include "Util/PropertyFileConfiguration.h"
#include "Util/IniFileConfiguration.h"
#include "Util/XMLConfiguration.h"
#include "Util/LoggingSubsystem.h"
#include "Util/Option.h"
#include "Util/OptionProcessor.h"
#include "Foundation/Environment.h"
#include "Foundation/Exception.h"
#include "Foundation/NumberFormatter.h"
#include "Foundation/File.h"
#include "Foundation/Path.h"
#include "Foundation/String.h"
#include "Foundation/ConsoleChannel.h"
#include "Foundation/AutoPtr.h"
#if defined(POCO_OS_FAMILY_WINDOWS)
#include <windows.h>
#endif
#if defined(POCO_OS_FAMILY_UNIX)
#include "Foundation/SignalHandler.h"
#endif


using Foundation::Logger;
using Foundation::Path;
using Foundation::File;
using Foundation::Environment;
using Foundation::SystemException;
using Foundation::ConsoleChannel;
using Foundation::NumberFormatter;
using Foundation::AutoPtr;
using Foundation::icompare;


Util_BEGIN


Application* Application::_pInstance = 0;


Application::Application():
	_pConfig(new LayeredConfiguration),
	_initialized(false),
	_logger(Logger::get("Application")),
	_unixOptions(true)
{
	setup();
}


Application::Application(int argc, char* argv[]):
	_pConfig(new LayeredConfiguration),
	_initialized(false),
	_logger(Logger::get("Application")),
	_unixOptions(true)
{
	setup();
	init(argc, argv);
}


Application::~Application()
{
	try
	{
		uninitialize();
	}
	catch (...)
	{
	}
	_pInstance = 0;
}


void Application::setup()
{
	poco_assert (_pInstance == 0);

	_pConfig->add(new SystemConfiguration);
	_pConfig->add(new MapConfiguration);
	addSubsystem(new LoggingSubsystem);
	
#if defined(POCO_OS_FAMILY_UNIX)
	#if !defined(_DEBUG)
	Foundation::SignalHandler::install();
	#endif
#else
	setUnixOptions(false);
#endif

	_pInstance = this;

	AutoPtr<ConsoleChannel> pCC = new ConsoleChannel;
	_logger.setChannel(pCC);
}


void Application::addSubsystem(Subsystem* pSubsystem)
{
	poco_check_ptr (pSubsystem);

	_subsystems.push_back(pSubsystem);
}


void Application::init(int argc, char* argv[])
{
	setArgs(argc, argv);
	Path appPath;
	getApplicationPath(appPath);
	_pConfig->setString("application.path", appPath.toString());
	_pConfig->setString("application.name", appPath.getFileName());
	_pConfig->setString("application.baseName", appPath.getBaseName());
	_pConfig->setString("application.dir", appPath.parent().toString());
	processOptions();
	initialize(*this);
	_initialized = true;
}


const char* Application::name() const
{
	return "Application";
}


void Application::initialize(const Application& self)
{
	for (SubsystemVec::iterator it = _subsystems.begin(); it != _subsystems.end(); ++it)
	{
		_logger.debug(std::string("Initializing subsystem: ") + (*it)->name());
		(*it)->initialize(self);
	}
}

	
void Application::uninitialize()
{
	if (_initialized)
	{
		for (SubsystemVec::reverse_iterator it = _subsystems.rbegin(); it != _subsystems.rend(); ++it)
		{
			_logger.debug(std::string("Uninitializing subsystem: ") + (*it)->name());
			(*it)->uninitialize();
		}
	}
}


void Application::reinitialize(const Application& self)
{
	for (SubsystemVec::iterator it = _subsystems.begin(); it != _subsystems.end(); ++it)
	{
		_logger.debug(std::string("Re-initializing subsystem: ") + (*it)->name());
		(*it)->reinitialize(self);
	}
}


void Application::setUnixOptions(bool flag)
{
	_unixOptions = flag;
}


int Application::loadConfiguration()
{
	int n = 0;
	Path appPath;
	getApplicationPath(appPath);
	appPath.setExtension("properties");
	if (File(appPath).exists())
	{
		_pConfig->add(new PropertyFileConfiguration(appPath.toString()));
		++n;
	}
	appPath.setExtension("ini");
	if (File(appPath).exists())
	{
		_pConfig->add(new IniFileConfiguration(appPath.toString()));
		++n;
	}
	appPath.setExtension("xml");
	if (File(appPath).exists())
	{
		_pConfig->add(new XMLConfiguration(appPath.toString()));
		++n;
	}
	return n;
}


void Application::loadConfiguration(const std::string& path)
{
	Path confPath(path);
	std::string ext = confPath.getExtension();
	if (icompare(ext, "properties") == 0)
		_pConfig->add(new PropertyFileConfiguration(confPath.toString()));
	else if (icompare(ext, "ini") == 0)
		_pConfig->add(new IniFileConfiguration(confPath.toString()));
	else if (icompare(ext, "xml") == 0)
		_pConfig->add(new XMLConfiguration(confPath.toString()));
	else
		throw Foundation::InvalidArgumentException("Unsupported configuration file type", ext);
}


std::string Application::commandName() const
{
	return _pConfig->getString("application.baseName");
}


int Application::run()
{
	try
	{
		return main(_args);
	}
	catch (Foundation::Exception& exc)
	{
		logger().log(exc);
		return EXIT_SOFTWARE;
	}
}


int Application::main(const std::vector<std::string>& args)
{
	return EXIT_OK;
}


void Application::setArgs(int argc, char* argv[])
{
	_command = argv[0];
	_pConfig->setInt("application.argc", argc);
	_args.reserve(argc);
	std::string argvKey = "application.argv[";
	for (int i = 0; i < argc; ++i)
	{
		std::string arg(argv[i]);
		_pConfig->setString(argvKey + NumberFormatter::format(i) + "]", arg);
		_args.push_back(arg);
	}
}


void Application::processOptions()
{
	defineOptions(_options);
	OptionProcessor processor(_options);
	processor.setUnixStyle(_unixOptions);
	ArgVec::iterator it = _args.begin();
	_args.erase(it);
	while (it != _args.end())
	{
		std::string name;
		std::string value;
		if (processor.process(*it, name, value))
		{
			handleOption(name, value);
			_args.erase(it);
		}
		else ++it;
	}
}


void Application::getApplicationPath(Foundation::Path& appPath)
{
#if defined(POCO_OS_FAMILY_UNIX)
	if (_command.find('/') != std::string::npos)
	{
		Path path(_command);
		if (path.isAbsolute())
		{
			appPath = path;
		}
		else
		{
			appPath = Path::current();
			appPath.append(path);
		}
	}
	else
	{
		if (!Path::find(Environment::get("PATH"), _command, appPath))
			appPath = Path(Path::current(), _command);
	}
#elif defined(POCO_OS_FAMILY_WINDOWS)
	char path[1024];
	int n = GetModuleFileName(0, path, sizeof(path));
	if (n > 0)
		appPath = path;
	else
		throw SystemException("Cannot get application file name.");
#else
	appPath = _command;
#endif
}


void Application::defineOptions(OptionSet& options)
{
}


void Application::handleOption(const std::string& name, const std::string& value)
{
}


Util_END