Example #1
0
XN_C_API void xnLogWriteNoEntry(const XnChar* csLogMask, XnLogSeverity nSeverity, const XnChar* csFormat, ...)
{
	if (!xnLogIsEnabled(csLogMask, nSeverity))
		return;

	if (g_xnLoggerData.m_bWriteToFile)
	{
		va_list args;
		va_start(args, csFormat);

		const XnUInt32 nMaxMessageSize = 1024;
		XnChar csMessage[nMaxMessageSize+1];
		XnUInt32 nChars;
		xnOSStrFormatV(csMessage, nMaxMessageSize, &nChars, csFormat, args);

		va_end(args);

		xnOSWriteFile(g_xnLoggerData.m_fLogFile, csMessage, nChars);
	}

	if (g_xnLoggerData.m_bWriteToConsole)
	{
		va_list args;
		va_start(args, csFormat);
		vprintf(csFormat, args);
		va_end(args);
	}
}
Example #2
0
XnStatus xnDumpCreate(XnDump* pDump, const XnChar* csHeader, const XnChar* csFileNameFormat, va_list args)
{
    XnStatus nRetVal = XN_STATUS_OK;

    XnChar strFileName[XN_FILE_MAX_PATH];
    XnUInt32 nChars;
    nRetVal = xnOSStrFormatV(strFileName, XN_FILE_MAX_PATH, &nChars, csFileNameFormat, args);
    XN_IS_STATUS_OK(nRetVal);

    XnChar strFullPath[XN_FILE_MAX_PATH];
    nRetVal = xnLogCreateNewFile(strFileName, TRUE, strFullPath, XN_FILE_MAX_PATH, &pDump->hFile);
    if (nRetVal != XN_STATUS_OK)
    {
        // we don't have much to do if files can't be open. Dump will not be written
        xnLogWarning(XN_MASK_LOG, "Couldn't create dump file %s! Dump will not be written", strFileName);
        pDump->hFile = XN_INVALID_FILE_HANDLE;
        return nRetVal;
    }

    if (csHeader != NULL)
    {
        xnOSWriteFile(pDump->hFile, csHeader, (XnUInt32)strlen(csHeader));
    }

    return XN_STATUS_OK;
}
Example #3
0
void xnLogWriteImplV(const XnChar* /*csLogMask*/, XnLogSeverity nSeverity, const XnChar* csFile, XnUInt32 nLine, const XnChar* csFormat, va_list args)
{
	// take time
	XnUInt64 nNow;
	xnOSGetHighResTimeStamp(&nNow);

	// write timestamp and severity
	const XnChar* csSeverity = xnLogGetSeverityString(nSeverity);

	const XnUInt32 nMaxMessageSize = 2047;
	XnChar csMessage[nMaxMessageSize+1];
	XnUInt32 nChars = 0;
	XnUInt32 nMessageLen = 0;

	// write timestamp
	xnOSStrFormat(csMessage + nMessageLen, nMaxMessageSize - nMessageLen, &nChars, "%8llu\t[%s]\t", nNow, csSeverity);
	nMessageLen += nChars;

	XnUInt32 nLineInfoBegin = nMessageLen;

	if (g_xnLoggerData.m_bWriteLineInfo)
	{
		// write line info
		XnChar fileName[XN_FILE_MAX_PATH];
		XnStatus nRetVal = xnOSGetFileName(csFile, fileName, sizeof(fileName));
		if (nRetVal == XN_STATUS_OK)
		{
			xnOSStrFormat(csMessage + nMessageLen, nMaxMessageSize - nMessageLen, &nChars, "%s\t%d\t", fileName, nLine);
			nMessageLen += nChars;
		}
	}

	XnUInt32 nLineInfoEnd = nMessageLen;

	// write message
	xnOSStrFormatV(csMessage + nMessageLen, nMaxMessageSize - nMessageLen, &nChars, csFormat, args);
	nMessageLen += nChars;
	XnUInt32 nUserMsgLen = nChars;

	// write end-of-line
	xnOSStrFormat(csMessage + nMessageLen, nMaxMessageSize - nMessageLen, &nChars, XN_NEW_LINE_SEP);
	nMessageLen += nChars;

	if (g_xnLoggerData.m_bWriteToFile)
	{
		xnOSWriteFile(g_xnLoggerData.m_fLogFile, csMessage, nMessageLen);
	}

	if (g_xnLoggerData.m_bWriteToConsole)
	{
		// Write to console without line info
		XnChar cSaveChar = csMessage[nLineInfoBegin];
		csMessage[nLineInfoBegin] = '\0';
		printf("%s", csMessage);
		csMessage[nLineInfoBegin] = cSaveChar;
		//printf should know how to translate '\n' to proper newline on every platform so we don't need XN_NEW_LINE_SEP here
		printf("%s", csMessage + nLineInfoEnd);
	}

}
Example #4
0
void setErrorState(const char* strFormat, ...)
{
	va_list args;
	XnUInt32 nWritten;
	va_start(args, strFormat);
	xnOSStrFormatV(g_DrawConfig.strErrorState, sizeof(g_DrawConfig.strErrorState), &nWritten, strFormat, args);
	va_end(args);
}
Example #5
0
XnDumpFile* xnDumpFileOpenImpl(const XnChar* strDumpName, XnBool bForce, XnBool bSessionDump, const XnChar* strNameFormat, va_list args)
{
    XnStatus nRetVal = XN_STATUS_OK;

    DumpData& dumpData = DumpData::GetInstance();

    // check if there are writers
    if (dumpData.writers.IsEmpty())
    {
        return NULL;
    }

    if (!bForce)
    {
        if (!xnLogIsDumpMaskEnabled(strDumpName))
        {
            return NULL;
        }
    }

    // format file name
    XnChar strFileName[XN_FILE_MAX_PATH];
    XnUInt32 nChars;
    nRetVal = xnOSStrFormatV(strFileName, XN_FILE_MAX_PATH, &nChars, strNameFormat, args);
    if (nRetVal != XN_STATUS_OK)
    {
        XN_ASSERT(FALSE);
        return NULL;
    }

    // create a handle that will hold all handles to all writers
    XnDumpFile* pFile = XN_NEW(XnDumpFile);

    // try to add writers
    for (XnDumpWriters::Iterator it = dumpData.writers.Begin(); it != dumpData.writers.End(); ++it)
    {
        XnDumpWriterFile writerFile;
        writerFile.pWriter = *it;
        writerFile.hFile = writerFile.pWriter->OpenFile(writerFile.pWriter->pCookie, strDumpName, bSessionDump, strFileName);
        XN_ASSERT(writerFile.hFile.pInternal != NULL);
        if (writerFile.hFile.pInternal != NULL)
        {
            nRetVal = pFile->m_writersFiles.AddLast(writerFile);
            XN_ASSERT(nRetVal == XN_STATUS_OK);
        }
    }

    // check if any writer succeeded
    if (pFile->m_writersFiles.IsEmpty())
    {
        // no file. Release memory
        XN_DELETE(pFile);
        return NULL;
    }

    // return the file pointer
    return pFile;
}
Example #6
0
void displayError(const char* csFormat, ...)
{
	g_DrawConfig.messageType = ERROR_MESSAGE;
	g_DrawConfig.bShowMessage = true;
	va_list args;
	va_start(args, csFormat);
	XnUInt32 nCount;
	xnOSStrFormatV(g_csUserMessage, sizeof(g_csUserMessage), &nCount, csFormat, args);
	va_end(args);
}
Example #7
0
static void xnLogCreateEntryV(XnBufferedLogEntry* pEntry, const XnChar* csLogMask, XnLogSeverity nSeverity, const XnChar* csFile, XnUInt32 nLine, const XnChar* csFormat, va_list args)
{
	// format message
	XnUInt32 nChars;
	xnOSStrFormatV(pEntry->Buffer(), pEntry->MaxBufferSize(), &nChars, csFormat, args);

	// create log entry
	xnOSGetHighResTimeStamp(&pEntry->nTimestamp);
	pEntry->nSeverity = nSeverity;
	pEntry->strSeverity = xnLogGetSeverityString(nSeverity);
	pEntry->strMask = csLogMask;
	pEntry->strFile = csFile;
	pEntry->nLine = nLine;
}
Example #8
0
XN_C_API XnStatus xnOSStrFormat(XnChar* cpDestString, const XnUInt32 nDestLength, XnUInt32* pnCharsWritten, const XnChar* cpFormat, ...)
{
	XnStatus nRetVal = XN_STATUS_OK;

	va_list args;
	va_start(args, cpFormat);

	nRetVal = xnOSStrFormatV(cpDestString, nDestLength, pnCharsWritten, cpFormat, args);
	XN_IS_STATUS_OK(nRetVal);

	va_end(args);

	// All is good...
	return (XN_STATUS_OK);
}
Example #9
0
void xnLogWriteNoEntryImplV(const XnChar* csFormat, va_list args)
{
	const XnUInt32 nMaxMessageSize = 1024;
	XnChar csMessage[nMaxMessageSize+1];
	XnUInt32 nChars;
	xnOSStrFormatV(csMessage, nMaxMessageSize, &nChars, csFormat, args);

	LogData& logData = LogData::GetInstance();
	xnl::AutoCSLocker locker(logData.hLock);
	for (XnLogWritersList::ConstIterator it = logData.writers.Begin(); it != logData.writers.End(); ++it)
	{
		const XnLogWriter* pWriter = *it;
		pWriter->WriteUnformatted(csMessage, pWriter->pCookie);
	}
}
Example #10
0
XN_C_API void xnDumpWriteStringImpl(XnDump dump, const XnChar* csFormat, ...)
{
    if (dump.hFile != XN_INVALID_FILE_HANDLE)
    {
        const XnUInt32 nStringLength = 1024;
        XnChar csString[1024];

        va_list args;
        va_start(args, csFormat);

        // format message
        XnUInt32 nChars;
        xnOSStrFormatV(csString, nStringLength, &nChars, csFormat, args);

        // and write it to file
        xnOSWriteFile(dump.hFile, csString, nChars);

        va_end(args);
    }
}
Example #11
0
XN_C_API void XN_C_DECL _xnDumpFileWriteString(XnDumpFile* pFile, const XnChar* strFormat, ...)
{
    XnStatus nRetVal = XN_STATUS_OK;
    XN_REFERENCE_VARIABLE(nRetVal);

    if (pFile == NULL)
    {
        return;
    }

    // format string
    XnChar strBuffer[XN_DUMP_MAX_FORMATTED_STRING_LENGTH];
    XnUInt32 nCharsWritten;
    va_list args;
    va_start(args, strFormat);
    nRetVal = xnOSStrFormatV(strBuffer, sizeof(strBuffer), &nCharsWritten, strFormat, args);
    XN_ASSERT(nRetVal == XN_STATUS_OK);
    va_end(args);

    _xnDumpFileWriteBuffer(pFile, (const XnUInt8*)strBuffer, nCharsWritten);
}
Example #12
0
XN_C_API void xnLogWriteNoEntry(const XnChar* csLogMask, XnLogSeverity nSeverity, const XnChar* csFormat, ...)
{
	if (!xnLogIsEnabled(csLogMask, nSeverity))
		return;

	va_list args;
	va_start(args, csFormat);

	const XnUInt32 nMaxMessageSize = 1024;
	XnChar csMessage[nMaxMessageSize+1];
	XnUInt32 nChars;
	xnOSStrFormatV(csMessage, nMaxMessageSize, &nChars, csFormat, args);

	va_end(args);

	for (XnLogWritersList::ConstIterator it = g_logData.m_writers.begin(); it != g_logData.m_writers.end(); ++it)
	{
		const XnLogWriter* pWriter = *it;
		pWriter->WriteUnformatted(csMessage, pWriter->pCookie);
	}
}