function enableIsActive ($isActive = true);
/**
- * Determines wether the chatter is active
+ * Determines whether the chatter is active
*
- * @return $isActive Wether the chatter is active
+ * @return $isActive Whether the chatter is active
*/
function isActive ();
}
function enableIsActive ($isActive = true);
/**
- * Determines wether the cruncher is active
+ * Determines whether the cruncher is active
*
- * @return $isActive Wether the cruncher is active
+ * @return $isActive Whether the cruncher is active
*/
function isActive ();
function processRawDataFromResource ($resource);
/**
- * Checks wether decoded data is pending for further processing.
+ * Checks whether decoded data is pending for further processing.
*
- * @return $isPending Wether decoded data is pending
+ * @return $isPending Whether decoded data is pending
*/
function isDecodedDataPending ();
function registerTask ($taskName, Visitable $taskInstance);
/**
- * Checks wether tasks are left including idle task.
+ * Checks whether tasks are left including idle task.
*
- * @return $tasksLeft Wether there are tasks left to handle
+ * @return $tasksLeft Whether there are tasks left to handle
*/
function hasTasksLeft ();
function doListen();
/**
- * Checks wether the listener would accept the given package data array
+ * Checks whether the listener would accept the given package data array
*
* @param $packageData Raw package data
- * @return $accepts Wether this listener does accept
+ * @return $accepts Whether this listener does accept
*/
function ifListenerAcceptsPackageData (array $packageData);
*/
interface Listable extends FrameworkInterface, IteratorAggregate {
/**
- * Checks wether the given group is set
+ * Checks whether the given group is set
*
* @param $groupName Group to check if found in list
- * @return $isset Wether the group is valid
+ * @return $isset Whether the group is valid
*/
function isGroupSet ($groupName);
*/
interface LookupablePeerState extends Lookupable {
/**
- * Checks wether given 'sender' is a new peer
+ * Checks whether given 'sender' is a new peer
*
* @param $packageData Raw package data
- * @return $isNewPeer Wether 'sender' is a new peer to this node
+ * @return $isNewPeer Whether 'sender' is a new peer to this node
*/
function isSenderNewPeer (array $packageData);
function purgeOldEntriesBySocketResource ($socketResource);
/**
- * Checks wether a given peer state (in helper instance) is same as stored
+ * Checks whether a given peer state (in helper instance) is same as stored
* in database compared with the one from $helperInstance.
*
* @param $helperInstance An instance of a ConnectionHelper class
* @param $packageData Valid package data array
- * @return $isSamePeerState Wether the peer's state is the same
+ * @return $isSamePeerState Whether the peer's state is the same
*/
function isSamePeerState (ConnectionHelper $helperInstance, array $packageData);
}
function enqueueRawDataFromTemplate (HelpableHub $helperInstance, NodeHelper $nodeInstance);
/**
- * Checks wether a package has been enqueued for delivery.
+ * Checks whether a package has been enqueued for delivery.
*
- * @return $isEnqueued Wether a package is enqueued
+ * @return $isEnqueued Whether a package is enqueued
*/
function isPackageEnqueued ();
/**
- * Checks wether a package has been declared
+ * Checks whether a package has been declared
*
- * @return $isDeclared Wether a package is declared
+ * @return $isDeclared Whether a package is declared
*/
function isPackageDeclared ();
/**
- * Checks wether a package should be sent out
+ * Checks whether a package should be sent out
*
- * @return $isWaitingDelivery Wether a package is waiting for delivery
+ * @return $isWaitingDelivery Whether a package is waiting for delivery
*/
function isPackageWaitingForDelivery ();
*/
interface Receivable extends FrameworkInterface {
/**
- * Checks wether new raw data from the socket has arrived
+ * Checks whether new raw data from the socket has arrived
*
* @param $poolInstance An instance of a PoolableListener class
- * @return $hasArrived Wether raw package data has arrived at a socket
+ * @return $hasArrived Whether raw package data has arrived at a socket
*/
function isNewRawDataPending (PoolableListener $poolInstance);
function handleIncomingDecodedData ();
/**
- * Checks wether incoming decoded data is handled.
+ * Checks whether incoming decoded data is handled.
*
- * @return $isHandled Wether incoming decoded data is handled
+ * @return $isHandled Whether incoming decoded data is handled
*/
function isIncomingDecodedDataHandled ();
function assembleDecodedDataToPackage ();
/**
- * Checks wether a new package has arrived
+ * Checks whether a new package has arrived
*
- * @return $hasArrived Wether a new package has arrived for processing
+ * @return $hasArrived Whether a new package has arrived for processing
*/
function isNewPackageArrived ();
function chooseProtocolFromPackageData (array $packageData);
/**
- * Checks wether the given package data is accepted by the listener
+ * Checks whether the given package data is accepted by the listener
*
* @param $packageData Raw package data
* @param $listenerInstance A Listenable instance
- * @return $accepts Wether it is accepted
+ * @return $accepts Whether it is accepted
*/
function ifPackageDataIsAcceptedByListener (array $packageData, Listenable $listenerInstance);
}
*/
class BaseNodeChat extends BaseHubSystem {
/**
- * Wether this Chatter is active
+ * Whether this Chatter is active
*/
private $isActive = false;
}
/**
- * Determines wether the chatter is active
+ * Determines whether the chatter is active
*
- * @return $isActive Wether the chatter is active
+ * @return $isActive Whether the chatter is active
*/
public final function isActive () {
return $this->isActive;
}
/**
- * Checks wether the in-buffer queue is filled by comparing it's current
+ * Checks whether the in-buffer queue is filled by comparing it's current
* amount of entries against a threshold.
*
- * @return $isFilled Wether the in-buffer is filled
+ * @return $isFilled Whether the in-buffer is filled
*/
protected function isInBufferQueueFilled () {
// Determine it
}
/**
- * Determines wether the cruncher is active
+ * Determines whether the cruncher is active
*
- * @return $isActive Wether the cruncher is active
+ * @return $isActive Whether the cruncher is active
*/
public final function isActive () {
return $this->isActive;
}
/**
- * Checks wether given 'sender' is a new peer
+ * Checks whether given 'sender' is a new peer
*
* @param $packageData Raw package data
* @param $dataSetInstance An optional instance of a StoreableCriteria class
- * @return $isNewPeer Wether 'sender' is a new peer to this peer
+ * @return $isNewPeer Whether 'sender' is a new peer to this peer
*/
public function isSenderNewPeer (array $packageData, StoreableCriteria $dataSetInstance = NULL) {
// Debug message
}
/**
- * Checks wether a given peer state (in helper instance) is same as stored
+ * Checks whether a given peer state (in helper instance) is same as stored
* in database compared with the one from $helperInstance.
*
* @param $helperInstance An instance of a ConnectionHelper class
* @param $packageData Valid package data array
- * @return $isSamePeerState Wether the peer's state is the same
+ * @return $isSamePeerState Whether the peer's state is the same
*/
public function isSamePeerState (ConnectionHelper $helperInstance, array $packageData) {
// Debug message
$listenerInstance = NULL;
/*
- * Now we need to choose again. It is wether we are speaking with a hub
+ * Now we need to choose again. It is whether we are speaking with a hub
* or with a client. So just handle it over to all listeners in this
* pool.
*/
* collisions) the content is the same as the sender sends it to this
* peer.
*
- * And also the serial number is valid (basicly) at this point.
- *
- * Now the chunk can be added to the final array
+ * And also the serial number is valid (basicly) at this point. Now the
+ * chunk can be added to the final array.
*/
$this->addChunkToFinalArray($chunkSplits);
* Assembles all chunks (except EOP and "hash chunk") back together to the original package data.
*
* This is done by the following steps:
- *
+*
* 1) Sort the final array with ksort(). This will bring the "hash
* chunk" up to the last array index and the EOP chunk to the
* pre-last array index
* @return void
*/
public function assembleChunksFromFinalArray () {
+ // Make sure the final array is really completed
+ assert($this->ifUnassembledChunksAvailable());
+
$this->partialStub('Please implement this method.');
}
}
}
/**
- * Checks wether decoded data is pending for further processing.
+ * Checks whether decoded data is pending for further processing.
*
- * @return $isPending Wether decoded data is pending
+ * @return $isPending Whether decoded data is pending
*/
public function isDecodedDataPending () {
// Does the stacker have some entries (not empty)?
}
/**
- * Checks wether the 'recipient' field matches our own address:port
+ * Checks whether the 'recipient' field matches our own address:port
* combination.
*
* @param $packageData Raw package data
- * @return $matches Wether it matches
+ * @return $matches Whether it matches
* @todo This method will be moved to a better place
*/
protected function ifRecipientMatchesOwnAddress (array $packageData) {
$taskEntry = array(
// Identifier for the generateHash() method
'id' => $taskName,
- // Wether the task is started
+ // Whether the task is started
'task_started' => false,
- // Wether the task is paused (not yet implemented)
+ // Whether the task is paused (not yet implemented)
'task_paused' => false,
- // Wether the task can be paused (not yet implemented)
+ // Whether the task can be paused (not yet implemented)
'task_pauseable' => true,
// Timestamp of registration
'task_registered' => $this->getMilliTime(),
}
/**
- * Checks wether tasks are left including idle task
+ * Checks whether tasks are left including idle task
*
- * @return $tasksLeft Wether there are tasks left to handle
+ * @return $tasksLeft Whether there are tasks left to handle
*/
public function hasTasksLeft () {
// Do we have tasks there?
private $isInitialized = false;
/**
- * Wether this connection is shutted down
+ * Whether this connection is shutted down
*/
private $shuttedDown = false;
* recipientData array with currently configured timeout.
*
* @param $recipientData A valid recipient data array, 0=IP; 1=PORT
- * @return $isConnected Wether the connection went fine
+ * @return $isConnected Whether the connection went fine
* @see Please see http://de.php.net/manual/en/function.socket-connect.php#84465 for original code
* @todo Rewrite the while() loop to a iterator to not let the software stay very long here
*/
/**
* Getter for shuttedDown
*
- * @return $shuttedDown Wether this connection is shutted down
+ * @return $shuttedDown Whether this connection is shutted down
*/
public final function isShuttedDown () {
/* NOISY-DEBUG: */ $this->debugOutput('CONNECTION: ' . $this->__toString() . ',shuttedDown=' . intval($this->shuttedDown));
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
* @return void
*/
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
- * @return $isValid Wether the current entry is there
+ * @return $isValid Whether the current entry is there
*/
public function valid () {
// Check for total active peers and if we are not at the end
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
- * @return $isValid Wether the current entry is there
+ * @return $isValid Whether the current entry is there
*/
public function valid () {
// Check for total active peers and if we are not at the end
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
- * @return $isValid Wether the current entry is there
+ * @return $isValid Whether the current entry is there
*/
public function valid () {
// Check for total active peers and if we are not at the end
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
- * @return $isValid Wether the current entry is there
+ * @return $isValid Whether the current entry is there
*/
public function valid () {
// Check for total active peers and if we are not at the end
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
- * @return $isValid Wether the current entry is there
+ * @return $isValid Whether the current entry is there
*/
public function valid () {
// Check for total active peers and if we are not at the end
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
- * @return $isValid Wether the current entry is there
+ * @return $isValid Whether the current entry is there
*/
public function valid () {
// Check for total active peers and if we are not at the end
}
/**
- * Checks wether the current entry is valid (not at the end of the list)
+ * Checks whether the current entry is valid (not at the end of the list)
*
* @return void
*/
private $listenPort = 0; // This port MUST be changed by your application
/**
- * Wether we are in blocking or non-blocking mode (default: non-blocking
+ * Whether we are in blocking or non-blocking mode (default: non-blocking
*/
private $blockingMode = false;
}
/**
- * Checks wether the given socket resource is a server socket
+ * Checks whether the given socket resource is a server socket
*
* @param $socketResource A valid socket resource
- * @return $isServerSocket Wether the socket resource is a server socket
+ * @return $isServerSocket Whether the socket resource is a server socket
*/
protected function isServerSocketResource ($socketResource) {
// Check it
/**
* Setter for blocking-mode
*
- * @param $blockingMode Wether blocking-mode is disabled (default) or enabled
+ * @param $blockingMode Whether blocking-mode is disabled (default) or enabled
* @return void
*/
protected final function setBlockingMode ($blockingMode) {
}
/**
- * Checks wether blocking-mode is enabled or disabled
+ * Checks whether blocking-mode is enabled or disabled
*
- * @return $blockingMode Wether blocking mode is disabled or enabled
+ * @return $blockingMode Whether blocking mode is disabled or enabled
*/
public final function isBlockingModeEnabled () {
return $this->blockingMode;
}
/**
- * Checks wether given socket resource is registered in socket registry
+ * Checks whether given socket resource is registered in socket registry
*
* @param $socketResource A valid server socket resource
- * @return $isRegistered Wether given server socket is registered
+ * @return $isRegistered Whether given server socket is registered
*/
protected function isServerSocketRegistered ($socketResource) {
// Get a socket registry instance (singleton)
}
/**
- * Checks wether the listener would accept the given package data array
+ * Checks whether the listener would accept the given package data array
*
* @param $packageData Raw package data
- * @return $accepts Wether this listener does accept
+ * @return $accepts Whether this listener does accept
*/
public function ifListenerAcceptsPackageData (array $packageData) {
$this->debugBackTrace('This call should not happen. Please report it.');
}
/**
- * Checks wether the listener would accept the given package data array
+ * Checks whether the listener would accept the given package data array
*
* @param $packageData Raw package data
- * @return $accepts Wether this listener does accept
+ * @return $accepts Whether this listener does accept
*/
public function ifListenerAcceptsPackageData (array $packageData) {
// Get a tags instance
}
/**
- * Checks wether the listener would accept the given package data array
+ * Checks whether the listener would accept the given package data array
*
* @param $packageData Raw package data
- * @return $accepts Wether this listener does accept
+ * @return $accepts Whether this listener does accept
*/
public function ifListenerAcceptsPackageData (array $packageData) {
// Get a tags instance
}
/**
- * Checks wether the listener would accept the given package data array
+ * Checks whether the listener would accept the given package data array
*
* @param $packageData Raw package data
- * @return $accepts Wether this listener does accept
+ * @return $accepts Whether this listener does accept
*/
function ifListenerAcceptsPackageData (array $packageData) {
$this->partialStub('This call should not happen. Please report it.');
}
/**
- * Checks wether the listener would accept the given package data array
+ * Checks whether the listener would accept the given package data array
*
* @param $packageData Raw package data
- * @return $accepts Wether this listener does accept
+ * @return $accepts Whether this listener does accept
*/
function ifListenerAcceptsPackageData (array $packageData) {
// Get a tags instance
}
/**
- * Checks wether the listener would accept the given package data array
+ * Checks whether the listener would accept the given package data array
*
* @param $packageData Raw package data
- * @return $accepts Wether this listener does accept
+ * @return $accepts Whether this listener does accept
*/
public function ifListenerAcceptsPackageData (array $packageData) {
// Get a tags instance
}
/**
- * Checks wether the given group is set
+ * Checks whether the given group is set
*
* @param $groupName Group to check if found in list
- * @return $isset Wether the group is valid
+ * @return $isset Whether the group is valid
*/
public function isGroupSet ($groupName) {
//* DEBUG: */ $this->debugOutput(__METHOD__.': '.$groupName);
}
/**
- * Checks wether the given hash is valid
+ * Checks whether the given hash is valid
*
* @param $hash The hash we should validate
- * @return $isValid Wether the given hash is valid
+ * @return $isValid Whether the given hash is valid
*/
public final function isHashValid ($hash) {
// Check it
private $queueConnectorInstance = NULL;
/**
- * Wether this node is anncounced (KEEP ON false!)
+ * Whether this node is anncounced (KEEP ON false!)
* @deprecated
*/
private $hubIsAnnounced = false;
/**
- * Wether this hub is active
+ * Whether this hub is active
*/
private $isActive = false;
}
/**
- * Checks wether the given IP address matches one of the bootstrapping nodes
+ * Checks whether the given IP address matches one of the bootstrapping nodes
*
* @param $remoteAddr IP address to checkout against our bootstrapping list
- * @return $isFound Wether the IP is found
+ * @return $isFound Whether the IP is found
*/
protected function ifAddressMatchesBootstrappingNodes ($remoteAddr) {
// By default nothing is found
* @return void
*/
public function activateNode (Requestable $requestInstance, Responseable $responseInstance) {
- // Checks wether a listener is still active and shuts it down if one
+ // Checks whether a listener is still active and shuts it down if one
// is still listening.
if (($this->determineIfListenerIsActive()) && ($this->getIsActive())) {
// Shutdown them down before they can hurt anything
/**
* Getter for isActive attribute
*
- * @return $isActive Wether the hub is active
+ * @return $isActive Whether the hub is active
*/
public final function getIsActive () {
return $this->isActive;
/**
* Enables (default) or disables isActive flag
*
- * @param $isActive Wether the hub is active
+ * @param $isActive Whether the hub is active
* @return void
*/
public final function enableIsActive ($isActive = true) {
}
/**
- * Checks wether a package has been enqueued for delivery.
+ * Checks whether a package has been enqueued for delivery.
*
- * @return $isEnqueued Wether a package is enqueued
+ * @return $isEnqueued Whether a package is enqueued
*/
public function isPackageEnqueued () {
- // Check wether the stacker is not empty
+ // Check whether the stacker is not empty
$isEnqueued = (($this->getStackerInstance()->isStackInitialized(self::STACKER_NAME_UNDECLARED)) && (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_UNDECLARED)));
// Return the result
}
/**
- * Checks wether a package has been declared
+ * Checks whether a package has been declared
*
- * @return $isDeclared Wether a package is declared
+ * @return $isDeclared Whether a package is declared
*/
public function isPackageDeclared () {
- // Check wether the stacker is not empty
+ // Check whether the stacker is not empty
$isDeclared = (($this->getStackerInstance()->isStackInitialized(self::STACKER_NAME_DECLARED)) && (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_DECLARED)));
// Return the result
}
/**
- * Checks wether a package should be sent out
+ * Checks whether a package should be sent out
*
- * @return $isWaitingDelivery Wether a package is waiting for delivery
+ * @return $isWaitingDelivery Whether a package is waiting for delivery
*/
public function isPackageWaitingForDelivery () {
- // Check wether the stacker is not empty
+ // Check whether the stacker is not empty
$isWaitingDelivery = (($this->getStackerInstance()->isStackInitialized(self::STACKER_NAME_OUTGOING)) && (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_OUTGOING)));
// Return the result
///////////////////////////////////////////////////////////////////////////
/**
- * Checks wether decoded raw data is pending
+ * Checks whether decoded raw data is pending
*
- * @return $isPending Wether decoded raw data is pending
+ * @return $isPending Whether decoded raw data is pending
*/
private function isDecodedDataPending () {
- // Just return wether the stack is not empty
+ // Just return whether the stack is not empty
$isPending = (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_DECODED_INCOMING));
// Return the status
}
/**
- * Checks wether new raw package data has arrived at a socket
+ * Checks whether new raw package data has arrived at a socket
*
* @param $poolInstance An instance of a PoolableListener class
- * @return $hasArrived Wether new raw package data has arrived for processing
+ * @return $hasArrived Whether new raw package data has arrived for processing
*/
public function isNewRawDataPending (PoolableListener $poolInstance) {
// Visit the pool. This monitors the pool for incoming raw data.
}
/**
- * Checks wether incoming decoded data is handled.
+ * Checks whether incoming decoded data is handled.
*
- * @return $isHandled Wether incoming decoded data is handled
+ * @return $isHandled Whether incoming decoded data is handled
*/
public function isIncomingDecodedDataHandled () {
// Determine if the stack is not empty
}
/**
- * Checks wether a new package has arrived
+ * Checks whether a new package has arrived
*
- * @return $hasArrived Wether a new package has arrived for processing
+ * @return $hasArrived Whether a new package has arrived for processing
*/
public function isNewPackageArrived () {
// @TODO Add some content here
}
/**
- * Checks wether the given package data is already processed by this fragmenter
+ * Checks whether the given package data is already processed by this fragmenter
*
* @param $packageData Raw package data array
- * @return $isProcessed Wether the package has been fragmented
+ * @return $isProcessed Whether the package has been fragmented
*/
private function isPackageProcessed (array $packageData) {
// Get array index
}
/**
- * Checks wether a configurable out-going queue limit has been reached
+ * Checks whether a configurable out-going queue limit has been reached
*
* @param $configEntry Configuration entry where the limit is stored
- * @return $isReached Wether the limit is reached
+ * @return $isReached Whether the limit is reached
*/
protected function isOutgoingQueueLimitReached($configEntry) {
return ($this->getConfigInstance()->getConfigEntry($configEntry) <= $this->getOutgoingQueueInstance()->getStackCount('outgoing_queue'));
}
/**
- * Checks wether a configurable incoming queue limit has been reached
+ * Checks whether a configurable incoming queue limit has been reached
*
* @param $configEntry Configuration entry where the limit is stored
- * @return $isReached Wether the limit is reached
+ * @return $isReached Whether the limit is reached
*/
protected function isIncomingQueueLimitReached($configEntry) {
return ($this->getConfigInstance()->getConfigEntry($configEntry) <= $this->getIncomingQueueInstance()->getStackCount('incoming_queue'));
}
/**
- * Checks wether the given protocol is registered
+ * Checks whether the given protocol is registered
*
* @param $connectionInstance An instance of a ConnectionHelper class
- * @return $isRegistered Wether the protocol is registered
+ * @return $isRegistered Whether the protocol is registered
*/
private function isProtocolRegistered (ConnectionHelper $connectionInstance) {
// Get the key
}
/**
- * Checks wether given socket resource is registered. If $socketResource is
+ * Checks whether given socket resource is registered. If $socketResource is
* false only the instance will be checked.
*
* @param $connectionInstance An instance of a ConnectionHelper class
* @param $socketResource A valid socket resource
- * @return $isRegistered Wether the given socket resource is registered
+ * @return $isRegistered Whether the given socket resource is registered
*/
public function isConnectionRegistered (ConnectionHelper $connectionInstance, $socketResource) {
// Default is not registered
}
/**
- * Checks wether the given protocol is registered
+ * Checks whether the given protocol is registered
*
* @param $protocolInstance An instance of a ProtocolHandler class
- * @return $isRegistered Wether the protocol is registered
+ * @return $isRegistered Whether the protocol is registered
*/
private function isProtocolRegistered (ProtocolHandler $protocolInstance) {
// Get the key
}
/**
- * Checks wether given socket resource is registered. If $socketResource is
+ * Checks whether given socket resource is registered. If $socketResource is
* false only the instance will be checked.
*
* @param $protocolInstance An instance of a ProtocolHandler class
* @param $socketResource A valid socket resource
- * @return $isRegistered Wether the given socket resource is registered
+ * @return $isRegistered Whether the given socket resource is registered
*/
public function isSocketRegistered (ProtocolHandler $protocolInstance, $socketResource) {
// Default is not registered
}
/**
- * Checks wether the given state is valid
+ * Checks whether the given state is valid
*
* @param $stateName The default state we shall execute
- * @return $isValid Wether the given state is valid
+ * @return $isValid Whether the given state is valid
* @throws EmptyVariableException Thrown if given state is not set
* @throws DefaultStateException Thrown if default state was not found
*/
}
/**
- * Validates wether the state is 'active' or throws an exception if
+ * Validates whether the state is 'active' or throws an exception if
* it is every other state.
*
* @return void
/**
* Checks if this state is 'virgin'
*
- * @return $isVirgin Wether this state is 'virgin'
+ * @return $isVirgin Whether this state is 'virgin'
*/
public function isCruncherStateVirgin () {
// Just compare it...
}
/**
- * Validates wether the state is 'active' or throws an exception if
+ * Validates whether the state is 'active' or throws an exception if
* it is every other state.
*
* @return void
}
/**
- * Validates wether the state is 'connected' or throws an exception if
+ * Validates whether the state is 'connected' or throws an exception if
* it is every other state.
*
* @return void
}
/**
- * Checks wether the peer's state is 'connected'
+ * Checks whether the peer's state is 'connected'
*
- * @return $isConnected Wether the state is 'connected'
+ * @return $isConnected Whether the state is 'connected'
*/
public function isPeerStateConnected () {
// Just compare it...
}
/**
- * Checks wether the retry count has reached a configured limit for given
+ * Checks whether the retry count has reached a configured limit for given
* connection.
*
* @param $helperInstance An instance of a ConnectionHelper class
- * @return $isExhausted Wether the retry count has been reached
+ * @return $isExhausted Whether the retry count has been reached
*/
public static function isConnectRetryExhausted (ConnectionHelper $helperInstance) {
//* NOISY-DEBUG: */ $helperInstance->debugOutput('[' . __METHOD__ . ':' . __LINE__ . ']: helperInstance=' . $helperInstance->__toString() . ' - ENTERED!');
}
/**
- * Checks wether the given package data is accepted by the listener
+ * Checks whether the given package data is accepted by the listener
*
* @param $packageData Raw package data
* @param $listenerInstance A Listenable instance
- * @return $accepts Wether it is accepted
+ * @return $accepts Whether it is accepted
*/
public function ifPackageDataIsAcceptedByListener (array $packageData, Listenable $listenerInstance) {
// Extract the tags
* @param $message The optional message we shall output on exit
* @param $code Error code from exception
* @param $extraData Extra information from exceptions
- * @param $silentMode Wether not silent mode is turned on
+ * @param $silentMode Whether silent mode is turned on
* @return void
* @todo This method is old code and needs heavy rewrite and should be moved to ApplicationHelper
*/
projects / hub.git / commitdiff