Utoh...
There's been a problem with your Upcoming.org API request.
";
if ($this->method)
{
echo "
Method: method}.php\">{$this->method}
";
}
if (count($this->params) > 0) {
echo "
Parameters:
";
foreach ($this->params as $key=>$value)
{
echo "- $key: $value
";
}
echo "
";
}
echo "
This generated a {$this->responseCode} code, with the error message:
{$this->error_msg}
";
}
/*
* Various methods to serials different parts of the object
*/
/*
* Simply generates a hash to use as a plaintext identifier for the object
* (say, a filename)
*/
private function getIdentifier()
{
return md5($this->serialiseQuery());
}
/**
* Stringifies the method and parameters.
*/
private function serialiseQuery()
{
foreach ($this->params as $key=>$value)
{
$params .= $key.':'.$value.'|';
}
$params = rtrim($params,'|');
return "{$this->method}#$params";
}
/**
* Stringifies the Response object ready to be stored
*/
private function serialiseResponse()
{
return serialize($this->response);
}
/*
* Cache management methods lie beyond
* They are slightly mystical and rather ugly.
*/
/**
* This method will load a cache if it can find a valid one, otherwise will return false
* and (presumabley) the sendRequest method will continue to get the content, and then
* have it cached for later
*/
private function checkCache()
{
$cachesize = 0;
$identifier = $this->getIdentifier();
$dh = opendir($this->cache_dir);
while($file = readdir($dh))
{
if ($file != '.' && $file != '..') {
$splitter = split('-',$file);
$hashpart = $splitter[0];
if ($hashpart == $identifier)
{ // The query is the same ....
if ($this->isCacheFileFresh($file))
{ // the TTL is fresh ...
return $this->readCache($file);
} else { // use it or lose it.
unlink($this->cache_dir.$file);
}
}
}
}
return false; // no cache was loaded.
}
/**
* Deletes any out of date cache files in an attempt to reclaim
* space in the cache
*/
private function isCacheFileFresh($filename)
{
$splitter = split('-',$filename);
$timepart = intval(rtrim($splitter[1],'.txt'));
if (time() > ($timepart + ($this->cache_ttl*60)))
return false;
return true;
}
/**
* Writes a cache of the current response object
*/
private function makeCache()
{
$fname = $this->getIdentifier().'-'.time().'.txt';
$fh = fopen($this->cache_dir.$fname,'w');
fwrite($fh,$this->serialiseResponse());
fclose($fh);
}
/**
* Reads a cached file (relative to cache directory)
* and places it into the response object field ready to be accessed
*/
private function readCache($filename)
{
if (file_exists($this->cache_dir.$filename)) {
$this->response = unserialize( file_get_contents($this->cache_dir.$filename) );
if ($this->response != null)
{
return true;
}
}
return false;
}
}
class UpcomingRecordSet
{
/**
TODO: Implement sorting/filtering methods.
Implement iteration
*/
private $items = array(); // Holds records
/**
* Accepts SimpleXML object and maps it into several records
*/
public function simpleXmlToRecordSet($xml_object)
{
foreach ($xml_object->children() as $item) {
$current = new UpcomingRecord();
$current->simpleXmlToRecord($item);
$this->items[] = $current;
}
}
/**
* Returns the array of Records
*/
public function getResults()
{
return $this->items;
}
/**
* Returns the number of items in the recordset
*/
public function countItems()
{
return count($this->items);
}
}
class UpcomingRecord
{
private $attr = array(); // holds the attributes
private $objectType; // holds the object type returned from the server
/**
* Takes a SimpleXML object and maps it into the $attr array for access and proper serialisation
*/
public function simpleXmlToRecord($xml_object)
{
$this->objectType = $xml_object->getName();
foreach ($xml_object->attributes() as $key=>$value) {
$this->attr[$key] = (string)$value; // Cast to ensure we don't try to serialise SimpleXML (which cannot be unserialised)
}
}
/**
* Magical method to return attributes directly
*/
public function __get($name)
{ // magical method to get attributes
return $this->attr[$name];
}
/**
* Returns the object type
*/
public function getType()
{
return $this->objectType;
}
}
// Serialisable Token Storage Class
class UpcomingToken
{
private $data = array();
public function __construct($token)
{
$this->simpleXmlToToken($token);
}
public function simpleXmlToToken($token)
{
foreach ($token as $key=>$value)
{
$data[$key] = (string) $value;
}
}
public function __get($name)
{
return $data[$name];
}
// class to store token data
}
?>