2008-05-13 23:26:52 +00:00
|
|
|
/*
|
|
|
|
---------------------------------------------------------------------------
|
2008-05-22 10:20:31 +00:00
|
|
|
Open Asset Import Library (ASSIMP)
|
2008-05-13 23:26:52 +00:00
|
|
|
---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
Copyright (c) 2006-2008, ASSIMP Development Team
|
|
|
|
|
|
|
|
All rights reserved.
|
|
|
|
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
|
|
with or without modification, are permitted provided that the following
|
|
|
|
conditions are met:
|
|
|
|
|
|
|
|
* Redistributions of source code must retain the above
|
|
|
|
copyright notice, this list of conditions and the
|
|
|
|
following disclaimer.
|
|
|
|
|
|
|
|
* 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.
|
|
|
|
|
|
|
|
* Neither the name of the ASSIMP team, nor the names of its
|
|
|
|
contributors may be used to endorse or promote products
|
|
|
|
derived from this software without specific prior
|
|
|
|
written permission of the ASSIMP Development Team.
|
|
|
|
|
|
|
|
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.
|
|
|
|
---------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
2008-05-26 21:28:19 +00:00
|
|
|
#include "../include/DefaultLogger.h"
|
2008-05-21 15:35:28 +00:00
|
|
|
#include "../include/aiAssert.h"
|
2008-05-08 20:02:51 +00:00
|
|
|
#include "DefaultIOSystem.h"
|
|
|
|
#include "Win32DebugLogStream.h"
|
2008-05-21 15:35:28 +00:00
|
|
|
#include "../include/IOStream.h"
|
2008-05-08 20:02:51 +00:00
|
|
|
#include "FileLogStream.h"
|
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
|
|
|
|
namespace Assimp
|
|
|
|
{
|
|
|
|
// ---------------------------------------------------------------------------
|
2008-05-25 22:29:05 +00:00
|
|
|
NullLogger DefaultLogger::s_pNullLogger;
|
|
|
|
Logger *DefaultLogger::m_pLogger = &DefaultLogger::s_pNullLogger;
|
2008-05-08 20:02:51 +00:00
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
struct LogStreamInfo
|
|
|
|
{
|
|
|
|
unsigned int m_uiErrorSeverity;
|
|
|
|
LogStream *m_pStream;
|
|
|
|
|
|
|
|
// Constructor
|
|
|
|
LogStreamInfo( unsigned int uiErrorSev, LogStream *pStream ) :
|
|
|
|
m_uiErrorSeverity( uiErrorSev ),
|
|
|
|
m_pStream( pStream )
|
|
|
|
{
|
|
|
|
// empty
|
|
|
|
}
|
|
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Creates the only singleton instance
|
|
|
|
Logger *DefaultLogger::create(const std::string &name, LogSeverity severity)
|
|
|
|
{
|
|
|
|
m_pLogger = new DefaultLogger( name, severity );
|
|
|
|
|
|
|
|
return m_pLogger;
|
|
|
|
}
|
2008-05-25 22:29:05 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void DefaultLogger::set (Logger *logger)
|
|
|
|
{
|
|
|
|
if (!logger)
|
|
|
|
{
|
|
|
|
DefaultLogger::m_pLogger = &s_pNullLogger;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
DefaultLogger::m_pLogger = logger;
|
|
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
bool DefaultLogger::isNullLogger()
|
|
|
|
{
|
|
|
|
return m_pLogger == &s_pNullLogger;
|
|
|
|
}
|
2008-05-08 20:02:51 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Singleton getter
|
|
|
|
Logger *DefaultLogger::get()
|
|
|
|
{
|
|
|
|
return m_pLogger;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Kills the only instance
|
|
|
|
void DefaultLogger::kill()
|
|
|
|
{
|
|
|
|
ai_assert (NULL != m_pLogger);
|
|
|
|
delete m_pLogger;
|
2008-05-25 22:29:05 +00:00
|
|
|
m_pLogger = &s_pNullLogger;
|
2008-05-08 20:02:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Debug message
|
|
|
|
void DefaultLogger::debug(const std::string &message)
|
|
|
|
{
|
|
|
|
if ( m_Severity == Logger::NORMAL )
|
|
|
|
return;
|
|
|
|
|
|
|
|
const std::string msg( "Debug: " + message );
|
|
|
|
writeToStreams( msg, Logger::DEBUGGING );
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Logs an info
|
|
|
|
void DefaultLogger::info(const std::string &message)
|
|
|
|
{
|
|
|
|
const std::string msg( "Info: " + message );
|
|
|
|
writeToStreams( msg , Logger::INFO );
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Logs a warning
|
|
|
|
void DefaultLogger::warn( const std::string &message )
|
|
|
|
{
|
|
|
|
const std::string msg( "Warn: " + message );
|
|
|
|
writeToStreams( msg, Logger::WARN );
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Logs an error
|
|
|
|
void DefaultLogger::error( const std::string &message )
|
|
|
|
{
|
|
|
|
const std::string msg( "Error: " + message );
|
|
|
|
writeToStreams( msg, Logger::ERR );
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Severity setter
|
|
|
|
void DefaultLogger::setLogSeverity( LogSeverity log_severity )
|
|
|
|
{
|
|
|
|
m_Severity = log_severity;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Attachs a new stream
|
|
|
|
void DefaultLogger::attachStream( LogStream *pStream, unsigned int severity )
|
|
|
|
{
|
|
|
|
ai_assert ( NULL != pStream );
|
2008-05-25 22:29:05 +00:00
|
|
|
|
|
|
|
// fix (Aramis)
|
|
|
|
if (0 == severity)
|
|
|
|
{
|
|
|
|
severity = Logger::INFO | Logger::ERR | Logger::WARN | Logger::DEBUGGING;
|
|
|
|
}
|
|
|
|
|
|
|
|
for ( StreamIt it = m_StreamArray.begin();
|
|
|
|
it != m_StreamArray.end();
|
|
|
|
++it )
|
|
|
|
{
|
|
|
|
if ( (*it)->m_pStream == pStream )
|
|
|
|
{
|
|
|
|
(*it)->m_uiErrorSeverity |= severity;
|
2008-08-08 01:05:56 +00:00
|
|
|
return;
|
2008-05-25 22:29:05 +00:00
|
|
|
}
|
|
|
|
}
|
2008-05-08 20:02:51 +00:00
|
|
|
|
|
|
|
LogStreamInfo *pInfo = new LogStreamInfo( severity, pStream );
|
|
|
|
m_StreamArray.push_back( pInfo );
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Detatch a stream
|
|
|
|
void DefaultLogger::detatchStream( LogStream *pStream, unsigned int severity )
|
|
|
|
{
|
|
|
|
ai_assert ( NULL != pStream );
|
2008-05-25 22:29:05 +00:00
|
|
|
|
|
|
|
// fix (Aramis)
|
|
|
|
if (0 == severity)
|
|
|
|
{
|
|
|
|
severity = Logger::INFO | Logger::ERR | Logger::WARN | Logger::DEBUGGING;
|
|
|
|
}
|
2008-05-08 20:02:51 +00:00
|
|
|
|
|
|
|
for ( StreamIt it = m_StreamArray.begin();
|
|
|
|
it != m_StreamArray.end();
|
|
|
|
++it )
|
|
|
|
{
|
|
|
|
if ( (*it)->m_pStream == pStream )
|
|
|
|
{
|
|
|
|
unsigned int uiSev = (*it)->m_uiErrorSeverity;
|
|
|
|
if ( severity & Logger::INFO )
|
|
|
|
uiSev &= ( ~Logger::INFO );
|
|
|
|
if ( severity & Logger::WARN )
|
|
|
|
uiSev &= ( ~Logger::WARN );
|
|
|
|
if ( severity & Logger::ERR )
|
|
|
|
uiSev &= ( ~Logger::ERR );
|
2008-05-25 22:29:05 +00:00
|
|
|
// fix (Aramis)
|
|
|
|
if ( severity & Logger::DEBUGGING )
|
|
|
|
uiSev &= ( ~Logger::DEBUGGING );
|
2008-05-08 20:02:51 +00:00
|
|
|
|
|
|
|
(*it)->m_uiErrorSeverity = uiSev;
|
|
|
|
|
|
|
|
if ( (*it)->m_uiErrorSeverity == 0 )
|
|
|
|
{
|
|
|
|
it = m_StreamArray.erase( it );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Constructor
|
|
|
|
DefaultLogger::DefaultLogger( const std::string &name, LogSeverity severity ) :
|
|
|
|
m_Severity( severity )
|
|
|
|
{
|
2008-05-27 18:58:36 +00:00
|
|
|
#ifdef WIN32
|
2008-05-13 23:26:52 +00:00
|
|
|
m_Streams.push_back( new Win32DebugLogStream() );
|
2008-05-08 20:02:51 +00:00
|
|
|
if (name.empty())
|
|
|
|
return;
|
2008-05-27 18:58:36 +00:00
|
|
|
#endif
|
2008-05-08 20:02:51 +00:00
|
|
|
|
|
|
|
m_Streams.push_back( new FileLogStream( name ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Destructor
|
|
|
|
DefaultLogger::~DefaultLogger()
|
|
|
|
{
|
|
|
|
for ( StreamIt it = m_StreamArray.begin();
|
|
|
|
it != m_StreamArray.end();
|
|
|
|
++it )
|
|
|
|
{
|
|
|
|
delete *it;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (std::vector<LogStream*>::iterator it = m_Streams.begin();
|
|
|
|
it != m_Streams.end();
|
|
|
|
++it)
|
|
|
|
{
|
|
|
|
delete *it;
|
|
|
|
}
|
|
|
|
m_Streams.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Writes message to stream
|
|
|
|
void DefaultLogger::writeToStreams(const std::string &message,
|
|
|
|
ErrorSeverity ErrorSev )
|
|
|
|
{
|
|
|
|
if ( message.empty() )
|
|
|
|
return;
|
|
|
|
|
|
|
|
for ( ConstStreamIt it = this->m_StreamArray.begin();
|
|
|
|
it != m_StreamArray.end();
|
|
|
|
++it)
|
|
|
|
{
|
|
|
|
if ( ErrorSev & (*it)->m_uiErrorSeverity )
|
|
|
|
{
|
|
|
|
(*it)->m_pStream->write( message );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (std::vector<LogStream*>::iterator it = m_Streams.begin();
|
|
|
|
it != m_Streams.end();
|
|
|
|
++it)
|
|
|
|
{
|
|
|
|
(*it)->write( message + std::string("\n"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
} // Namespace Assimp
|