<?php
/**
* Perforce connection factory.
*
* A Factory used to create a Perforce Connection instance. This class is
* responsible for deciding the specific implementation to use.
*
* @copyright 2011 Perforce Software. All rights reserved.
* @license Please see LICENSE.txt in top-level folder of this distribution.
* @version <release>/<patch>
*/
namespace P4\Connection;
use P4;
class Connection
{
protected static $defaultConnection;
protected static $appName;
protected static $progName;
protected static $progVersion;
/**
* Factory method that creates and returns a single instance of a Perforce Connection
* implementation. The caller should not need to worry about the specific implemenation
* used, only that it implements ConnectionInterface.
*
* @param string $port optional - the port to connect to.
* @param string $user optional - the user to connect as.
* @param string $client optional - the client spec to use.
* @param string $password optional - the password to use.
* @param string $ticket optional - a ticket to use.
* @param string $type optional - a specific client implementation to use.
*
* @return ConnectionInterface a perforce client implementation.
* @throws P4\Exception if an invalid API type is given.
*/
public static function factory(
$port = null,
$user = null,
$client = null,
$password = null,
$ticket = null,
$type = null
) {
// use the type parameter if it was provided.
// throw an exception if it specifies an invalid type.
if ($type) {
if (!self::isValidType($type)) {
throw new P4\Exception("Invalid Perforce Connection Type: " . $type);
}
} else {
if (extension_loaded("perforce")) {
$type = "P4\Connection\Extension";
} else {
throw new P4\Exception('P4-PHP extension is not loaded.');
}
}
// create instance of desired type.
$connection = new $type(
$port,
$user,
$client,
$password,
$ticket
);
// if we have an app name, set it.
if (static::$appName) {
$connection->setAppName(static::$appName);
}
// if we have a program name, set it.
if (static::$progName) {
$connection->setProgName(static::$progName);
}
// if we have a program version, set it.
if (static::$progVersion) {
$connection->setProgVersion(static::$progVersion);
}
// if no default connection has been set, use this one.
if (!self::hasDefaultConnection()) {
self::setDefaultConnection($connection);
}
return $connection;
}
/**
* Get the identity of the current default Connection implementation.
*
* @return array an array of client Connection information containing the name,
* platform, version, build and date of the client library.
*/
public static function getConnectionIdentity()
{
$p4 = self::factory();
return $p4->getConnectionIdentity();
}
/**
* Determine if the given Connection type is valid.
*
* @param string $type the Connection implementation class to use.
* @return bool true if the given Connection class exists and is valid.
*/
public static function isValidType($type)
{
if (!class_exists($type)) {
return false;
}
if (!in_array('P4\\Connection\\ConnectionInterface', class_implements($type))) {
return false;
}
return true;
}
/**
* Set a default connection for the environment.
*
* @param ConnectionInterface $connection the default connection to use.
* @throws P4\Exception if the given connection is not a valid Connection instance.
*/
public static function setDefaultConnection(ConnectionInterface $connection)
{
self::$defaultConnection = $connection;
}
/**
* Unset the default connection.
*/
public static function clearDefaultConnection()
{
self::$defaultConnection = null;
}
/**
* Get the default connection for the environment.
*
* @return ConnectionInterface the default connection.
* @throws P4\Exception if no default connection has been set.
*/
public static function getDefaultConnection()
{
if (!self::$defaultConnection instanceof ConnectionInterface) {
throw new P4\Exception(
"Failed to get connection. A default connection has not been set."
);
}
return self::$defaultConnection;
}
/**
* Check if a default connection has been set.
*
* @return bool true if a default connection is set.
*/
public static function hasDefaultConnection()
{
try {
self::getDefaultConnection();
return true;
} catch (P4\Exception $e) {
return false;
}
}
/**
* Provide a application name to set on any new connections.
*
* @param string|null $name app name to report to the server
*/
public static function setAppName($name)
{
static::$appName = is_null($name) ? $name : (string) $name;
}
/**
* Get the application name that will be set on any new connections.
*
* @return string|null app name to be set on new connections.
*/
public static function getAppName()
{
return static::$appName;
}
/**
* Provide a program name to set on any new connections.
*
* @param string|null $name program name to report to the server
*/
public static function setProgName($name)
{
static::$progName = is_null($name) ? $name : (string) $name;
}
/**
* Get the program name that will be set on any new connections.
*
* @return string|null program name to be set on new connections.
*/
public static function getProgName()
{
return static::$progName;
}
/**
* Provide a program version to set on any new connections.
*
* @param string|null $version program version to report to the server
*/
public static function setProgVersion($version)
{
static::$progVersion = is_null($version) ? $version : (string) $version;
}
/**
* Get the program version that will be set on any new connections.
*
* @return string|null program version to be set on new connections.
*/
public static function getProgVersion()
{
return static::$progVersion;
}
/**
* Private constructor. Prevents callers from creating a factory instance.
*/
private function __construct()
{
}
}