File Coverage

blib/lib/Finance/InteractiveBrokers/TWS.pm

Criterion	Covered	Total	%
statement	22	81	27.1
branch	0	6	0.0
condition			n/a
subroutine	8	15	53.3
pod			n/a
total	30	102	29.4

#!/usr/bin/perl

package Finance::InteractiveBrokers::TWS;

use version; $VERSION = qv('0.1.1');

use warnings;
use strict;
use File::Spec;
use Data::Dumper;

use Class::InsideOut qw(:std);

#	Define class attributes
#
readonly api_path   => my %api_path;
readonly IB_classes => my %IB_classes;
readonly api_spec   => my %api_spec;
readonly java_src   => my %java_src;
readonly jcode      => my %jcode;
readonly eclient    => my %eclient;

sub new {

	my $self     = register( shift );
	my $callback = shift;

	$callback || die
	   "\n*** You MUST supply a callback to create a TWS object\n\n";

	$api_path   {id $self} = $self->get_tws_api_install_path();
	$IB_classes {id $self} = $self->get_list_ref_of_classes();
	$api_spec   {id $self} = $self->learn_EWrapper_spec();
	$java_src   {id $self} = $self->build_java_src();

	$self->compile_java_src();
	$self->create_subroutines();

	my $jcode = Finance::InteractiveBrokers::TWS::Inline_Java->new($callback);
	$jcode{id $self} = $jcode;

	my $eclient = $self->EClientSocket->new($jcode);
	$eclient{id $self} = $eclient;

	$jcode->OpenCallbackStream();

	return $self;
}

=begin build_java_src

I need to build a Java class that looks like the following with a whole
bunch of duplicate methods, one for each event the TWS emits.  Rather
than hard code the Java class, I build it on the fly by reading the
EWrapper as compiled by INLINE.  Then I return the source which
looks like:

	import org.perl.inline.java.*;
	import com.ib.client.*;

	class Inline_Java extends InlineJavaPerlCaller implements EWrapper {

	InlineJavaPerlObject perlobj;

    	public Inline_Java(InlineJavaPerlObject PerlObj)
    	throws InlineJavaException {
       	perlobj = PerlObj;
    	}

    	public void tickPrice(int tickerId, int field, double price,
                          int canAutoExecute)

    	{
       	try {
            		perlobj.InvokeMethod("tickPrice", new Object [] {
			tickerId, field, price, canAutoExecute });
		}
        	catch (InlineJavaPerlException pe){ }
        	catch (InlineJavaException pe) { pe.printStackTrace() ;}
	}
  ...
  ...
  ...
  }

=end build_java_src

=cut
sub build_java_src {

	my $self = shift;

	my $src = <<"	END";
	import org.perl.inline.java.*;
        import com.ib.client.*;

	class Inline_Java extends InlineJavaPerlCaller implements EWrapper {

	InlineJavaPerlObject perlobj;

	public Inline_Java(InlineJavaPerlObject PerlObj)
	throws InlineJavaException { perlobj = PerlObj; }

	END

	foreach my $method_def_ref (@{$self->api_spec()}) {

		my ($method_name, $parm_list_ref) = @$method_def_ref;

		# I need to remove the 'java.lang' from 'java.lang.String'
		# and the 'com.ib.client' from 'com.ib.client.Contract'
		# etc.. that gets stuck on some of the attributes
		my @clean = map { (split/\./)[-1] } @{$parm_list_ref};

		my $str0 = join ',', map {$clean[$_]." var".$_} 0..$#clean;
		my $str1 = join ',', map {"var".$_} 0..$#clean;

		$src .= sprintf("\tpublic void %s(%s) {
            try {
                perlobj.InvokeMethod(\"%s\", new Object [] {
                        %s
                });
            }
            catch (InlineJavaPerlException pe){ }
            catch (InlineJavaException pe) { pe.printStackTrace() ;}\n\n\t}",
		 $method_name, $str0, $method_name, $str1);
	}

	$src .= '}';

	return $src;
}


=for compile_java_src
Take the Java source created in this module and compile it, also study
all the IB supplied classes, so we can use them.

=cut
sub compile_java_src {

	my $self = shift;

	# Prepend 'com.ib.client' to each class, for proper pathing in STUDY
	my @class_list = map {'com.ib.client.'.$_} @{$self->IB_classes()};

	Inline->bind(
		Java => $self->java_src(),
      AUTOSTUDY => 1,
      STUDY => \@class_list,
      );

	return 0;
}

=begin create_subroutines

	I (at time of writing) create the following subroutines DYNAMICALLY:

	   EClientErrors
	   AnyWrapper
	   Execution
	   EWrapperMsgGenerator
	   ExecutionFilter
	   EWrapper
	   EClientSocket
	   TickType
	   OrderState
	   EReader
	   ScannerSubscription
	   AnyWrapperMsgGenerator
	   ContractDetails
	   Order
	   ComboLeg
	   Util
	   EClientErrors$CodeMsgPair
	   Contract

	These are simple, convenience subs that call the IB supplied class.  So that
	the user (or me) can do:

		my $contract = $object->Contract(...);

	 to create an IB contract instead of having to do

	   my $contract =
	     Finance::InteractiveBrokers::TWS::com::ib::client::Contract->new(...);


	The subroutines I create look like:

	   sub Contract {
	      return __PACKAGE__.'::com::ib::client::Contract';
	   }

=end create_subroutines

=cut

sub create_subroutines {

	my $self = shift;

	{  # localize "no strict 'refs'" to this block
		no strict 'refs';

		foreach my $class_name (@{$self->IB_classes()}) {

			*{ $class_name } =
			   sub { return __PACKAGE__.'::com::ib::client::'.$class_name };

		}
	}
}

=for get_list_ref_of_classes
	I read the list of files in the API directory whose name ends in
	*.class, remove the .class from the name and return a list of class names

=cut
sub get_list_ref_of_classes {

	my $self = shift;

	opendir(DIR, $self->api_path() ) || die
		"can not opendir \'".$self->api_path(),"\': $!";

	# CAREFUL this grep uses a search and replace to remove ".class"
	# from the filename in addition to the match
	my @classes = grep { s/\.class// } readdir(DIR);

	closedir DIR;

	return \@classes;
}

=for get_tws_api_install_path
	get_tws_api_install_path, simply looks through the CLASSPATH environmental
	variable and finds the path for the likely TWS installation, the way I do
	it is probably not bullet proof, that is looking for a path with IBJts
	or jts, but it works for me.

=cut
sub get_tws_api_install_path {

	my $self = shift;

	defined $ENV{'CLASSPATH'} || die "\nCLASSPATH not set\n\n";
	my ($API_base) = grep {/(IBJts)|(jts)/} split(/[:;]/, $ENV{CLASSPATH});

	my @path = File::Spec->splitdir($API_base);
	push @path, qw[com ib client];
	my $path = File::Spec->catfile(@path);

	return $path;
}

=for learn_EWrapper_spec
	I complile the IB supplied EWrapper with Inline::Java, and then plumb
	the debths of the structure created to learn the methods within the EWrapper
	and number and type of parameters to each method, so that I may later
	use that info, to dynamically build my own Wrapper

=cut
sub learn_EWrapper_spec {

	my $self = shift;

	use Inline (
		Java => 'STUDY',
		AUTOSTUDY => 1,
		STUDY => ['com.ib.client.EWrapper'],
	);

	my $package_name = __PACKAGE__.'::com::ib::client::EWrapper';
	my $inlines = (Inline::Java::__get_INLINES)[0]->[0]{ILSM}{data}[1];

	my $ewrapper_methods_ref = $inlines->{classes}{$package_name}{methods};

	my @spec = ();

	# Build a [[method_name, @parms], [method_name, @parms]]
	while (my ($method_name, $value) = each %{$ewrapper_methods_ref}) {

		while (my ($key, $ivalue) = each %{$value}) {

			push @spec, [$method_name, $ivalue->{SIGNATURE}]
				if $ivalue->{SIGNATURE};
		}
	}

	return \@spec;
}

=for read_messages_for_x_sec
Call our implementation of EWrapper to process the messages emitted from
the TWS.  When the messages are read it will trigger the code in the callback
supplied by the user.

=cut
sub read_messages_for_x_sec {

   my ($self, $wait) = @_;

   $wait ||= .05;
   my $jcode = $self->jcode();

   my $num_callbacks_processed = 0;
   while ($jcode->WaitForCallback($wait)) {
       $jcode->ProcessNextCallback();
       $num_callbacks_processed++;
   }

   return $num_callbacks_processed;
}

1;

__END__