function ofType($type, $val)
{
    if ($val instanceof $type) {
        return $val;
    }
    throwError("Not of type '{$type}'");
}

 public function addDataRow($values, $name = false)
 {
     /**
      *	Adds a data row to the existing graph
      *
      *	@param $values: An array of values
      *	@param $name (optional): The name of the data row
      *
      *	@return: TRUE if adding the data row suceeded, FALSE if not
      */
     if (!is_array($values)) {
         throwError('First argument should be an array', __METHOD__);
         return false;
     }
     if ($name !== false) {
         $name = (string) $name;
     } else {
         $name = 'Data row ' . ($this->nrOfDataRows + 1);
     }
     $this->dataRow[] = $values;
     $this->dataRowNames[] = $name;
     $this->nrOfDataRows++;
     $max = max($values);
     $min = min($values);
     $this->calculateGraduation($min, $max);
     $this->averages[] = false;
     $this->averagesNames[] = false;
     $this->movingAverages[] = false;
     $this->movingAveragesNames[] = false;
     $this->hyperlinks[] = false;
     // re-calculate rect width
     $this->calculateRectSpecs();
     return true;
 }

 /**
  * 
  * make zip archive
  * if exists additional paths, add additional items to the zip
  */
 public function makeZip($srcPath, $zipFilepath, $additionPaths = array())
 {
     if (!is_dir($srcPath)) {
         throwError("The path: '{$srcPath}' don't exists, can't zip");
     }
     $this->zip = new ZipArchive();
     $success = $this->zip->open($zipFilepath, ZipArchive::CREATE);
     if ($success == false) {
         throwError("Can't create zip file: {$zipFilepath}");
     }
     $this->addItem($srcPath, $srcPath);
     if (gettype($additionPaths) != "array") {
         throwError("Wrong additional paths variable.");
     }
     //add additional paths
     if (!empty($additionPaths)) {
         foreach ($additionPaths as $path) {
             if (!is_dir($path)) {
                 throwError("Path: {$path} not found, can't zip");
             }
             $this->addItem($path, $path);
         }
     }
     $this->zip->close();
 }

 /**
  * Adds a new {@link WizardStep} to this wizard.
  * @param string $name A short id/name for this step.
  * @param ref object $step
  * @access public
  * @return ref object
  */
 function addStep($name, $step)
 {
     if (count($this->getSteps())) {
         throwError(new Error("SingleStepWizards can only have one step. Cannot add '" . $name . "' step.", "Wizard"));
     }
     return parent::addStep($name, $step);
 }

function isArrayAndReturnValue($val, $index)
{
    if (isArray($val) && array_key_exists($index, $val)) {
        return $val[$index];
    }
    throwError("The array doesn't has {$index}");
}

 /**
  * Outputs the content of the current template with $variables containing
  * the variable output.
  * @param optional mixed $variables,... Either an associative array or a {@link FieldSet} containing
  * a number of [key]=>content pairs.
  * @access public
  * @return void
  **/
 function output()
 {
     // go through each argument, check if its good and set all the variables.
     for ($i = 0; $i < func_num_args(); $i++) {
         $__v = func_get_arg($i);
         if (is_array($__v)) {
             // ok, register them all as local variables
             foreach (array_keys($__v) as $__k) {
                 ${$__k} = $__v[$__k];
             }
         } else {
             if ($__v instanceof FieldSet) {
                 $__keys = $__v->getKeys();
                 foreach ($__keys as $__k) {
                     ${$__k} = $__v->get($__k);
                 }
             } else {
                 throwError(new Error("Template::output() - could not output: variables passed to method do not seem to be an associative array or a FieldSet."));
                 return false;
             }
         }
     }
     // for
     // otherwise, let's continue and output the file.
     include $this->_fullPath;
 }

 /**
  * Answers the target Id for all NavBlocks in the menu
  * 
  * @return string the target id
  * @access public
  * @since 4/12/06
  */
 function getTargetId()
 {
     if ($this->_element->hasAttribute('target_id')) {
         return $this->_element->getAttribute('target_id');
     }
     throwError(new Error("No target_id available " . $this->_element->toString(true), "XmlSiteComponents"));
 }

 /**
  * The constructor.
  * 
  * @param long $_start the start of the time span
  * @param long $_end the end of the time span
  * 
  * @access public
  * @return void
  */
 function HarmoniTimespan($start, $end)
 {
     if ($start > $end) {
         throwError(new Error("The end of a Timespan cannot come before the end", "HarmoniTimespan", true));
     }
     $this->_start = $start;
     $this->_end = $end;
 }

 /**
  * Executes the specified action in the specified module, using the Harmoni object as a base.
  * @param string $module The module in which to execute.
  * @param string $action The specific action to execute.
  * @access public
  * @return ref mixed A {@link Layout} or TRUE/FALSE
  */
 function executeAction($module, $action)
 {
     $fullPath = $this->_mkFullPath($module, $action);
     if (!$this->actionExists($module, $action)) {
         throwError(new Error("FlatFileActionSource::executeAction({$module}, {$action}) - could not proceed because the file to include does not exist!", "ActionHandler", true));
     }
     $result = (include $fullPath);
     return $result;
 }

 /**
  * Answer the string suffix for the desired muliple of 2^10 bytes
  * i.e. 0 -> B, 10 -> kB, 20 -> MB, 30 -> GB, etc.
  * 
  * @param integer $power A multiple of 10; Range, 0-80
  * @return string
  * @access public
  * @since 10/11/05
  * @static
  */
 static function suffixForPower($power)
 {
     $multiple = intval($power / 10);
     if ($multiple < 0 || $multiple > 8) {
         throwError(new Error("Invalid power, {$power}. Valid values are multiples of ten, 0-80.", "ByteSize", true));
     }
     $suffixes = array("B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB");
     return $suffixes[$multiple];
 }

 function TemplateFactory($searchPath1)
 {
     if (!func_num_args()) {
         throwError(new Error("TemplateFactory - you must specify at least one search path.", "TemplateFactory", true));
     }
     foreach (func_get_args() as $arg) {
         $this->_paths[] = $arg;
     }
 }

function __autoload($classname)
{
    $clbase = strtolower($classname) . '.php';
    $classfile = $_SERVER['DOCUMENT_ROOT'] . '/class/' . $clbase;
    if (file_exists($classfile)) {
        require $classfile;
    } else {
        throwError('missing class file');
    }
}

 /**
  * Create a Tokens Object
  * 
  * @return object Tokens
  * @access public
  * @since 3/1/05
  */
 function createTokensObject()
 {
     $tokensClass = $this->_configuration->getProperty('tokens_class');
     $newTokens = new $tokensClass($this->_configuration);
     $validatorRule = ExtendsValidatorRule::getRule('LDAPAuthNTokens');
     if ($validatorRule->check($newTokens)) {
         return $newTokens;
     } else {
         throwError(new Error("Configuration Error: tokens_class, '" . $tokensClass . "' does not extend UsernamePasswordAuthNTokens.", "LDAPAuthNMethod", true));
     }
 }

 /**
  * Sets the DebugHandler service's output level to $level. If not specified will
  * return the current output level.
  * @param optional integer $level
  * @static
  * @access public
  * @return integer The current debug output level.
  **/
 static function level($level = null)
 {
     if (!Services::serviceAvailable("Debug")) {
         throwError(new Error("Debug::level({$level}) called but Debug service isn't available.", "debug wrapper", false));
         return;
     }
     $debugHandler = Services::getService("Debug");
     if (is_int($level)) {
         $debugHandler->setOutputLevel($level);
     }
     return $debugHandler->getOutputLevel();
 }

 function printTime()
 {
     if (!isset($this->_start) || !isset($this->_end)) {
         $err = "Must call start() and end() first.";
         throwError(new Error($err, "Timer", true));
     }
     list($sm, $ss) = explode(" ", $this->_start);
     list($em, $es) = explode(" ", $this->_end);
     $s = $ss + $sm;
     $e = $es + $em;
     return $e - $s;
 }

 function DateVersionConstraint($relativeDateString)
 {
     $now = time();
     $relative = strtotime($relativeDateString, $now);
     if ($relative === -1) {
         throwError(new Error("DateVersionConstraint: the passed relative date string, '{$relativeDateString}', does not appear to be valid.", "DateVersionConstraint", true));
     }
     if ($relativeDateString >= $now) {
         throwError(new Error("DateVersionConstraint: the specified relative date must be in the PAST.", "DateVersionConstraint", true));
     }
     $this->_cutoffDate = $relative;
 }

 /**
  * Return the name of the day at index.
  * 
  * @param integer $anInteger
  * @return string
  * @access public
  * @since 5/4/05
  */
 static function nameOfDay($anInteger)
 {
     $names = ChronologyConstants::DayNames();
     if ($names[$anInteger]) {
         return $names[$anInteger];
     }
     $errorString = $anInteger . " is not a valid day index.";
     if (function_exists('throwError')) {
         throwError(new Error($errorString));
     } else {
         die($errorString);
     }
 }

 /**
  * The set method sets the value for a field while checking constrictions.
  * @param string $field The field to set.
  * @param mixed $val The value to set $field to.
  * @access public
  * @return boolean True if setting $field succeeds. 
  **/
 function set($field, $val)
 {
     // first check if this is a valid field.
     if (!in_array($field, $this->_ruleSet->getKeys())) {
         // no good
         throwError(new Error(get_class($this) . " - can not set key '{$field}' because it is not a valid key!", "UserDataContainer", true));
         return false;
     }
     if ($this->_ruleSet->validate($field, $val)) {
         $this->_fieldSet->set($field, $val);
         $this->_setFields[$field] = true;
         return true;
     }
     return false;
 }

 /**
  * The constructor.
  * @param string $color The HTML color.
  * @access public
  * @return void 
  **/
 function HTMLcolor($color)
 {
     $color = preg_replace("/^\\#/", "", $color);
     if (strlen($color) == 3) {
         $color = $color[0] . $color[0] . $color[1] . $color[1] . $color[2] . $color[2];
     }
     if (strlen($color) != 6) {
         throwError(new Error("HTMLcolor - can not create class for color '{$color}': it is not a valid HTML color.", "HTMLcolor", false));
     }
     // convert each part into its decimal equivaleng.
     $rgb = explode(" ", chunk_split($color, 2, " "));
     $this->_red = (int) hexdec($rgb[0]);
     $this->_green = (int) hexdec($rgb[1]);
     $this->_blue = (int) hexdec($rgb[2]);
 }

 function returnSearchString()
 {
     $mgr = Services::getService("SchemaManager");
     $typeMgr = Services::getService("DataTypeManager");
     $def = $mgr->getSchemaByID($this->_schemaID);
     $def->load();
     $fieldID = $def->getFieldIDFromLabel($this->_label);
     $field = $def->getField($fieldID);
     // first check if the $value we have is of the correct data type
     $extendsRule = ExtendsValidatorRule::getRule("HarmoniIterator");
     if (!$typeMgr->isObjectOfDataType($this->_value, $field->getType()) && !$extendsRule->check($this->_value)) {
         throwError(new Error("Cannot take a '" . get_class($this->_value) . "' object as search criteria\n\t\t\tfor field '{$this->_label}'; a '" . $field->getType() . "' is required.", "FieldValueSearch", true));
     }
     $class = $typeMgr->storablePrimitiveClassForType($field->getType());
     eval('$string = ' . $class . '::makeSearchString($this->_value, $this->_comparison);');
     return "(dm_record_field.fk_schema_field='" . addslashes($fieldID) . "' AND " . $string . " AND dm_record_field.active=1)";
 }