+ * foreach ($document as $fieldName => $fieldValue)
+ * {
+ * ...
+ * }
+ *
+ */
+class Apache_Solr_Document implements IteratorAggregate
+{
+ /**
+ * SVN Revision meta data for this class
+ */
+ const SVN_REVISION = '$Revision$';
+
+ /**
+ * SVN ID meta data for this class
+ */
+ const SVN_ID = '$Id$';
+
+ /**
+ * Document boost value
+ *
+ * @var float
+ */
+ protected $_documentBoost = false;
+
+ /**
+ * Document field values, indexed by name
+ *
+ * @var array
+ */
+ protected $_fields = array();
+
+ /**
+ * Document field boost values, indexed by name
+ *
+ * @var array array of floats
+ */
+ protected $_fieldBoosts = array();
+
+ /**
+ * Clear all boosts and fields from this document
+ */
+ public function clear()
+ {
+ $this->_documentBoost = false;
+
+ $this->_fields = array();
+ $this->_fieldBoosts = array();
+ }
+
+ /**
+ * Get current document boost
+ *
+ * @return mixed will be false for default, or else a float
+ */
+ public function getBoost()
+ {
+ return $this->_documentBoost;
+ }
+
+ /**
+ * Set document boost factor
+ *
+ * @param mixed $boost Use false for default boost, else cast to float that should be > 0 or will be treated as false
+ */
+ public function setBoost($boost)
+ {
+ $boost = (float) $boost;
+
+ if ($boost > 0.0)
+ {
+ $this->_documentBoost = $boost;
+ }
+ else
+ {
+ $this->_documentBoost = false;
+ }
+ }
+
+ /**
+ * Add a value to a multi-valued field
+ *
+ * NOTE: the solr XML format allows you to specify boosts
+ * PER value even though the underlying Lucene implementation
+ * only allows a boost per field. To remedy this, the final
+ * field boost value will be the product of all specified boosts
+ * on field values - this is similar to SolrJ's functionality.
+ *
+ *
+ * $doc = new Apache_Solr_Document();
+ *
+ * $doc->addField('foo', 'bar', 2.0);
+ * $doc->addField('foo', 'baz', 3.0);
+ *
+ * // resultant field boost will be 6!
+ * echo $doc->getFieldBoost('foo');
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @param mixed $boost Use false for default boost, else cast to float that should be > 0 or will be treated as false
+ */
+ public function addField($key, $value, $boost = false)
+ {
+ if (!isset($this->_fields[$key]))
+ {
+ // create holding array if this is the first value
+ $this->_fields[$key] = array();
+ }
+ else if (!is_array($this->_fields[$key]))
+ {
+ // move existing value into array if it is not already an array
+ $this->_fields[$key] = array($this->_fields[$key]);
+ }
+
+ if ($this->getFieldBoost($key) === false)
+ {
+ // boost not already set, set it now
+ $this->setFieldBoost($key, $boost);
+ }
+ else if ((float) $boost > 0.0)
+ {
+ // multiply passed boost with current field boost - similar to SolrJ implementation
+ $this->_fieldBoosts[$key] *= (float) $boost;
+ }
+
+ // add value to array
+ $this->_fields[$key][] = $value;
+ }
+
+ /**
+ * Handle the array manipulation for a multi-valued field
+ *
+ * @param string $key
+ * @param string $value
+ * @param mixed $boost Use false for default boost, else cast to float that should be > 0 or will be treated as false
+ *
+ * @deprecated Use addField(...) instead
+ */
+ public function setMultiValue($key, $value, $boost = false)
+ {
+ $this->addField($key, $value, $boost);
+ }
+
+ /**
+ * Get field information
+ *
+ * @param string $key
+ * @return mixed associative array of info if field exists, false otherwise
+ */
+ public function getField($key)
+ {
+ if (isset($this->_fields[$key]))
+ {
+ return array(
+ 'name' => $key,
+ 'value' => $this->_fields[$key],
+ 'boost' => $this->getFieldBoost($key)
+ );
+ }
+
+ return false;
+ }
+
+ /**
+ * Set a field value. Multi-valued fields should be set as arrays
+ * or instead use the addField(...) function which will automatically
+ * make sure the field is an array.
+ *
+ * @param string $key
+ * @param mixed $value
+ * @param mixed $boost Use false for default boost, else cast to float that should be > 0 or will be treated as false
+ */
+ public function setField($key, $value, $boost = false)
+ {
+ $this->_fields[$key] = $value;
+ $this->setFieldBoost($key, $boost);
+ }
+
+ /**
+ * Get the currently set field boost for a document field
+ *
+ * @param string $key
+ * @return float currently set field boost, false if one is not set
+ */
+ public function getFieldBoost($key)
+ {
+ return isset($this->_fieldBoosts[$key]) ? $this->_fieldBoosts[$key] : false;
+ }
+
+ /**
+ * Set the field boost for a document field
+ *
+ * @param string $key field name for the boost
+ * @param mixed $boost Use false for default boost, else cast to float that should be > 0 or will be treated as false
+ */
+ public function setFieldBoost($key, $boost)
+ {
+ $boost = (float) $boost;
+
+ if ($boost > 0.0)
+ {
+ $this->_fieldBoosts[$key] = $boost;
+ }
+ else
+ {
+ $this->_fieldBoosts[$key] = false;
+ }
+ }
+
+ /**
+ * Return current field boosts, indexed by field name
+ *
+ * @return array
+ */
+ public function getFieldBoosts()
+ {
+ return $this->_fieldBoosts;
+ }
+
+ /**
+ * Get the names of all fields in this document
+ *
+ * @return array
+ */
+ public function getFieldNames()
+ {
+ return array_keys($this->_fields);
+ }
+
+ /**
+ * Get the values of all fields in this document
+ *
+ * @return array
+ */
+ public function getFieldValues()
+ {
+ return array_values($this->_fields);
+ }
+
+ /**
+ * IteratorAggregate implementation function. Allows usage:
+ *
+ *
+ * foreach ($document as $key => $value)
+ * {
+ * ...
+ * }
+ *
+ */
+ #[\ReturnTypeWillChange]
+ public function getIterator()
+ {
+ $arrayObject = new ArrayObject($this->_fields);
+
+ return $arrayObject->getIterator();
+ }
+
+ /**
+ * Magic get for field values
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key)
+ {
+ if (isset($this->_fields[$key]))
+ {
+ return $this->_fields[$key];
+ }
+
+ return null;
+ }
+
+ /**
+ * Magic set for field values. Multi-valued fields should be set as arrays
+ * or instead use the addField(...) function which will automatically
+ * make sure the field is an array.
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value)
+ {
+ $this->setField($key, $value);
+ }
+
+ /**
+ * Magic isset for fields values. Do not call directly. Allows usage:
+ *
+ *
+ * isset($document->some_field);
+ *
+ *
+ * @param string $key
+ * @return boolean
+ */
+ public function __isset($key)
+ {
+ return isset($this->_fields[$key]);
+ }
+
+ /**
+ * Magic unset for field values. Do not call directly. Allows usage:
+ *
+ *
+ * unset($document->some_field);
+ *
+ *
+ * @param string $key
+ */
+ public function __unset($key)
+ {
+ unset($this->_fields[$key]);
+ unset($this->_fieldBoosts[$key]);
+ }
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/Exception.php b/thirdparty/solr-php-client/Apache/Solr/Exception.php
new file mode 100644
index 00000000..28c30bac
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/Exception.php
@@ -0,0 +1,49 @@
+, Donovan Jimenez
+ */
+
+/**
+ * Convenience class that implements the transport implementation. Can be extended by
+ * real implementations to do some of the common book keeping
+ */
+abstract class Apache_Solr_HttpTransport_Abstract implements Apache_Solr_HttpTransport_Interface
+{
+ /**
+ * Our default timeout value for requests that don't specify a timeout
+ *
+ * @var float
+ */
+ private $_defaultTimeout = false;
+
+ /**
+ * Get the current default timeout setting (initially the default_socket_timeout ini setting)
+ * in seconds
+ *
+ * @return float
+ */
+ public function getDefaultTimeout()
+ {
+ // lazy load the default timeout from the ini settings
+ if ($this->_defaultTimeout === false)
+ {
+ $this->_defaultTimeout = (int) ini_get('default_socket_timeout');
+
+ // double check we didn't get 0 for a timeout
+ if ($this->_defaultTimeout <= 0)
+ {
+ $this->_defaultTimeout = 60;
+ }
+ }
+
+ return $this->_defaultTimeout;
+ }
+
+ /**
+ * Set the current default timeout for all HTTP requests
+ *
+ * @param float $timeout
+ */
+ public function setDefaultTimeout($timeout)
+ {
+ $timeout = (float) $timeout;
+
+ if ($timeout >= 0)
+ {
+ $this->_defaultTimeout = $timeout;
+ }
+ }
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Curl.php b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Curl.php
new file mode 100644
index 00000000..6b4dc1e8
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Curl.php
@@ -0,0 +1,206 @@
+, Donovan Jimenez
+ */
+
+// Require Apache_Solr_HttpTransport_Abstract
+require_once(dirname(__FILE__) . '/Abstract.php');
+
+/**
+ * A Curl based HTTP transport. Uses a single curl session for all requests.
+ */
+class Apache_Solr_HttpTransport_Curl extends Apache_Solr_HttpTransport_Abstract
+{
+ /**
+ * SVN Revision meta data for this class
+ */
+ const SVN_REVISION = '$Revision:$';
+
+ /**
+ * SVN ID meta data for this class
+ */
+ const SVN_ID = '$Id:$';
+
+ /**
+ * Curl Session Handle
+ *
+ * @var resource
+ */
+ private $_curl;
+
+ /**
+ * Initializes a curl session
+ */
+ public function __construct()
+ {
+ // initialize a CURL session
+ $this->_curl = curl_init();
+
+ // set common options that will not be changed during the session
+ curl_setopt_array($this->_curl, array(
+ // return the response body from curl_exec
+ CURLOPT_RETURNTRANSFER => true,
+
+ // get the output as binary data
+ CURLOPT_BINARYTRANSFER => true,
+
+ // we do not need the headers in the output, we get everything we need from curl_getinfo
+ CURLOPT_HEADER => false
+ ));
+ }
+
+ /**
+ * Closes a curl session
+ */
+ function __destruct()
+ {
+ // close our curl session
+ curl_close($this->_curl);
+ }
+
+ public function setAuthenticationCredentials($username, $password)
+ {
+ // add the options to our curl handle
+ curl_setopt_array($this->_curl, array(
+ CURLOPT_USERPWD => $username . ":" . $password,
+ CURLOPT_HTTPAUTH => CURLAUTH_BASIC
+ ));
+ }
+
+ public function performGetRequest($url, $timeout = false)
+ {
+ // check the timeout value
+ if ($timeout === false || $timeout <= 0.0)
+ {
+ // use the default timeout
+ $timeout = $this->getDefaultTimeout();
+ }
+
+ // set curl GET options
+ curl_setopt_array($this->_curl, array(
+ // make sure we're returning the body
+ CURLOPT_NOBODY => false,
+
+ // make sure we're GET
+ CURLOPT_HTTPGET => true,
+
+ // set the URL
+ CURLOPT_URL => $url,
+
+ // set the timeout
+ CURLOPT_TIMEOUT => $timeout
+ ));
+
+ // make the request
+ $responseBody = curl_exec($this->_curl);
+
+ // get info from the transfer
+ $statusCode = curl_getinfo($this->_curl, CURLINFO_HTTP_CODE);
+ $contentType = curl_getinfo($this->_curl, CURLINFO_CONTENT_TYPE);
+
+ return new Apache_Solr_HttpTransport_Response($statusCode, $contentType, $responseBody);
+ }
+
+ public function performHeadRequest($url, $timeout = false)
+ {
+ // check the timeout value
+ if ($timeout === false || $timeout <= 0.0)
+ {
+ // use the default timeout
+ $timeout = $this->getDefaultTimeout();
+ }
+
+ // set curl HEAD options
+ curl_setopt_array($this->_curl, array(
+ // this both sets the method to HEAD and says not to return a body
+ CURLOPT_NOBODY => true,
+
+ // set the URL
+ CURLOPT_URL => $url,
+
+ // set the timeout
+ CURLOPT_TIMEOUT => $timeout
+ ));
+
+ // make the request
+ $responseBody = curl_exec($this->_curl);
+
+ // get info from the transfer
+ $statusCode = curl_getinfo($this->_curl, CURLINFO_HTTP_CODE);
+ $contentType = curl_getinfo($this->_curl, CURLINFO_CONTENT_TYPE);
+
+ return new Apache_Solr_HttpTransport_Response($statusCode, $contentType, $responseBody);
+ }
+
+ public function performPostRequest($url, $postData, $contentType, $timeout = false)
+ {
+ // check the timeout value
+ if ($timeout === false || $timeout <= 0.0)
+ {
+ // use the default timeout
+ $timeout = $this->getDefaultTimeout();
+ }
+
+ // set curl POST options
+ curl_setopt_array($this->_curl, array(
+ // make sure we're returning the body
+ CURLOPT_NOBODY => false,
+
+ // make sure we're POST
+ CURLOPT_POST => true,
+
+ // set the URL
+ CURLOPT_URL => $url,
+
+ // set the post data
+ CURLOPT_POSTFIELDS => $postData,
+
+ // set the content type
+ CURLOPT_HTTPHEADER => array("Content-Type: {$contentType}"),
+
+ // set the timeout
+ CURLOPT_TIMEOUT => $timeout
+ ));
+
+ // make the request
+ $responseBody = curl_exec($this->_curl);
+
+ // get info from the transfer
+ $statusCode = curl_getinfo($this->_curl, CURLINFO_HTTP_CODE);
+ $contentType = curl_getinfo($this->_curl, CURLINFO_CONTENT_TYPE);
+
+ return new Apache_Solr_HttpTransport_Response($statusCode, $contentType, $responseBody);
+ }
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/HttpTransport/CurlNoReuse.php b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/CurlNoReuse.php
new file mode 100644
index 00000000..3220edda
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/CurlNoReuse.php
@@ -0,0 +1,230 @@
+, Donovan Jimenez
+ */
+
+// Require Apache_Solr_HttpTransport_Abstract
+require_once(dirname(__FILE__) . '/Abstract.php');
+
+/**
+ * An alternative Curl HTTP transport that opens and closes a curl session for
+ * every request. This isn't the recommended way to use curl, but some version of
+ * PHP have memory issues.
+ */
+class Apache_Solr_HttpTransport_CurlNoReuse extends Apache_Solr_HttpTransport_Abstract
+{
+ /**
+ * SVN Revision meta data for this class
+ */
+ const SVN_REVISION = '$Revision:$';
+
+ /**
+ * SVN ID meta data for this class
+ */
+ const SVN_ID = '$Id:$';
+
+ private $_authString = false;
+
+ public function setAuthenticationCredentials($username, $password)
+ {
+ // this is how curl wants it for the CURLOPT_USERPWD
+ $this->_authString = $username . ":" . $password;
+ }
+
+ public function performGetRequest($url, $timeout = false)
+ {
+ // check the timeout value
+ if ($timeout === false || $timeout <= 0.0)
+ {
+ // use the default timeout
+ $timeout = $this->getDefaultTimeout();
+ }
+
+ $curl = curl_init();
+
+ // set curl GET options
+ curl_setopt_array($curl, array(
+ // return the response body from curl_exec
+ CURLOPT_RETURNTRANSFER => true,
+
+ // get the output as binary data
+ CURLOPT_BINARYTRANSFER => true,
+
+ // we do not need the headers in the output, we get everything we need from curl_getinfo
+ CURLOPT_HEADER => false,
+
+ // set the URL
+ CURLOPT_URL => $url,
+
+ // set the timeout
+ CURLOPT_TIMEOUT => $timeout
+ ));
+
+ // set auth if appropriate
+ if ($this->_authString !== false)
+ {
+ curl_setopt_array($curl, array(
+ CURLOPT_USERPWD => $this->_authString,
+ CURLOPT_HTTPAUTH => CURLAUTH_BASIC
+ ));
+ }
+
+ // make the request
+ $responseBody = curl_exec($curl);
+
+ // get info from the transfer
+ $statusCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
+ $contentType = curl_getinfo($curl, CURLINFO_CONTENT_TYPE);
+
+ // close our curl session - we're done with it
+ curl_close($curl);
+
+ return new Apache_Solr_HttpTransport_Response($statusCode, $contentType, $responseBody);
+ }
+
+ public function performHeadRequest($url, $timeout = false)
+ {
+ // check the timeout value
+ if ($timeout === false || $timeout <= 0.0)
+ {
+ // use the default timeout
+ $timeout = $this->getDefaultTimeout();
+ }
+
+ $curl = curl_init();
+
+ // set curl HEAD options
+ curl_setopt_array($curl, array(
+ // return the response body from curl_exec
+ CURLOPT_RETURNTRANSFER => true,
+
+ // get the output as binary data
+ CURLOPT_BINARYTRANSFER => true,
+
+ // we do not need the headers in the output, we get everything we need from curl_getinfo
+ CURLOPT_HEADER => false,
+
+ // this both sets the method to HEAD and says not to return a body
+ CURLOPT_NOBODY => true,
+
+ // set the URL
+ CURLOPT_URL => $url,
+
+ // set the timeout
+ CURLOPT_TIMEOUT => $timeout
+ ));
+
+ // set auth if appropriate
+ if ($this->_authString !== false)
+ {
+ curl_setopt_array($curl, array(
+ CURLOPT_USERPWD => $this->_authString,
+ CURLOPT_HTTPAUTH => CURLAUTH_BASIC
+ ));
+ }
+
+ // make the request
+ $responseBody = curl_exec($curl);
+
+ // get info from the transfer
+ $statusCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
+ $contentType = curl_getinfo($curl, CURLINFO_CONTENT_TYPE);
+
+ // close our curl session - we're done with it
+ curl_close($curl);
+
+ return new Apache_Solr_HttpTransport_Response($statusCode, $contentType, $responseBody);
+ }
+
+ public function performPostRequest($url, $postData, $contentType, $timeout = false)
+ {
+ // check the timeout value
+ if ($timeout === false || $timeout <= 0.0)
+ {
+ // use the default timeout
+ $timeout = $this->getDefaultTimeout();
+ }
+
+ $curl = curl_init();
+
+ // set curl POST options
+ curl_setopt_array($curl, array(
+ // return the response body from curl_exec
+ CURLOPT_RETURNTRANSFER => true,
+
+ // get the output as binary data
+ CURLOPT_BINARYTRANSFER => true,
+
+ // we do not need the headers in the output, we get everything we need from curl_getinfo
+ CURLOPT_HEADER => false,
+
+ // make sure we're POST
+ CURLOPT_POST => true,
+
+ // set the URL
+ CURLOPT_URL => $url,
+
+ // set the post data
+ CURLOPT_POSTFIELDS => $postData,
+
+ // set the content type
+ CURLOPT_HTTPHEADER => array("Content-Type: {$contentType}"),
+
+ // set the timeout
+ CURLOPT_TIMEOUT => $timeout
+ ));
+
+ // set auth if appropriate
+ if ($this->_authString !== false)
+ {
+ curl_setopt_array($curl, array(
+ CURLOPT_USERPWD => $this->_authString,
+ CURLOPT_HTTPAUTH => CURLAUTH_BASIC
+ ));
+ }
+
+ // make the request
+ $responseBody = curl_exec($curl);
+
+ // get info from the transfer
+ $statusCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
+ $contentType = curl_getinfo($curl, CURLINFO_CONTENT_TYPE);
+
+ // close our curl session - we're done with it
+ curl_close($curl);
+
+ return new Apache_Solr_HttpTransport_Response($statusCode, $contentType, $responseBody);
+ }
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/HttpTransport/FileGetContents.php b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/FileGetContents.php
new file mode 100644
index 00000000..7cd9687a
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/FileGetContents.php
@@ -0,0 +1,238 @@
+_getContext = stream_context_create();
+ $this->_headContext = stream_context_create();
+ $this->_postContext = stream_context_create();
+ }
+
+ public function setAuthenticationCredentials($username, $password)
+ {
+ // compute the Authorization header
+ $this->_authHeader = "Authorization: Basic " . base64_encode($username . ":" . $password);
+
+ // set it now for get and head contexts
+ stream_context_set_option($this->_getContext, 'http', 'header', $this->_authHeader);
+ stream_context_set_option($this->_headContext, 'http', 'header', $this->_authHeader);
+
+ // for post, it'll be set each time, so add an \r\n so it can be concatenated
+ // with the Content-Type
+ $this->_authHeader .= "\r\n";
+ }
+
+ public function performGetRequest($url, $timeout = false)
+ {
+ // set the timeout if specified
+ if ($timeout !== FALSE && $timeout > 0.0)
+ {
+ // timeouts with file_get_contents seem to need
+ // to be halved to work as expected
+ $timeout = (float) $timeout / 2;
+
+ stream_context_set_option($this->_getContext, 'http', 'timeout', $timeout);
+ }
+ else
+ {
+ // use the default timeout pulled from default_socket_timeout otherwise
+ stream_context_set_option($this->_getContext, 'http', 'timeout', $this->getDefaultTimeout());
+ }
+
+ // $http_response_headers will be updated by the call to file_get_contents later
+ // see http://us.php.net/manual/en/wrappers.http.php for documentation
+ // Unfortunately, it will still create a notice in analyzers if we don't set it here
+ $http_response_header = null;
+ $responseBody = @file_get_contents($url, false, $this->_getContext);
+
+ return $this->_getResponseFromParts($responseBody, $http_response_header);
+ }
+
+ public function performHeadRequest($url, $timeout = false)
+ {
+ stream_context_set_option($this->_headContext, array(
+ 'http' => array(
+ // set HTTP method
+ 'method' => 'HEAD',
+
+ // default timeout
+ 'timeout' => $this->getDefaultTimeout()
+ )
+ )
+ );
+
+ // set the timeout if specified
+ if ($timeout !== FALSE && $timeout > 0.0)
+ {
+ // timeouts with file_get_contents seem to need
+ // to be halved to work as expected
+ $timeout = (float) $timeout / 2;
+
+ stream_context_set_option($this->_headContext, 'http', 'timeout', $timeout);
+ }
+
+ // $http_response_headers will be updated by the call to file_get_contents later
+ // see http://us.php.net/manual/en/wrappers.http.php for documentation
+ // Unfortunately, it will still create a notice in analyzers if we don't set it here
+ $http_response_header = null;
+ $responseBody = @file_get_contents($url, false, $this->_headContext);
+
+ return $this->_getResponseFromParts($responseBody, $http_response_header);
+ }
+
+ public function performPostRequest($url, $rawPost, $contentType, $timeout = false)
+ {
+ stream_context_set_option($this->_postContext, array(
+ 'http' => array(
+ // set HTTP method
+ 'method' => 'POST',
+
+ // Add our posted content type (and auth header - see setAuthentication)
+ 'header' => "{$this->_authHeader}Content-Type: {$contentType}",
+
+ // the posted content
+ 'content' => $rawPost,
+
+ // default timeout
+ 'timeout' => $this->getDefaultTimeout()
+ )
+ )
+ );
+
+ // set the timeout if specified
+ if ($timeout !== FALSE && $timeout > 0.0)
+ {
+ // timeouts with file_get_contents seem to need
+ // to be halved to work as expected
+ $timeout = (float) $timeout / 2;
+
+ stream_context_set_option($this->_postContext, 'http', 'timeout', $timeout);
+ }
+
+ // $http_response_header will be updated by the call to file_get_contents later
+ // see http://us.php.net/manual/en/wrappers.http.php for documentation
+ // Unfortunately, it will still create a notice in analyzers if we don't set it here
+ $http_response_header = null;
+ $responseBody = @file_get_contents($url, false, $this->_postContext);
+
+ // reset content of post context to reclaim memory
+ stream_context_set_option($this->_postContext, 'http', 'content', '');
+
+ return $this->_getResponseFromParts($responseBody, $http_response_header);
+ }
+
+ private function _getResponseFromParts($rawResponse, $httpHeaders)
+ {
+ //Assume 0, false as defaults
+ $status = 0;
+ $contentType = false;
+
+ //iterate through headers for real status, type, and encoding
+ if (is_array($httpHeaders) && count($httpHeaders) > 0)
+ {
+ //look at the first headers for the HTTP status code
+ //and message (errors are usually returned this way)
+ //
+ //HTTP 100 Continue response can also be returned before
+ //the REAL status header, so we need look until we find
+ //the last header starting with HTTP
+ //
+ //the spec: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.1
+ //
+ //Thanks to Daniel Andersson for pointing out this oversight
+ while (isset($httpHeaders[0]) && substr($httpHeaders[0], 0, 4) == 'HTTP')
+ {
+ // we can do a intval on status line without the "HTTP/1.X " to get the code
+ $status = intval(substr($httpHeaders[0], 9));
+
+ // remove this from the headers so we can check for more
+ array_shift($httpHeaders);
+ }
+
+ //Look for the Content-Type response header and determine type
+ //and encoding from it (if possible - such as 'Content-Type: text/plain; charset=UTF-8')
+ foreach ($httpHeaders as $header)
+ {
+ // look for the header that starts appropriately
+ if (strncasecmp($header, 'Content-Type:', 13) == 0)
+ {
+ $contentType = substr($header, 13);
+ break;
+ }
+ }
+ }
+
+ return new Apache_Solr_HttpTransport_Response($status, $contentType, $rawResponse);
+ }
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Interface.php b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Interface.php
new file mode 100644
index 00000000..1ca59d90
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Interface.php
@@ -0,0 +1,103 @@
+, Donovan Jimenez
+ */
+
+// require Apache_Solr_HttpTransport_Response
+require_once(dirname(__FILE__) . '/Response.php');
+
+/**
+ * Interface that all Transport (HTTP Requester) implementations must implement. These
+ * Implementations can then be plugged into the Service instance in order to user their
+ * the desired method for making HTTP requests
+ */
+interface Apache_Solr_HttpTransport_Interface
+{
+ /**
+ * Get the current default timeout for all HTTP requests
+ *
+ * @return float
+ */
+ public function getDefaultTimeout();
+
+ /**
+ * Set the current default timeout for all HTTP requests
+ *
+ * @param float $timeout
+ */
+ public function setDefaultTimeout($timeout);
+
+ /**
+ * Set authentication credentials to pass along with the requests.
+ *
+ * These will be used to perform HTTP Basic authentication.
+ *
+ * @param string $username
+ * @param string $password
+ */
+ public function setAuthenticationCredentials($username, $password);
+
+ /**
+ * Perform a GET HTTP operation with an optional timeout and return the response
+ * contents, use getLastResponseHeaders to retrieve HTTP headers
+ *
+ * @param string $url
+ * @param float $timeout
+ * @return Apache_Solr_HttpTransport_Response HTTP response
+ */
+ public function performGetRequest($url, $timeout = false);
+
+ /**
+ * Perform a HEAD HTTP operation with an optional timeout and return the response
+ * headers - NOTE: head requests have no response body
+ *
+ * @param string $url
+ * @param float $timeout
+ * @return Apache_Solr_HttpTransport_Response HTTP response
+ */
+ public function performHeadRequest($url, $timeout = false);
+
+ /**
+ * Perform a POST HTTP operation with an optional timeout and return the response
+ * contents, use getLastResponseHeaders to retrieve HTTP headers
+ *
+ * @param string $url
+ * @param string $rawPost
+ * @param string $contentType
+ * @param float $timeout
+ * @return Apache_Solr_HttpTransport_Response HTTP response
+ */
+ public function performPostRequest($url, $rawPost, $contentType, $timeout = false);
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Response.php b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Response.php
new file mode 100644
index 00000000..f65bca40
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/HttpTransport/Response.php
@@ -0,0 +1,254 @@
+ "Communication Error",
+
+ // Informational 1XX
+ 100 => "Continue",
+ 101 => "Switching Protocols",
+
+ // Successful 2XX
+ 200 => "OK",
+ 201 => "Created",
+ 202 => "Accepted",
+ 203 => "Non-Authoritative Information",
+ 204 => "No Content",
+ 205 => "Reset Content",
+ 206 => "Partial Content",
+
+ // Redirection 3XX
+ 300 => "Multiple Choices",
+ 301 => "Moved Permanently",
+ 302 => "Found",
+ 303 => "See Other",
+ 304 => "Not Modified",
+ 305 => "Use Proxy",
+ 307 => "Temporary Redirect",
+
+ // Client Error 4XX
+ 400 => "Bad Request",
+ 401 => "Unauthorized",
+ 402 => "Payment Required",
+ 403 => "Forbidden",
+ 404 => "Not Found",
+ 405 => "Method Not Allowed",
+ 406 => "Not Acceptable",
+ 407 => "Proxy Authentication Required",
+ 408 => "Request Timeout",
+ 409 => "Conflict",
+ 410 => "Gone",
+ 411 => "Length Required",
+ 412 => "Precondition Failed",
+ 413 => "Request Entity Too Large",
+ 414 => "Request-URI Too Long",
+ 415 => "Unsupported Media Type",
+ 416 => "Request Range Not Satisfiable",
+ 417 => "Expectation Failed",
+
+ // Server Error 5XX
+ 500 => "Internal Server Error",
+ 501 => "Not Implemented",
+ 502 => "Bad Gateway",
+ 503 => "Service Unavailable",
+ 504 => "Gateway Timeout",
+ 505 => "HTTP Version Not Supported"
+ );
+
+ /**
+ * Get the HTTP status message based on status code
+ *
+ * @return string
+ */
+ public static function getDefaultStatusMessage($statusCode)
+ {
+ $statusCode = (int) $statusCode;
+
+ if (isset(self::$_defaultStatusMessages[$statusCode]))
+ {
+ return self::$_defaultStatusMessages[$statusCode];
+ }
+
+ return "Unknown Status";
+ }
+
+ /**
+ * The response's HTTP status code
+ *
+ * @var integer
+ */
+ private $_statusCode;
+
+ /**
+ * The response's HTTP status message
+ *
+ * @var string
+ */
+ private $_statusMessage;
+
+ /**
+ * The response's mime type
+ *
+ * @var string
+ */
+ private $_mimeType;
+
+ /**
+ * The response's character encoding
+ *
+ * @var string
+ */
+ private $_encoding;
+
+ /**
+ * The response's data
+ *
+ * @var string
+ */
+ private $_responseBody;
+
+ /**
+ * Construct a HTTP transport response
+ *
+ * @param integer $statusCode The HTTP status code
+ * @param string $contentType The VALUE of the Content-Type HTTP header
+ * @param string $responseBody The body of the HTTP response
+ */
+ public function __construct($statusCode, $contentType, $responseBody)
+ {
+ // set the status code, make sure its an integer
+ $this->_statusCode = (int) $statusCode;
+
+ // lookup up status message based on code
+ $this->_statusMessage = self::getDefaultStatusMessage($this->_statusCode);
+
+ // set the response body, it should always be a string
+ $this->_responseBody = (string) $responseBody;
+
+ // parse the content type header value for mimetype and encoding
+ // first set default values that will remain if we can't find
+ // what we're looking for in the content type
+ $this->_mimeType = "text/plain";
+ $this->_encoding = "UTF-8";
+
+ if ($contentType)
+ {
+ // now break apart the header to see if there's character encoding
+ $contentTypeParts = explode(';', $contentType, 2);
+
+ if (isset($contentTypeParts[0]))
+ {
+ $this->_mimeType = trim($contentTypeParts[0]);
+ }
+
+ if (isset($contentTypeParts[1]))
+ {
+ // we have a second part, split it further
+ $contentTypeParts = explode('=', $contentTypeParts[1]);
+
+ if (isset($contentTypeParts[1]))
+ {
+ $this->_encoding = trim($contentTypeParts[1]);
+ }
+ }
+ }
+ }
+
+ /**
+ * Get the status code of the response
+ *
+ * @return integer
+ */
+ public function getStatusCode()
+ {
+ return $this->_statusCode;
+ }
+
+ /**
+ * Get the status message of the response
+ *
+ * @return string
+ */
+ public function getStatusMessage()
+ {
+ return $this->_statusMessage;
+ }
+
+ /**
+ * Get the mimetype of the response body
+ *
+ * @return string
+ */
+ public function getMimeType()
+ {
+ return $this->_mimeType;
+ }
+
+ /**
+ * Get the charset encoding of the response body.
+ *
+ * @return string
+ */
+ public function getEncoding()
+ {
+ return $this->_encoding;
+ }
+
+ /**
+ * Get the raw response body
+ *
+ * @return string
+ */
+ public function getBody()
+ {
+ return $this->_responseBody;
+ }
+}
diff --git a/thirdparty/solr-php-client/Apache/Solr/HttpTransportException.php b/thirdparty/solr-php-client/Apache/Solr/HttpTransportException.php
new file mode 100644
index 00000000..642b7b64
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/HttpTransportException.php
@@ -0,0 +1,78 @@
+getHttpStatus()}' Status: {$response->getHttpStatusMessage()}", $response->getHttpStatus());
+
+ $this->_response = $response;
+ }
+
+ /**
+ * Get the response for which this exception was generated
+ *
+ * @return Apache_Solr_Response
+ */
+ public function getResponse()
+ {
+ return $this->_response;
+ }
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/InvalidArgumentException.php b/thirdparty/solr-php-client/Apache/Solr/InvalidArgumentException.php
new file mode 100644
index 00000000..46c15702
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/InvalidArgumentException.php
@@ -0,0 +1,49 @@
+= 5.2.0, Alternatively can be
+ * installed with PECL. Zend Framework also includes a purely PHP solution.
+ */
+class Apache_Solr_Response
+{
+ /**
+ * SVN Revision meta data for this class
+ */
+ const SVN_REVISION = '$Revision$';
+
+ /**
+ * SVN ID meta data for this class
+ */
+ const SVN_ID = '$Id$';
+
+ /**
+ * Holds the raw response used in construction
+ *
+ * @var Apache_Solr_HttpTransport_Response HTTP response
+ */
+ protected $_response;
+
+ /**
+ * Whether the raw response has been parsed
+ *
+ * @var boolean
+ */
+ protected $_isParsed = false;
+
+ /**
+ * Parsed representation of the data
+ *
+ * @var mixed
+ */
+ protected $_parsedData;
+
+ /**
+ * Data parsing flags. Determines what extra processing should be done
+ * after the data is initially converted to a data structure.
+ *
+ * @var boolean
+ */
+ protected $_createDocuments = true,
+ $_collapseSingleValueArrays = true;
+
+ /**
+ * Constructor. Takes the raw HTTP response body and the exploded HTTP headers
+ *
+ * @return Apache_Solr_HttpTransport_Response HTTP response
+ * @param boolean $createDocuments Whether to convert the documents json_decoded as stdClass instances to Apache_Solr_Document instances
+ * @param boolean $collapseSingleValueArrays Whether to make multivalued fields appear as single values
+ */
+ public function __construct(Apache_Solr_HttpTransport_Response $response, $createDocuments = true, $collapseSingleValueArrays = true)
+ {
+ $this->_response = $response;
+ $this->_createDocuments = (bool) $createDocuments;
+ $this->_collapseSingleValueArrays = (bool) $collapseSingleValueArrays;
+ }
+
+ /**
+ * Get the HTTP status code
+ *
+ * @return integer
+ */
+ public function getHttpStatus()
+ {
+ return $this->_response->getStatusCode();
+ }
+
+ /**
+ * Get the HTTP status message of the response
+ *
+ * @return string
+ */
+ public function getHttpStatusMessage()
+ {
+ return $this->_response->getStatusMessage();
+ }
+
+ /**
+ * Get content type of this Solr response
+ *
+ * @return string
+ */
+ public function getType()
+ {
+ return $this->_response->getMimeType();
+ }
+
+ /**
+ * Get character encoding of this response. Should usually be utf-8, but just in case
+ *
+ * @return string
+ */
+ public function getEncoding()
+ {
+ return $this->_response->getEncoding();
+ }
+
+ /**
+ * Get the raw response as it was given to this object
+ *
+ * @return string
+ */
+ public function getRawResponse()
+ {
+ return $this->_response->getBody();
+ }
+
+ /**
+ * Magic get to expose the parsed data and to lazily load it
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key)
+ {
+ if (!$this->_isParsed)
+ {
+ $this->_parseData();
+ $this->_isParsed = true;
+ }
+
+ if (isset($this->_parsedData->$key))
+ {
+ return $this->_parsedData->$key;
+ }
+
+ return null;
+ }
+
+ /**
+ * Magic function for isset function on parsed data
+ *
+ * @param string $key
+ * @return boolean
+ */
+ public function __isset($key)
+ {
+ if (!$this->_isParsed)
+ {
+ $this->_parseData();
+ $this->_isParsed = true;
+ }
+
+ return isset($this->_parsedData->$key);
+ }
+
+ /**
+ * Parse the raw response into the parsed_data array for access
+ *
+ * @throws Apache_Solr_ParserException If the data could not be parsed
+ */
+ protected function _parseData()
+ {
+ //An alternative would be to use Zend_Json::decode(...)
+ $data = json_decode($this->_response->getBody());
+
+ // check that we receive a valid JSON response - we should never receive a null
+ if ($data === null)
+ {
+ throw new Apache_Solr_ParserException('Solr response does not appear to be valid JSON, please examine the raw response with getRawResponse() method');
+ }
+
+ //if we're configured to collapse single valued arrays or to convert them to Apache_Solr_Document objects
+ //and we have response documents, then try to collapse the values and / or convert them now
+ if (($this->_createDocuments || $this->_collapseSingleValueArrays) && isset($data->response) && is_array($data->response->docs))
+ {
+ $documents = array();
+
+ foreach ($data->response->docs as $originalDocument)
+ {
+ if ($this->_createDocuments)
+ {
+ $document = new Apache_Solr_Document();
+ }
+ else
+ {
+ $document = $originalDocument;
+ }
+
+ foreach ($originalDocument as $key => $value)
+ {
+ //If a result is an array with only a single
+ //value then its nice to be able to access
+ //it as if it were always a single value
+ if ($this->_collapseSingleValueArrays && is_array($value) && count($value) <= 1)
+ {
+ $value = array_shift($value);
+ }
+
+ $document->$key = $value;
+ }
+
+ $documents[] = $document;
+ }
+
+ $data->response->docs = $documents;
+ }
+
+ $this->_parsedData = $data;
+ }
+}
\ No newline at end of file
diff --git a/thirdparty/solr-php-client/Apache/Solr/Service.php b/thirdparty/solr-php-client/Apache/Solr/Service.php
new file mode 100644
index 00000000..cdf53e54
--- /dev/null
+++ b/thirdparty/solr-php-client/Apache/Solr/Service.php
@@ -0,0 +1,1211 @@
+
+ * ...
+ * $solr = new Apache_Solr_Service(); //or explicitly new Apache_Solr_Service('localhost', 8180, '/solr')
+ *
+ * $solr->deleteByQuery('*:*'); //deletes ALL documents - be careful :)
+ *
+ * $document = new Apache_Solr_Document();
+ * $document->id = uniqid(); //or something else suitably unique
+ *
+ * $document->title = 'Some Title';
+ * $document->content = 'Some content for this wonderful document. Blah blah blah.';
+ *
+ * $solr->addDocument($document); //if you're going to be adding documents in bulk using addDocuments
+ * //with an array of documents is faster
+ *
+ * $solr->commit(); //commit to see the deletes and the document
+ * $solr->optimize(); //merges multiple segments into one
+ *
+ * //and the one we all care about, search!
+ * //any other common or custom parameters to the request handler can go in the
+ * //optional 4th array argument.
+ * $solr->search('content:blah', 0, 10, array('sort' => 'timestamp desc'));
+ * ...
+ *
+ */
+class Apache_Solr_Service
+{
+ /**
+ * SVN Revision meta data for this class
+ */
+ const SVN_REVISION = '$Revision$';
+
+ /**
+ * SVN ID meta data for this class
+ */
+ const SVN_ID = '$Id$';
+
+ /**
+ * SVN HeadURL meta data for this class
+ */
+ const SVN_URL = '$HeadURL$';
+
+ /**
+ * Response writer we'll request - JSON. See http://code.google.com/p/solr-php-client/issues/detail?id=6#c1 for reasoning
+ */
+ const SOLR_WRITER = 'json';
+
+ /**
+ * NamedList Treatment constants
+ */
+ const NAMED_LIST_FLAT = 'flat';
+ const NAMED_LIST_MAP = 'map';
+
+ /**
+ * Search HTTP Methods
+ */
+ const METHOD_GET = 'GET';
+ const METHOD_POST = 'POST';
+
+ /**
+ * Servlet mappings
+ */
+ const PING_SERVLET = 'admin/ping';
+ const UPDATE_SERVLET = 'update';
+ const SEARCH_SERVLET = 'select';
+ const SYSTEM_SERVLET = 'admin/system';
+ const THREADS_SERVLET = 'admin/threads';
+ const EXTRACT_SERVLET = 'update/extract';
+
+ /**
+ * Server identification strings
+ *
+ * @var string
+ */
+ protected $_host, $_port, $_path;
+
+ /**
+ * Whether {@link Apache_Solr_Response} objects should create {@link Apache_Solr_Document}s in
+ * the returned parsed data
+ *
+ * @var boolean
+ */
+ protected $_createDocuments = true;
+
+ /**
+ * Whether {@link Apache_Solr_Response} objects should have multivalue fields with only a single value
+ * collapsed to appear as a single value would.
+ *
+ * @var boolean
+ */
+ protected $_collapseSingleValueArrays = true;
+
+ /**
+ * How NamedLists should be formatted in the output. This specifically effects facet counts. Valid values
+ * are {@link Apache_Solr_Service::NAMED_LIST_MAP} (default) or {@link Apache_Solr_Service::NAMED_LIST_FLAT}.
+ *
+ * @var string
+ */
+ protected $_namedListTreatment = self::NAMED_LIST_MAP;
+
+ /**
+ * Query delimiters. Someone might want to be able to change
+ * these (to use & instead of & for example), so I've provided them.
+ *
+ * @var string
+ */
+ protected $_queryDelimiter = '?', $_queryStringDelimiter = '&', $_queryBracketsEscaped = true;
+
+ /**
+ * Constructed servlet full path URLs
+ *
+ * @var string
+ */
+ protected $_pingUrl, $_updateUrl, $_searchUrl, $_systemUrl, $_threadsUrl;
+
+ /**
+ * Keep track of whether our URLs have been constructed
+ *
+ * @var boolean
+ */
+ protected $_urlsInited = false;
+
+ /**
+ * HTTP Transport implementation (pluggable)
+ *
+ * @var Apache_Solr_HttpTransport_Interface
+ */
+ protected $_httpTransport = false;
+
+ /**
+ * Escape a value for special query characters such as ':', '(', ')', '*', '?', etc.
+ *
+ * NOTE: inside a phrase fewer characters need escaped, use {@link Apache_Solr_Service::escapePhrase()} instead
+ *
+ * @param string $value
+ * @return string
+ */
+ static public function escape($value)
+ {
+ //list taken from http://lucene.apache.org/java/docs/queryparsersyntax.html#Escaping%20Special%20Characters
+ $pattern = '/(\+|-|&&|\|\||!|\(|\)|\{|}|\[|]|\^|"|~|\*|\?|:|\\\)/';
+ $replace = '\\\$1';
+
+ return preg_replace($pattern, $replace, $value);
+ }
+
+ /**
+ * Escape a value meant to be contained in a phrase for special query characters
+ *
+ * @param string $value
+ * @return string
+ */
+ static public function escapePhrase($value)
+ {
+ $pattern = '/("|\\\)/';
+ $replace = '\\\$1';
+
+ return preg_replace($pattern, $replace, $value);
+ }
+
+ /**
+ * Convenience function for creating phrase syntax from a value
+ *
+ * @param string $value
+ * @return string
+ */
+ static public function phrase($value)
+ {
+ return '"' . self::escapePhrase($value) . '"';
+ }
+
+ /**
+ * Constructor. All parameters are optional and will take on default values
+ * if not specified.
+ *
+ * @param string $host
+ * @param string $port
+ * @param string $path
+ * @param Apache_Solr_HttpTransport_Interface $httpTransport
+ */
+ public function __construct($host = 'localhost', $port = 8180, $path = '/solr/', $httpTransport = false)
+ {
+ $this->setHost($host);
+ $this->setPort($port);
+ $this->setPath($path);
+
+ $this->_initUrls();
+
+ if ($httpTransport)
+ {
+ $this->setHttpTransport($httpTransport);
+ }
+
+ // check that our php version is >= 5.1.3 so we can correct for http_build_query behavior later
+ $this->_queryBracketsEscaped = version_compare(phpversion(), '5.1.3', '>=');
+ }
+
+ /**
+ * Return a valid http URL given this server's host, port and path and a provided servlet name
+ *
+ * @param string $servlet
+ * @return string
+ */
+ protected function _constructUrl($servlet, $params = array())
+ {
+ if (count($params))
+ {
+ //escape all parameters appropriately for inclusion in the query string
+ $escapedParams = array();
+
+ foreach ($params as $key => $value)
+ {
+ $escapedParams[] = urlencode($key) . '=' . urlencode($value);
+ }
+
+ $queryString = $this->_queryDelimiter . implode($this->_queryStringDelimiter, $escapedParams);
+ }
+ else
+ {
+ $queryString = '';
+ }
+
+ return 'http://' . $this->_host . ':' . $this->_port . $this->_path . $servlet . $queryString;
+ }
+
+ /**
+ * Construct the Full URLs for the three servlets we reference
+ */
+ protected function _initUrls()
+ {
+ //Initialize our full servlet URLs now that we have server information
+ $this->_extractUrl = $this->_constructUrl(self::EXTRACT_SERVLET);
+ $this->_pingUrl = $this->_constructUrl(self::PING_SERVLET);
+ $this->_searchUrl = $this->_constructUrl(self::SEARCH_SERVLET);
+ $this->_systemUrl = $this->_constructUrl(self::SYSTEM_SERVLET, array('wt' => self::SOLR_WRITER));
+ $this->_threadsUrl = $this->_constructUrl(self::THREADS_SERVLET, array('wt' => self::SOLR_WRITER ));
+ $this->_updateUrl = $this->_constructUrl(self::UPDATE_SERVLET, array('wt' => self::SOLR_WRITER ));
+
+ $this->_urlsInited = true;
+ }
+
+ protected function _generateQueryString($params)
+ {
+ // use http_build_query to encode our arguments because its faster
+ // than urlencoding all the parts ourselves in a loop
+ //
+ // because http_build_query treats arrays differently than we want to, correct the query
+ // string by changing foo[#]=bar (# being an actual number) parameter strings to just
+ // multiple foo=bar strings. This regex should always work since '=' will be urlencoded
+ // anywhere else the regex isn't expecting it
+ //
+ // NOTE: before php 5.1.3 brackets were not url encoded by http_build query - we've checked
+ // the php version in the constructor and put the results in the instance variable. Also, before
+ // 5.1.2 the arg_separator parameter was not available, so don't use it
+ if ($this->_queryBracketsEscaped)
+ {
+ $queryString = http_build_query($params, null, $this->_queryStringDelimiter);
+ return preg_replace('/%5B(?:[0-9]|[1-9][0-9]+)%5D=/', '=', $queryString);
+ }
+ else
+ {
+ $queryString = http_build_query($params);
+ return preg_replace('/\\[(?:[0-9]|[1-9][0-9]+)\\]=/', '=', $queryString);
+ }
+ }
+
+ /**
+ * Central method for making a get operation against this Solr Server
+ *
+ * @param string $url
+ * @param float $timeout Read timeout in seconds
+ * @return Apache_Solr_Response
+ *
+ * @throws Apache_Solr_HttpTransportException If a non 200 response status is returned
+ */
+ protected function _sendRawGet($url, $timeout = FALSE)
+ {
+ $httpTransport = $this->getHttpTransport();
+
+ $httpResponse = $httpTransport->performGetRequest($url, $timeout);
+ $solrResponse = new Apache_Solr_Response($httpResponse, $this->_createDocuments, $this->_collapseSingleValueArrays);
+
+ if ($solrResponse->getHttpStatus() != 200)
+ {
+ throw new Apache_Solr_HttpTransportException($solrResponse);
+ }
+
+ return $solrResponse;
+ }
+
+ /**
+ * Central method for making a post operation against this Solr Server
+ *
+ * @param string $url
+ * @param string $rawPost
+ * @param float $timeout Read timeout in seconds
+ * @param string $contentType
+ * @return Apache_Solr_Response
+ *
+ * @throws Apache_Solr_HttpTransportException If a non 200 response status is returned
+ */
+ protected function _sendRawPost($url, $rawPost, $timeout = FALSE, $contentType = 'text/xml; charset=UTF-8')
+ {
+ $httpTransport = $this->getHttpTransport();
+
+ $httpResponse = $httpTransport->performPostRequest($url, $rawPost, $contentType, $timeout);
+ $solrResponse = new Apache_Solr_Response($httpResponse, $this->_createDocuments, $this->_collapseSingleValueArrays);
+
+ if ($solrResponse->getHttpStatus() != 200)
+ {
+ throw new Apache_Solr_HttpTransportException($solrResponse);
+ }
+
+ return $solrResponse;
+ }
+
+ /**
+ * Returns the set host
+ *
+ * @return string
+ */
+ public function getHost()
+ {
+ return $this->_host;
+ }
+
+ /**
+ * Set the host used. If empty will fallback to constants
+ *
+ * @param string $host
+ *
+ * @throws Apache_Solr_InvalidArgumentException If the host parameter is empty
+ */
+ public function setHost($host)
+ {
+ //Use the provided host or use the default
+ if (empty($host))
+ {
+ throw new Apache_Solr_InvalidArgumentException('Host parameter is empty');
+ }
+ else
+ {
+ $this->_host = $host;
+ }
+
+ if ($this->_urlsInited)
+ {
+ $this->_initUrls();
+ }
+ }
+
+ /**
+ * Get the set port
+ *
+ * @return integer
+ */
+ public function getPort()
+ {
+ return $this->_port;
+ }
+
+ /**
+ * Set the port used. If empty will fallback to constants
+ *
+ * @param integer $port
+ *
+ * @throws Apache_Solr_InvalidArgumentException If the port parameter is empty
+ */
+ public function setPort($port)
+ {
+ //Use the provided port or use the default
+ $port = (int) $port;
+
+ if ($port <= 0)
+ {
+ throw new Apache_Solr_InvalidArgumentException('Port is not a valid port number');
+ }
+ else
+ {
+ $this->_port = $port;
+ }
+
+ if ($this->_urlsInited)
+ {
+ $this->_initUrls();
+ }
+ }
+
+ /**
+ * Get the set path.
+ *
+ * @return string
+ */
+ public function getPath()
+ {
+ return $this->_path;
+ }
+
+ /**
+ * Set the path used. If empty will fallback to constants
+ *
+ * @param string $path
+ */
+ public function setPath($path)
+ {
+ $path = trim($path, '/');
+
+ if (strlen($path) > 0)
+ {
+ $this->_path = '/' . $path . '/';
+ }
+ else
+ {
+ $this->_path = '/';
+ }
+
+ if ($this->_urlsInited)
+ {
+ $this->_initUrls();
+ }
+ }
+
+ /**
+ * Get the current configured HTTP Transport
+ *
+ * @return HttpTransportInterface
+ */
+ public function getHttpTransport()
+ {
+ // lazy load a default if one has not be set
+ if ($this->_httpTransport === false)
+ {
+ require_once(dirname(__FILE__) . '/HttpTransport/FileGetContents.php');
+
+ $this->_httpTransport = new Apache_Solr_HttpTransport_FileGetContents();
+ }
+
+ return $this->_httpTransport;
+ }
+
+ /**
+ * Set the HTTP Transport implemenation that will be used for all HTTP requests
+ *
+ * @param Apache_Solr_HttpTransport_Interface
+ */
+ public function setHttpTransport(Apache_Solr_HttpTransport_Interface $httpTransport)
+ {
+ $this->_httpTransport = $httpTransport;
+ }
+
+ /**
+ * Set the create documents flag. This determines whether {@link Apache_Solr_Response} objects will
+ * parse the response and create {@link Apache_Solr_Document} instances in place.
+ *
+ * @param boolean $createDocuments
+ */
+ public function setCreateDocuments($createDocuments)
+ {
+ $this->_createDocuments = (bool) $createDocuments;
+ }
+
+ /**
+ * Get the current state of teh create documents flag.
+ *
+ * @return boolean
+ */
+ public function getCreateDocuments()
+ {
+ return $this->_createDocuments;
+ }
+
+ /**
+ * Set the collapse single value arrays flag.
+ *
+ * @param boolean $collapseSingleValueArrays
+ */
+ public function setCollapseSingleValueArrays($collapseSingleValueArrays)
+ {
+ $this->_collapseSingleValueArrays = (bool) $collapseSingleValueArrays;
+ }
+
+ /**
+ * Get the current state of the collapse single value arrays flag.
+ *
+ * @return boolean
+ */
+ public function getCollapseSingleValueArrays()
+ {
+ return $this->_collapseSingleValueArrays;
+ }
+
+ /**
+ * Get the current default timeout setting (initially the default_socket_timeout ini setting)
+ * in seconds
+ *
+ * @return float
+ *
+ * @deprecated Use the getDefaultTimeout method on the HTTP transport implementation
+ */
+ public function getDefaultTimeout()
+ {
+ return $this->getHttpTransport()->getDefaultTimeout();
+ }
+
+ /**
+ * Set the default timeout for all calls that aren't passed a specific timeout
+ *
+ * @param float $timeout Timeout value in seconds
+ *
+ * @deprecated Use the setDefaultTimeout method on the HTTP transport implementation
+ */
+ public function setDefaultTimeout($timeout)
+ {
+ $this->getHttpTransport()->setDefaultTimeout($timeout);
+ }
+
+ /**
+ * Convenience method to set authentication credentials on the current HTTP transport implementation
+ *
+ * @param string $username
+ * @param string $password
+ */
+ public function setAuthenticationCredentials($username, $password)
+ {
+ $this->getHttpTransport()->setAuthenticationCredentials($username, $password);
+ }
+
+ /**
+ * Set how NamedLists should be formatted in the response data. This mainly effects
+ * the facet counts format.
+ *
+ * @param string $namedListTreatment
+ * @throws Apache_Solr_InvalidArgumentException If invalid option is set
+ */
+ public function setNamedListTreatment($namedListTreatment)
+ {
+ switch ((string) $namedListTreatment)
+ {
+ case Apache_Solr_Service::NAMED_LIST_FLAT:
+ $this->_namedListTreatment = Apache_Solr_Service::NAMED_LIST_FLAT;
+ break;
+
+ case Apache_Solr_Service::NAMED_LIST_MAP:
+ $this->_namedListTreatment = Apache_Solr_Service::NAMED_LIST_MAP;
+ break;
+
+ default:
+ throw new Apache_Solr_InvalidArgumentException('Not a valid named list treatement option');
+ }
+ }
+
+ /**
+ * Get the current setting for named list treatment.
+ *
+ * @return string
+ */
+ public function getNamedListTreatment()
+ {
+ return $this->_namedListTreatment;
+ }
+
+ /**
+ * Set the string used to separate the path form the query string.
+ * Defaulted to '?'
+ *
+ * @param string $queryDelimiter
+ */
+ public function setQueryDelimiter($queryDelimiter)
+ {
+ $this->_queryDelimiter = $queryDelimiter;
+ }
+
+ /**
+ * Set the string used to separate the parameters in thequery string
+ * Defaulted to '&'
+ *
+ * @param string $queryStringDelimiter
+ */
+ public function setQueryStringDelimiter($queryStringDelimiter)
+ {
+ $this->_queryStringDelimiter = $queryStringDelimiter;
+ }
+
+ /**
+ * Call the /admin/ping servlet, can be used to quickly tell if a connection to the
+ * server is able to be made.
+ *
+ * @param float $timeout maximum time to wait for ping in seconds, -1 for unlimited (default is 2)
+ * @return float Actual time taken to ping the server, FALSE if timeout or HTTP error status occurs
+ */
+ public function ping($timeout = 2)
+ {
+ $start = microtime(true);
+
+ $httpTransport = $this->getHttpTransport();
+
+ $httpResponse = $httpTransport->performHeadRequest($this->_pingUrl, $timeout);
+ $solrResponse = new Apache_Solr_Response($httpResponse, $this->_createDocuments, $this->_collapseSingleValueArrays);
+
+ if ($solrResponse->getHttpStatus() == 200)
+ {
+ return microtime(true) - $start;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ /**
+ * Call the /admin/system servlet and retrieve system information about Solr
+ *
+ * @return Apache_Solr_Response
+ *
+ * @throws Apache_Solr_HttpTransportException If an error occurs during the service call
+ */
+ public function system()
+ {
+ return $this->_sendRawGet($this->_systemUrl);
+ }
+
+ /**
+ * Call the /admin/threads servlet and retrieve information about all threads in the
+ * Solr servlet's thread group. Useful for diagnostics.
+ *
+ * @return Apache_Solr_Response
+ *
+ * @throws Apache_Solr_HttpTransportException If an error occurs during the service call
+ */
+ public function threads()
+ {
+ return $this->_sendRawGet($this->_threadsUrl);
+ }
+
+ /**
+ * Raw Add Method. Takes a raw post body and sends it to the update service. Post body
+ * should be a complete and well formed "add" xml document.
+ *
+ * @param string $rawPost
+ * @return Apache_Solr_Response
+ *
+ * @throws Apache_Solr_HttpTransportException If an error occurs during the service call
+ */
+ public function add($rawPost)
+ {
+ return $this->_sendRawPost($this->_updateUrl, $rawPost);
+ }
+
+ /**
+ * Add a Solr Document to the index
+ *
+ * @param Apache_Solr_Document $document
+ * @param boolean $allowDups
+ * @param boolean $overwritePending
+ * @param boolean $overwriteCommitted
+ * @param integer $commitWithin The number of milliseconds that a document must be committed within, see @{link http://wiki.apache.org/solr/UpdateXmlMessages#The_Update_Schema} for details. If left empty this property will not be set in the request.
+ * @return Apache_Solr_Response
+ *
+ * @throws Apache_Solr_HttpTransportException If an error occurs during the service call
+ */
+ public function addDocument(Apache_Solr_Document $document, $allowDups = false, $overwritePending = true, $overwriteCommitted = true, $commitWithin = 0)
+ {
+ $dupValue = $allowDups ? 'true' : 'false';
+ $pendingValue = $overwritePending ? 'true' : 'false';
+ $committedValue = $overwriteCommitted ? 'true' : 'false';
+
+ $commitWithin = (int) $commitWithin;
+ $commitWithinString = $commitWithin > 0 ? " commitWithin=\"{$commitWithin}\"" : '';
+
+ $rawPost = "type Status report
message unknown handler: standad
description The request sent by the client was syntactically incorrect (unknown handler: standad).
type Status report
message /solr/doesnotexist/select
description The requested resource (/solr/doesnotexist/select) is not available.