view release on metacpan or  search on metacpan

lib/POE/Component/Lightspeed/Hack/Kernel.pm  view on Meta::CPAN

			$session = $self->_resolve_session( $session );
			unless ( defined $session ) {
				$self->_explain_resolve_failure( $dest_session );
				return;
			}
		}
	} elsif ( ref( $session ) eq 'HASH' or ref( $session ) eq 'ARRAY' ) {
		# Validate this
		$session = POE::Component::Lightspeed::Router::ValidateDestination( $session );

		# Sanity check
		if ( ! defined $session ) {
			$self->_explain_lightspeed_failure( $dest_session );
			return;
		}

		# Since we know it's a lightspeed specifier, shift the args
		unshift( @etc, $event_name );
	} elsif ( ref( $session ) eq 'POE::Component::Lightspeed::Hack::Session' ) {
		# Convert it :)
		$session = [];
		$session->[ POE::Component::Lightspeed::Constants::DEST_KERNEL ] = $dest_session->remote_kernel();
		$session->[ POE::Component::Lightspeed::Constants::DEST_SESSION ] = $dest_session->remote_session();

		# Sanity checks
		if ( ref( $event_name ) ) {
			if ( POE::Component::Lightspeed::Router::DEBUG ) {
				warn 'Missing state in the specifier, as the argument after the destination was not a plain scalar!';
			}
			return undef;
		}

		# Add it!
		$session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] = $event_name;
	} else {
		# Attempt to resolve the destination session reference against various things.
		$session = $self->_resolve_session( $session );
		unless ( defined $session ) {
			$self->_explain_resolve_failure( $dest_session );
			return;
		}
	}

	# Send it off to lightspeed
	if ( ref( $session ) eq 'ARRAY' ) {
		$self->_data_ev_enqueue(
			$self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
			${ $self->[ KR_ACTIVE_SESSION ] },
			'post',
			ET_POST,
			[ $session, \@etc ],
			( caller )[1,2],
			${ $self->[ KR_ACTIVE_EVENT ] },
			time(),
		);
	} else {
		# Enqueue the event for "now", which simulates FIFO in our
		# time-ordered queue.
		$self->_data_ev_enqueue(
			$session, ${ $self->[ KR_ACTIVE_SESSION ] }, $event_name, ET_POST, \@etc,
			(caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(),
		);
	}

	# All done!
	return 1;
}

sub _lightspeed_post_31 {
	my( $self, $fake_session, $dest_session, $event_name, $etc ) = @_;

	# Enqueue the event for "now", which simulates FIFO in our
	# time-ordered queue.
	$self->_data_ev_enqueue(
		$dest_session,
		$fake_session,
		$event_name,
		ET_POST,
		$etc,
		$fake_session->remote_file(),
		$fake_session->remote_line(),
		$fake_session->remote_state(),
		time(),
	);

	# All done!
	return 1;
}

sub _call_31 {
  	my ($self, $dest_session, $event_name, @etc) = @_;

  	if (ASSERT_USAGE) {
		_confess "<us> destination is undefined in call()" unless defined $dest_session;
		_confess "<us> event is undefined in call()" unless defined $event_name;
		_carp "<us> The '$event_name' event is one of POE's own.  Its effect cannot be achieved by calling it" if exists $POE::Kernel::poes_own_events{$event_name};
  	};

  	# Is this destination session a fake lightspeed one?
  	my $session = $dest_session;
  	if ( ! defined $session ) {
		return undef;
  	} elsif ( ! ref( $session ) ) {
		if ( $session =~ m|^poe://|i ) {
			# Validate the destination and the RSVP
			$session = POE::Component::Lightspeed::Router::ValidateDestination( $session );
			if ( ! defined $session ) {
				$self->_explain_lightspeed_failure( $dest_session );
				return;
			}

			# If we didn't receive the state, assume this is a call() without rsvp
			if ( ! defined $session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] ) {
				# Sanity checks
				if ( ref( $event_name ) ) {
					if ( POE::Component::Lightspeed::Router::DEBUG ) {
						warn 'Missing state in the specifier, as the argument after the destination was not a plain scalar!';
					}
					return undef;
				}

lib/POE/Component/Lightspeed/Hack/Kernel.pm  view on Meta::CPAN

			$self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
			${ $self->[ KR_ACTIVE_SESSION ] },
			'call',
			ET_POST,
			[ $session, $rsvp, \@etc ],
			( caller )[1,2],
			${ $self->[ KR_ACTIVE_EVENT ] },
			time(),
		);

		# Always return undef
		return undef;
  	} elsif ( ref( $session ) eq 'POE::Component::Lightspeed::Hack::Session' ) {
		# This is a plain call() without the rsvp

		# Sanity checks
		if ( ref( $event_name ) ) {
			if ( POE::Component::Lightspeed::Router::DEBUG ) {
				warn 'Malformed state';
			}
			return undef;
		}

		# Convert it!
		$session = [];
		$session->[ POE::Component::Lightspeed::Constants::DEST_KERNEL ] = $dest_session->remote_kernel();
		$session->[ POE::Component::Lightspeed::Constants::DEST_SESSION ] = $dest_session->remote_session();
		$session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] = $event_name;

		# Send it off!
		$self->_data_ev_enqueue(
			$self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
			${ $self->[ KR_ACTIVE_SESSION ] },
			'post',
			ET_POST,
			[ $session, \@etc ],
			( caller )[1,2],
			${ $self->[ KR_ACTIVE_EVENT ] },
			time(),
		);

		# Always return undef
		return undef;
  	}

  	# Dispatch the event right now, bypassing the queue altogether.
  	# This tends to be a Bad Thing to Do.

  	# -><- The difference between synchronous and asynchronous events
  	# should be made more clear in the documentation, so that people
  	# have a tendency not to abuse them.  I discovered in xws that that
  	# mixing the two types makes it harder than necessary to write
  	# deterministic programs, but the difficulty can be ameliorated if
  	# programmers set some base rules and stick to them.

  	# What should we return?
  	if (wantarray) {
  	  my @return_value = (
  	    ($session == ${ $self->[ KR_ACTIVE_SESSION ] })
  	    ? $session->_invoke_state(
		$session, $event_name, \@etc, (caller)[1,2],
		${ $self->[ KR_ACTIVE_EVENT ] }
  	    )
  	    : $self->_dispatch_event(
		$session, ${ $self->[ KR_ACTIVE_SESSION ] },
		$event_name, ET_CALL, \@etc,
		(caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(), -__LINE__
  	    )
  	  );

  	  $! = 0;
  	  return @return_value;
  	}

  	if (defined wantarray) {
  	  my $return_value = (
  	    $session == ${ $self->[ KR_ACTIVE_SESSION ] }
  	    ? $session->_invoke_state(
		$session, $event_name, \@etc, (caller)[1,2],
		${ $self->[ KR_ACTIVE_EVENT ] }
  	    )
  	    : $self->_dispatch_event(
		$session, ${ $self->[ KR_ACTIVE_SESSION ] },
		$event_name, ET_CALL, \@etc,
		(caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(), -__LINE__
  	    )
  	  );

  	  $! = 0;
  	  return $return_value;
  	}

  	if ($session == ${ $self->[ KR_ACTIVE_SESSION ] }) {
  	  $session->_invoke_state(
  	    $session, $event_name, \@etc, (caller)[1,2],
  	    ${ $self->[ KR_ACTIVE_EVENT ] }
  	  );
  	}
  	else {
  	  $self->_dispatch_event(
  	    $session, ${ $self->[ KR_ACTIVE_SESSION ] },
  	    $event_name, ET_CALL, \@etc,
  	    (caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(), -__LINE__
  	  );
  	}

  	$! = 0;
  	return;
}

sub _lightspeed_call_31 {
	my( $self, $fake_session, $dest_session, $event_name, $etc ) = @_;

	# Dispatch the event!
	my @return_value = (
		$self->_dispatch_event(
			$dest_session,
			$fake_session,
			$event_name,
			ET_CALL,
			$etc,
			$fake_session->remote_file(),
			$fake_session->remote_line(),
			$fake_session->remote_state(),
			time(),
			-__LINE__,
		)
	);

	# All done!
	return \@return_value;
}

# Scope our evil stuff :)
BEGIN {
	# Turn off strictness for our nasty stuff
	no strict 'refs';

	# Oh boy, no warnings too :(
	no warnings 'redefine';

	# Now, decide which version we should load...
	my %post_versions = (
		'0.31'		=>	\&_post_31,
		'0.3101'	=>	\&_post_31,
	);
	my %call_versions = (
		'0.31'		=>	\&_call_31,
		'0.3101'	=>	\&_call_31,
	);
	my %lightspeed_post_versions = (
		'0.31'		=>	\&_lightspeed_post_31,
		'0.3101'	=>	\&_lightspeed_post_31,
	);
	my %lightspeed_call_versions = (
		'0.31'		=>	\&_lightspeed_call_31,
		'0.3101'	=>	\&_lightspeed_call_31,
	);
	my %alias_versions = (
		'0.31'		=>	\&_alias_31,
		'0.3101'	=>	\&_alias_31,
	);