quickfix_ruby 1.14.3

data/ext/quickfix/FlexLexer.h

@@ -0,0 +1,188 @@
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+//  by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+// Redistribution and use in source and binary forms with or without
+// modification are permitted provided that: (1) source distributions retain
+// this entire copyright notice and comment, and (2) distributions including
+// binaries display the following acknowledgement:  ``This product includes
+// software developed by the University of California, Berkeley and its
+// contributors'' in the documentation or other materials provided with the
+// distribution and in all advertising materials mentioning features or use
+// of this software.  Neither the name of the University nor the names of
+// its contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.  You then
+// include <FlexLexer.h> in your other sources once per lexer class:
+//
+//#undef yyFlexLexer
+//#define yyFlexLexer xxFlexLexer
+//#include <FlexLexer.h>
+//
+//#undef yyFlexLexer
+//#define yyFlexLexer zzFlexLexer
+//#include <FlexLexer.h>
+//...
+
+#ifndef __FLEX_LEXER_H 
+// Never included before - need to define base class.
+#define __FLEX_LEXER_H
+#include <iostream>
+
+extern "C++"
+{
+
+  struct yy_buffer_state;
+  typedef int yy_state_type;
+
+  class FlexLexer
+  {
+  public:
+    virtual ~FlexLexer() { }
+
+    const char* YYText() { return yytext; }
+    int YYLeng() { return yyleng; }
+
+    virtual void
+    yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
+    virtual struct yy_buffer_state*
+          yy_create_buffer( std::istream* s, int size ) = 0;
+    virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
+    virtual void yyrestart( std::istream* s ) = 0;
+
+    virtual int yylex() = 0;
+
+    // Call yylex with new input/output sources.
+    int yylex( std::istream* new_in, std::ostream* new_out = 0 )
+{
+      switch_streams( new_in, new_out );
+      return yylex();
+    }
+
+    // Switch to new input/output streams.  A nil stream pointer
+    // indicates "keep the current one".
+    virtual void switch_streams( std::istream* new_in = 0,
+                                 std::ostream* new_out = 0 ) = 0;
+
+    int lineno() const{ return yylineno; }
+
+    int debug() const{ return yy_flex_debug; }
+    void set_debug( int flag ) { yy_flex_debug = flag; }
+
+  protected:
+    char* yytext;
+    int yyleng;
+    int yylineno; // only maintained if you use %option yylineno
+    int yy_flex_debug; // only has effect with -d or "%option debug"
+  }
+  ;
+
+}
+#endif
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce) 
+// Either this is the first time through (yyFlexLexerOnce not defined),
+// or this is a repeated include to define a different flavor of
+// yyFlexLexer, as discussed in the flex man page.
+#define yyFlexLexerOnce
+
+class yyFlexLexer : public FlexLexer
+{
+public:
+  // arg_yyin and arg_yyout default to the cin and cout, but we
+  // only make that assignment when initializing in yylex().
+  yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
+
+  virtual ~yyFlexLexer();
+
+  void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
+  struct yy_buffer_state* yy_create_buffer( std::istream* s, int size );
+  void yy_delete_buffer( struct yy_buffer_state* b );
+  void yyrestart( std::istream* s );
+
+  virtual int yylex();
+  virtual void switch_streams( std::istream* new_in, std::ostream* new_out );
+
+protected:
+  virtual int LexerInput( char* buf, int max_size );
+  virtual void LexerOutput( const char* buf, int size );
+  virtual void LexerError( const char* msg );
+
+  void yyunput( int c, char* buf_ptr );
+  int yyinput();
+
+  void yy_load_buffer_state();
+  void yy_init_buffer( struct yy_buffer_state* b, std::istream* s );
+  void yy_flush_buffer( struct yy_buffer_state* b );
+
+  int yy_start_stack_ptr;
+  int yy_start_stack_depth;
+  int* yy_start_stack;
+
+  void yy_push_state( int new_state );
+  void yy_pop_state();
+  int yy_top_state();
+
+  yy_state_type yy_get_previous_state();
+  yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+  int yy_get_next_buffer();
+
+  std::istream* yyin; // input source for default LexerInput
+  std::ostream* yyout; // output sink for default LexerOutput
+
+  struct yy_buffer_state* yy_current_buffer;
+
+  // yy_hold_char holds the character lost when yytext is formed.
+  char yy_hold_char;
+
+  // Number of characters read into yy_ch_buf.
+  int yy_n_chars;
+
+  // Points to current character in buffer.
+  char* yy_c_buf_p;
+
+  int yy_init; // whether we need to initialize
+  int yy_start; // start state number
+
+  // Flag which is used to allow yywrap()'s to do buffer switches
+  // instead of setting up a fresh yyin.  A bit of a hack ...
+  int yy_did_buffer_switch_on_eof;
+
+  // The following are not always needed, but may be depending
+  // on use of certain flex features (like REJECT or yymore()).
+
+  yy_state_type yy_last_accepting_state;
+  char* yy_last_accepting_cpos;
+
+  yy_state_type* yy_state_buf;
+  yy_state_type* yy_state_ptr;
+
+  char* yy_full_match;
+  int* yy_full_state;
+  int yy_full_lp;
+
+  int yy_lp;
+  int yy_looking_for_trail_begin;
+
+  int yy_more_flag;
+  int yy_more_len;
+  int yy_more_offset;
+  int yy_prev_more_offset;
+};
+
+#endif

data/ext/quickfix/Group.cpp

@@ -0,0 +1,64 @@
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** 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.
+**
+****************************************************************************/
+
+#ifdef _MSC_VER
+#include "stdafx.h"
+#else
+#include "config.h"
+#endif
+
+#include "Group.h"
+
+namespace FIX
+{
+void Group::addGroup( const Group& group )
+{
+  FieldMap::addGroup( group.field(), group );
+}
+
+void Group::replaceGroup( unsigned num, const FIX::Group& group )
+{
+  FieldMap::replaceGroup( num, group.field(), group ); 
+}
+
+Group& Group::getGroup( unsigned num, Group& group ) const throw( FieldNotFound )
+{
+  return static_cast < Group& > ( FieldMap::getGroup( num, group.field(), group ) );
+}
+
+void Group::removeGroup( unsigned num, const Group& group )
+{
+  FieldMap::removeGroup( num, group.field() );
+}
+
+void Group::removeGroup( const Group& group )
+{
+  FieldMap::removeGroup( group.field() );
+}
+
+bool Group::hasGroup( unsigned num, const Group& group )
+{
+  return FieldMap::hasGroup( num, group.field() );
+}
+
+bool Group::hasGroup( const Group& group )
+{
+  return FieldMap::hasGroup( group.field() );
+}
+}

data/ext/quickfix/Group.h

@@ -0,0 +1,73 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** 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_GROUP
+#define FIX_GROUP
+
+#ifdef _MSC_VER
+#pragma warning( disable: 4786 )
+#endif
+
+#include "FieldMap.h"
+#include "Fields.h"
+#include <vector>
+
+namespace FIX
+{
+/**
+ * Base class for all %FIX repeating groups.
+ *
+ * A group consists of a count field, deliminator, and a sorting order.
+ */
+class Group : public FieldMap
+{
+public:
+  Group( int field, int delim )
+  : FieldMap( message_order( delim, 0 ) ),
+    m_field( field ), m_delim( delim ) {}
+
+  Group( int field, int delim, const int order[] )
+  : FieldMap( order ), m_field( field ), m_delim( delim ) {}
+
+  Group( int field, int delim, const message_order& order )
+  : FieldMap( order ), m_field( field ), m_delim( delim ) {}
+
+  Group( const Group& copy )
+  : FieldMap( copy ), m_field( copy.m_field ), m_delim( copy.m_delim ) {}
+
+  int field() const { return m_field; }
+  int delim() const { return m_delim; }
+
+  void addGroup( const Group& group );
+  void replaceGroup( unsigned num, const Group& group );
+  Group& getGroup( unsigned num, Group& group ) const throw( FieldNotFound );
+  void removeGroup( unsigned num, const Group& group );
+  void removeGroup( const Group& group );
+  bool hasGroup( const Group& group );
+  bool hasGroup( unsigned num, const Group& group );
+
+private:
+  int m_field;
+  int m_delim;
+};
+}
+
+#endif //FIX_GROUP

data/ext/quickfix/HtmlBuilder.h

@@ -0,0 +1,186 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** 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 HTML_BUILDER_H
+#define HTML_BUILDER_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include <sstream>
+
+namespace HTML
+{
+class TAG
+{
+public:
+  TAG( const std::string& tag, std::ostream& stream )
+  : m_tag( tag ), m_stream( stream ) 
+  {
+    m_stream << "<" << m_tag;
+  }
+
+  virtual ~TAG() 
+  {
+    m_stream << m_value.str();
+    m_stream << "</" << m_tag << ">";
+  }
+
+  TAG& text()
+  { m_stream << ">"; return *this; }
+  TAG& text( const std::string& value )
+  { m_value << value; text(); return *this; }
+  TAG& text( int value )
+  { m_value << value; text(); return *this; } 
+
+ private:
+  std::string m_tag;
+  std::stringstream m_value;
+
+ protected:
+  std::ostream& m_stream;
+};
+
+class SPECIAL
+{
+ public:
+  SPECIAL( const std::string& value, std::ostream& stream )
+  {
+    stream << "&" << value << ";";
+  }
+};
+
+class A : public TAG
+{
+public:
+  A( std::ostream& stream )
+  : TAG( "A", stream ) {}
+
+  A& href( const std::string& value )
+  { m_stream << " href='" << value << "'"; return *this; }
+};
+
+class BODY : public TAG
+{
+public:
+  BODY( std::ostream& stream )
+  : TAG( "BODY", stream ) {}
+};
+
+class BR : public TAG
+{
+public:
+  BR( std::ostream& stream )
+  : TAG( "BR", stream ) {}
+};
+
+class CAPTION : public TAG
+{
+public:
+  CAPTION( std::ostream& stream )
+  : TAG( "CAPTION", stream ) {}
+};
+
+class CENTER : public TAG
+{
+public:
+  CENTER( std::ostream& stream )
+  : TAG( "CENTER", stream ) {}
+};
+
+class EM : public TAG
+{
+public:
+  EM( std::ostream& stream )
+  : TAG( "EM", stream ) {}
+};
+
+class H1 : public TAG
+{
+public:
+  H1( std::ostream& stream )
+  : TAG( "H1", stream ) {}
+};
+
+class H2 : public TAG
+{
+public:
+  H2( std::ostream& stream )
+  : TAG( "H2", stream ) {}
+};
+
+class HEAD : public TAG
+{
+public:
+  HEAD( std::ostream& stream )
+  : TAG( "HEAD", stream ) {}
+};
+
+class HR : public TAG
+{
+public:
+  HR( std::ostream& stream )
+  : TAG( "HR", stream ) {}
+};
+
+const char* NBSP = "&nbsp;";
+
+class TABLE : public TAG
+{
+public:
+  TABLE( std::ostream& stream )
+  : TAG( "TABLE", stream ) {}
+
+  TABLE& border( int value )
+  { m_stream << " border='" << value << "'"; return *this; }
+  TABLE& cellspacing( int value )
+  { m_stream << " cellspacing='" << value << "'"; return *this; }
+  TABLE& width( int value )
+  { m_stream << " width='" << value << "%'"; return *this; }
+};
+
+class TD : public TAG
+{
+public:
+  TD( std::ostream& stream )
+  : TAG( "TD", stream ) {}
+
+  TD& align( const std::string& value )
+  { m_stream << " align='" << value << "'"; return *this; }
+};
+
+class TITLE : public TAG
+{
+public:
+  TITLE( std::ostream& stream )
+  : TAG( "TITLE", stream ) {}
+};
+
+class TR : public TAG
+{
+public:
+  TR( std::ostream& stream )
+  : TAG( "TR", stream ) {}
+};
+}
+
+#endif