PDA

View Full Version : Error in building QuickFix library in Exceptions.h



Bsbosa.com
07-11-2010, 11:08 PM
Hi
I am in the process of learning FIX protocol using QuickFix, I am following the example which is given in the documentation,however I am getting an error during build in one file which is part of the quickfix header file.

Can anyone please let me know if I am missing anything in my project configuration. Just as an FYI I did follow all the instruction in quickfix website to set up a C++ project.

Regards
Arup

Error:
---------------------
1>c:\project\quickfix\quickfix_c\quickfix\include\qu ickfix\exceptions.h(260) : error C2664: 'FormatMessageW' : cannot convert parameter 5 from 'char [2048]' to 'LPWSTR'1> Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast


Code of Exceptions.h. The error is in line 260 which is as follows:

#ifdef _MSC_VER
error = WSAGetLastError();
char buffer[2048];
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
buffer, 2048, NULL );
return buffer;
#else
Exceptions.h
-------------------------

/* -*- C++ -*- */
/************************************************** **************************
** Copyright (c) quickfixengine.org All rights reserved.
**
** This file is part of the QuickFIX FIX Engine
**
** This file may be distributed under the terms of the quickfixengine.org
** license as defined by quickfixengine.org and appearing in the file
** LICENSE included in the packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.quickfixengine.org/LICENSE for licensing information.
**
** Contact ask@quickfixengine.org if any conditions of this licensing are
** not clear to you.
**
************************************************** **************************/
#ifndef FIX_EXCEPTIONS_H
#define FIX_EXCEPTIONS_H

#include #include #include "Utility.h"
namespace FIX
{

/// Base QuickFIX exception type.
struct Exception : public std::logic_error
{
Exception( const std::string& t, const std::string& d )
: std::logic_error( d.size() ? t + ": " + d : t ),
type( t ), detail( d )
{}
~Exception() throw() {}

std::string type;
std::string detail;
};

/// DataDictionary not found for BeginString or ApplVerID
struct DataDictionaryNotFound : public Exception
{
DataDictionaryNotFound( const std::string& v, const std::string& what = "" )
: Exception( "Could not find data dictionary", what ),
version( v ) {}
~DataDictionaryNotFound() throw() {}

std::string version;
};

/// Field not found inside a message
struct FieldNotFound : public Exception
{
FieldNotFound( int f = 0, const std::string& what = "" )
: Exception( "Field not found", what ),
field( f ) {}
int field;
};

/// Unable to convert field into its native format
struct FieldConvertError : public Exception
{
FieldConvertError( const std::string& what = "" )
: Exception( "Could not convert field", what ) {}
};

/// Unable to parse message
struct MessageParseError : public Exception
{
MessageParseError( const std::string& what = "" )
: Exception( "Could not parse message", what ) {}
};

/// Not a recognizable message
struct InvalidMessage : public Exception
{
InvalidMessage( const std::string& what = "" )
: Exception( "Invalid message", what ) {}
};

/// %Application is not configured correctly
struct ConfigError : public Exception
{
ConfigError( const std::string& what = "" )
: Exception( "Configuration failed", what ) {}
};

/// %Application encountered serious error during runtime
struct RuntimeError : public Exception
{
RuntimeError( const std::string& what = "" )
: Exception( "Runtime error", what ) {}
};

/// Tag number does not exist in specification
struct InvalidTagNumber : public Exception
{
InvalidTagNumber( int f = 0, const std::string& what = "" )
: Exception( "Invalid tag number", what ),
field( f ) {}
int field;
};

/// Required field is not in message
struct RequiredTagMissing : public Exception
{
RequiredTagMissing( int f = 0, const std::string& what = "" )
: Exception( "Required tag missing", what ),
field( f ) {}
int field;
};

/// Field does not belong to message
struct TagNotDefinedForMessage : public Exception
{
TagNotDefinedForMessage( int f = 0, const std::string& what = "" )
: Exception( "Tag not defined for this message type", what ),
field( f ) {}
int field;
};

/// Field exists in message without a value
struct NoTagValue : public Exception
{
NoTagValue( int f = 0, const std::string& what = "" )
: Exception( "Tag specified without a value", what ),
field( f ) {}
int field;
};

/// Field has a value that is out of range
struct IncorrectTagValue : public Exception
{
IncorrectTagValue( int f = 0, const std::string& what = "" )
: Exception( "Value is incorrect (out of range) for this tag", what ),
field( f ) {}
int field;
};

/// Field has a badly formatted value
struct IncorrectDataFormat : public Exception
{
IncorrectDataFormat( int f = 0, const std::string& what = "" )
: Exception( "Incorrect data format for value", what ),
field( f ) {}
int field;
};

/// Message is not structured correctly
struct IncorrectMessageStructure : public Exception
{
IncorrectMessageStructure( const std::string& what = "" )
: Exception( "Incorrect message structure", what ) {}
};

/// Field shows up twice in the message
struct DuplicateFieldNumber : public Exception
{
DuplicateFieldNumber( const std::string& what = "" )
: Exception( "Duplicate field number", what ) {}
};

/// Not a known message type
struct InvalidMessageType : public Exception
{
InvalidMessageType( const std::string& what = "" )
: Exception( "Invalid Message Type", what ) {}
};

/// Message type not supported by application
struct UnsupportedMessageType : public Exception
{
UnsupportedMessageType( const std::string& what = "" )
: Exception( "Unsupported Message Type", what ) {}
};

/// Version of %FIX is not supported
struct UnsupportedVersion : public Exception
{
UnsupportedVersion( const std::string& what = "" )
: Exception( "Unsupported Version", what ) {}
};

/// Tag is not in the correct order
struct TagOutOfOrder : public Exception
{
TagOutOfOrder( int f = 0, const std::string& what = "" )
: Exception( "Tag specified out of required order", what ),
field( f ) {}
int field;
};

/// Repeated tag not part of repeating group
struct RepeatedTag : public Exception
{
RepeatedTag( int f = 0, const std::string& what = "" )
: Exception( "Repeated tag not part of repeating group", what ),
field( f ) {}
int field;
};

/// Repeated group count not equal to actual count
struct RepeatingGroupCountMismatch : public Exception
{
RepeatingGroupCountMismatch( int f = 0, const std::string& what = "" )
: Exception( "Repeating group count mismatch", what ),
field( f ) {}
int field;
};

/// Indicates user does not want to send a message
struct DoNotSend : public Exception
{
DoNotSend( const std::string& what = "" )
: Exception( "Do Not Send Message", what ) {}
};

/// User wants to reject permission to logon
struct RejectLogon : public Exception
{
RejectLogon( const std::string& what = "" )
: Exception( "Rejected Logon Attempt", what ) {}
};

/// Session cannot be found for specified action
struct SessionNotFound : public Exception
{
SessionNotFound( const std::string& what = "" )
: Exception( "Session Not Found", what ) {}
};

/// IO Error
struct IOException : public Exception
{
IOException( const std::string& what = "" )
: Exception( "IO Error", what ) {}
};

/// Socket Error
struct SocketException : public Exception
{
SocketException()
: Exception( "Socket Error", errorToWhat() ) {}

SocketException( const std::string& what )
: Exception( "Socket Error", what ) {}

std::string errorToWhat()
{
#ifdef _MSC_VER
error = WSAGetLastError();
char buffer[2048];
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
buffer, 2048, NULL );
return buffer;
#else error = errno;
return strerror( error );
#endif }

int error;
};

/// Socket send operation failed
struct SocketSendFailed : public SocketException
{
SocketSendFailed() {}
SocketSendFailed( const std::string& what )
: SocketException( what ) {}
};

/// Socket recv operation failed
struct SocketRecvFailed : public SocketException
{
SocketRecvFailed( int size )
: SocketException( size == 0 ? "Connection reset by peer." : size <span class="code-keyword">