COUNTER.php

<?php
 
/*
 * Copyright (c) 2015 University of Pittsburgh
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
namespace COUNTER {
   class ReportBuilder {
 
      const COUNTER_NAMESPACE = 'http://www.niso.org/schemas/counter';
 
      protected function validateOneOf($object, $className) {
         if (strpos($className, '\\') === FALSE) {
            $expectedClassname = 'COUNTER\\'.$className;
         } elseif (strpos($className, '\\') === 0) {
            $expectedClassname = substr($className, 1);
         } else {
            $expectedClassname = $className;
         }
         if (is_null($object)) {
            throw new \Exception('Invalid object. Expected "'.$expectedClassname.'", got "NULL"');
         } elseif (is_array($object)) {
            switch ($className) {
               default:
                  throw new \Exception('Invalid class. Expected "'.$expectedClassname.'", got unparsable array');
            }
         } elseif (is_string($object)) {
            switch ($className) {
               case '\DateTime':
                  $date = date_create($object);
                  if ($date) {
                     return $date;
                  }
                  break;
               default:
            }
            throw new \Exception('Invalid class. Expected "'.$expectedClassname.'", got unparsable string');
         } elseif ($expectedClassname == get_class($object) || is_subclass_of($object, $expectedClassname)) {
            return $object;
         } else {
            throw new \Exception('Invalid class. Expected "'.$expectedClassname.'", got "'.get_class($object).'"');
         }
      }
 
      protected function validateOneOrMoreOf($objects, $className) {
         if (is_array($objects)) {
            foreach ($objects as $object) {
               $this->validateOneOf($object, $className);
            }
            return $objects;
         } else {
            return array($this->validateOneOf($objects, $className));
         }
      }
 
      protected function validateZeroOrMoreOf($objects, $className) {
         if (empty($objects)) {
            return;
         } else {
            return $this->validateOneOrMoreOf($objects, $className);
         }
      }
 
      protected function validateZeroOrOneOf($object, $className) {
         if (empty($object)) {
            return;
         } else {
            return $this->validateOneOf($object, $className);
         }
      }
 
      protected function validatePositiveInteger($int) {
         $intval = intval($int);
         if (!is_int($intval) || $intval < 0) {
            throw new \Exception('Invalid positive integer: '.gettype($int).' value '.$int);
         }
         return $intval;
      }
 
      protected function validateString($string) {
         if (!is_string($string)) {
            throw new \Exception('Invalid string: '.gettype($string));
         }
         return $string;
      }
 
      protected function validateStrings($array) {
         if (is_array($array)) {
            foreach ($array as $string) {
               $this->validateString($string);
            }
            return $array;
         } elseif (is_string($array)) {
            return array($array);
         } elseif (!empty($array)) {
            throw new \Exception('Invalid string array: '.gettype($array));
         }
      }
 
      protected static function isAssociative($array) {
         return count(array_filter(array_keys($array), 'is_string')) > 0;
      }
 
      protected function buildMultiple($classname, $array) {
         if (!is_array($array)) {
            return array();
         }else if (self::isAssociative($array)) {
            return $classname::build($array);
         } else {
            $elements = array();
            foreach ($array as $element) {
               $elements[] = $classname::build($element);
            }
            return $elements;
         }
      }
 
      protected function getItemDataTypes() {
         return array('Journal', 'Database', 'Platform', 'Book', 'Collection', 'Multimedia', 'Article');
      }
 
      protected function getIdentifierTypes() {
         return array('Online_ISSN', 'Print_ISSN', 'Online_ISBN', 'Print_ISBN', 'DOI', 'Proprietary');
      }
 
      protected function getContributorIdentifierTypes() {
         return array('ORCID', 'ISNI', 'Proprietary');
      }
 
      protected function getDateTypes() {
         return array('PubDate', 'FirstAccessedOnline', 'Proprietary');
      }
 
      protected function getAttributeTypes() {
         return array('ArticleVersion', 'ArticleType', 'QualificationName', 'QualificationLevel');
      }
 
      protected function getMetricTypes() {
         return array('abstract', 'audio', 'data_set', 'ft_epub', 'ft_html', 'ft_html_mobile', 'ft_pdf', 'ft_pdf_mobile', 'ft_ps', 'ft_ps_mobile', 'ft_total', 'image', 'multimedia', 'no_license', 'other', 'podcast', 'record_view', 'reference', 'result_click', 'search_fed', 'search_reg', 'sectioned_html', 'toc', 'turnaway', 'video');
      }
 
      protected function getCategories() {
         return array('Requests', 'Searches', 'Access_denied');
      }
 
      public function __toString() {
         $doc = $this->asDOMDocument();
         $doc->formatOutput = TRUE;
         return $doc->saveXML();
      }
 
      public function asDOMDocument() {
         throw new Exception(get_class($this).' does not implement asDOMDocument()');
      }
      
      public static function build($array) {
         throw new \Exception('Failed to build '.get_called_class().' from data '.var_export($array, true));
      }
   }
 
   class Reports extends ReportBuilder {
      /* 
       * @var array one or more COUNTER\Report objects
       * @access private
       */
      private $report = array();
 
      public function __construct($reports) {
         $this->report = $this->validateOneOrMoreOf($reports, 'Report');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['Report'])) {
               // Nicely structured associative array
               $reports = parent::buildMultiple('COUNTER\Report', $array['Report']);
               return new self($reports);
            } elseif (!parent::isAssociative($array)) {
               // Just an array of reports
               $reports = parent::buildMultiple('COUNTER\Report', $array);
               return new self($reports);
            }
         }
         parent::build($array);
      }
 
      public function addReport($report) {
         $this->report[] = $this->validateOneOf($report, 'Report');
      }
 
      public function getReports() {
         return $this->report;
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElementNS(self::COUNTER_NAMESPACE, 'Reports'));
         $xmlns = $doc->createAttributeNS('http://www.w3.org/2001/XMLSchema-instance', 'xsi:schemaLocation');
         $xmlns->value = self::COUNTER_NAMESPACE.' http://www.niso.org/schemas/sushi/counter4_1.xsd';
         $root->appendChild($xmlns);
         foreach ($this->report as $rep) {
            $root->appendChild($doc->importNode($rep->asDOMDocument()->documentElement, true));
         }
         return $doc;
      }
   }
 
   class Report extends ReportBuilder {
      /* 
       * @var string Report attribute "Created"
       * @access private
       */
      private $created;
      /* 
       * @var string Report attribute "ID"
       * @access private
       */
      private $id;
      /* 
       * @var string Report attribute "Version"
       * @access private
       */
      private $version;
      /* 
       * @var string Report attribute "Name"
       * @access private
       */
      private $name;
      /* 
       * @var string Report attribute "Title"
       * @access private
       */
      private $title;
      /* 
       * @var COUNTER\Vendor
       * @access private
       */
      private $vendor;
      /* 
       * @var array one or more COUNTER\Customer objects
       * @access private
       */
      private $customer;
 
      public function __construct($id, $version, $name, $title, $customers, $vendor, $created = '') {
         foreach (array('id', 'version', 'name', 'title', 'created') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         if (!$created) {
            $this->created = date("Y-m-d\Th:i:sP");
         }
         $this->vendor = $this->validateOneOf($vendor, 'Vendor');
         $this->customer = $this->validateOneOrMoreOf($customers, 'Customer');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['ID']) && isset($array['Version']) && isset($array['Name']) && isset($array['Title']) && isset($array['Customer']) && isset($array['Vendor'])) {
               // Nicely structured associative array
               $customers = parent::buildMultiple('COUNTER\Customer', $array['Customer']);
               return new self(
                  $array['ID'],
                  $array['Version'],
                  $array['Name'],
                  $array['Title'],
                  $customers,
                  Vendor::build($array['Vendor']),
                  isset($array['Created']) ? $array['Created'] : ''
               );
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('Report'));
         foreach (array('Created', 'ID', 'Version', 'Name', 'Title') as $arg) {
            $lcarg = strtolower($arg);
            $attrAttr = $doc->createAttribute($arg);
            $attrAttr->appendChild($doc->createTextNode($this->$lcarg));
            $root->appendChild($attrAttr);
         }
         $root->appendChild($doc->importNode($this->vendor->asDOMDocument()->documentElement, true));
         foreach ($this->customer as $customer) {
            $root->appendChild($doc->importNode($customer->asDOMDocument()->documentElement, true));
         }
         return $doc;
      }
   }
 
   class Vendor extends ReportBuilder {
      /* 
       * @var string Vendor element "Name"
       * @access private
       */
      private $name;
      /* 
       * @var string Vendor element "ID"
       * @access private
       */
      private $id;
      /* 
       * @var array zero or more COUNTER\Contact elements
       * @access private
       */
      private $contact = array();
      /* 
       * @var string Vendor element "WebSiteUrl"
       * @access private
       */
      private $webSiteUrl;
      /* 
       * @var string Vendor element "LogoUrl"
       * @access private
       */
      private $logoUrl;
 
      public function __construct($id, $name = '', $contacts = array(), $webSiteUrl = '', $logoUrl = '') {
         foreach (array('id', 'name', 'webSiteUrl', 'logoUrl') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         $this->contact = $this->validateZeroOrMoreOf($contacts, 'Contact');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['ID'])) {
               // Nicely structured associative array
               $contacts = parent::buildMultiple('COUNTER\Contact', isset($array['Contact']) ? $array['Contact'] : array());
               return new self(
                  $array['ID'],
                  isset($array['Name']) ? $array['Name'] : '',
                  $contacts,
                  isset($array['WebSiteUrl']) ? $array['WebSiteUrl'] : '',
                  isset($array['LogoUrl']) ? $array['LogoUrl'] : ''
               );
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('Vendor'));
         if ($this->name) {
            $root->appendChild($doc->createElement('Name'))->appendChild($doc->createTextNode($this->name));
         }
         $root->appendChild($doc->createElement('ID'))->appendChild($doc->createTextNode($this->id));
         if ($this->contact) {
            foreach ($this->contact as $contact) {
               $root->appendChild($doc->importNode($contact->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->webSiteUrl) {
            $root->appendChild($doc->createElement('WebSiteUrl'))->appendChild($doc->createTextNode($this->webSiteUrl));
         }
         if ($this->logoUrl) {
            $root->appendChild($doc->createElement('LogoUrl'))->appendChild($doc->createTextNode($this->logoUrl));
         }
         return $doc;
      }
   }
 
   class Contact extends ReportBuilder {
      /* 
       * @var string Contact element "Contact"
       * @access private
       */
      private $contact;
      /* 
       * @var string Contact element "Email"
       * @access private
       */
      private $email;
 
      public function __construct($contact = '', $email = '') {
         foreach (array('contact', 'email') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['E-mail'])) {
               $array['Email'] = $array['E-mail'];
               unset($array['E-mail']);
            }
            if (isset($array['Contact']) || isset($array['Email'])) {
               return new self($array['Contact'] ? $array['Contact'] : '', $array['Email'] ? $array['Email'] : '');
            } elseif (count(array_keys($array)) == 1 && parent::isAssociative($array)) {
               // Loosely structured associative array (name/email => name/email)
               foreach ($array as $k => $v) {
                  if (filter_var($k, FILTER_VALIDATE_EMAIL)) {
                     // email => name
                     return new self($v, $k);
                  } else {
                     // name => email
                     return new self($k, $v);
                  }
               }
            } elseif (count(array_keys($array)) == 1 && !parent::isAssociative($array)) {
               // Loosely array with a name or email
               if (filter_var($k, FILTER_VALIDATE_EMAIL)) {
                  // email
                  return new self('', $array[0]);
               } else {
                  // name
                  return new self($array[0]);
               }
            }
         } elseif (is_string($array)) {
            // Just a name or email
            if (filter_var($array, FILTER_VALIDATE_EMAIL)) {
               // email
               return new self('', $array);
            } else {
               // name
               return new self($array);
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('Contact'));
         if ($this->contact) {
            $root->appendChild($doc->createElement('Contact'))->appendChild($doc->createTextNode($this->contact));
         }
         if ($this->email) {
            $root->appendChild($doc->createElement('E-mail'))->appendChild($doc->createTextNode($this->email));
         }
         return $doc;
      }
   }
 
   class Customer extends ReportBuilder {
      /* 
       * @var string Customer element "Name"
       * @access private
       */
      private $name;
      /* 
       * @var string Customer element "ID"
       * @access private
       */
      private $id;
      /* 
       * @var array zero or more COUNTER\Contact elements
       * @access private
       */
      private $contact;
      /* 
       * @var string Customer element "WebSiteUrl"
       * @access private
       */
      private $webSiteUrl;
      /* 
       * @var string Customer element "LogoUrl"
       * @access private
       */
      private $logoUrl;
      /* 
       * @var string Customer element "Consortium"
       * @access private
       */
      private $consortium;
      /* 
       * @var array zero or more COUNTER\Identifier elements
       * @access private
       */
      private $institutionalIdentifier;
      /* 
       * @var array one or more COUNTER\ReportItem elements
       * @access private
       */
      private $reportItems;
 
      public function __construct($id, $reportItems, $name = '', $contacts = array(), $webSiteUrl = '' , $logoUrl = '', $consortium = NULL, $institutionalIdentifier = array()) {
         foreach (array('id', 'name', 'webSiteUrl', 'logoUrl') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         $this->reportItems = $this->validateOneOrMoreOf($reportItems, 'ReportItems');
         $this->contact = $this->validateZeroOrMoreOf($contacts, 'Contact');
         $this->consortium = $this->validateZeroOrOneOf($consortium, 'Consortium');
         $this->institutionalIdentifier = $this->validateZeroOrMoreOf($institutionalIdentifier, 'Identifier');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['ID']) && isset($array['ReportItems'])) {
               // Nicely structured associative array
               $items = parent::buildMultiple('COUNTER\ReportItems', $array['ReportItems']);
               $ids = parent::buildMultiple('COUNTER\Identifier', isset($array['InstitutionalIdentifier']) ? $array['InstitutionalIdentifier'] : array());
               $contacts = parent::buildMultiple('COUNTER\Contact', isset($array['Contact']) ? $array['Contact'] : array());
               return new self(
                  $array['ID'],
                  $items,
                  isset($array['Name']) ? $array['Name'] : '',
                  $contacts,
                  isset($array['WebSiteUrl']) ? $array['WebSiteUrl'] : '',
                  isset($array['LogoUrl']) ? $array['LogoUrl'] : '',
                  isset($array['Consortium']) ? Consortium::build($array['Consortium']) : NULL,
                  $ids
               );
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('Customer'));
         if ($this->name) {
            $root->appendChild($doc->createElement('Name'))->appendChild($doc->createTextNode($this->name));
         }
         $root->appendChild($doc->createElement('ID'))->appendChild($doc->createTextNode($this->id));
         if ($this->contact) {
            foreach ($this->contact as $contact) {
               $root->appendChild($doc->importNode($contact->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->webSiteUrl) {
            $root->appendChild($doc->createElement('WebSiteUrl'))->appendChild($doc->createTextNode($this->webSiteUrl));
         }
         if ($this->logoUrl) {
            $root->appendChild($doc->createElement('LogoUrl'))->appendChild($doc->createTextNode($this->logoUrl));
         }
         if ($this->consortium) {
            $root->appendChild($doc->importNode($this->consortium->asDOMDocument()->documentElement, true));
         }
         if ($this->institutionalIdentifier) {
            foreach ($this->institutionalIdentifier as $id) {
               $root->appendChild($doc->importNode($id->asDOMDocument()->documentElement, true));
            }
         }
         foreach ($this->reportItems as $rep) {
            $root->appendChild($doc->importNode($rep->asDOMDocument()->documentElement, true));
         }
         return $doc;
      }
   }
 
   class Consortium extends ReportBuilder {
      /* 
       * @var string Consortium element "Code"
       * @access private
       */
      private $code;
      /* 
       * @var string Consortium element "WellKnownName"
       * @access private
       */
      private $wellKnownName;
 
      /*  
       * Construct the object
       * @param string $wellKnownName
       * @param string $code optional
       */
      public function __construct($wellKnownName, $code = '') {
         foreach (array('wellKnownName', 'code') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['WellKnownName'])) {
               // Nicely structured associative array
               return new self($array['WellKnownName'], $array['Code'] ? $array['Code'] : '');
            } elseif (count(array_keys($array)) == 1 && parent::isAssociative($array)) {
               // Loosely structured associative array (name => code)
               foreach ($array as $k => $v) {
                  return new self($k, $v);
               }
            } elseif (count(array_keys($array)) == 1 && !parent::isAssociative($array)) {
               // Loosely array with a name
               return new self($array[0]);
            }
         } elseif (is_string($array)) {
            // Just a name
            return new self($array);
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('Consortium'));
         if ($this->code) {
            $root->appendChild($doc->createElement('Code'))->appendChild($doc->createTextNode($this->code));
         }
         $root->appendChild($doc->createElement('WellKnownName'))->appendChild($doc->createTextNode($this->wellKnownName));
         return $doc;
      }
   }
 
   class ReportItems extends ReportBuilder {
      /* 
       * @var COUNTER\ParentItem ReportItem element "ParentItem"
       * @access private
       */
      private $parentItem;
      /* 
       * @var array zero or more COUNTER\Identifier elements
       * @access private
       */
      private $itemIdentifier;
      /* 
       * @var array zero or more COUNTER\ItemContributor elements
       * @access private
       */
      private $itemContributor;
      /* 
       * @var array zero or more COUNTER\ItemDate elements
       * @access private
       */
      private $itemDate;
      /* 
       * @var array zero or more COUNTER\ItemAttribute elements
       * @access private
       */
      private $itemAttribute;
      /* 
       * @var string ReportItem element "ItemPlatform"
       * @access private
       */
      private $itemPlatform;
      /* 
       * @var string ReportItem element "ItemPublisher"
       * @access private
       */
      private $itemPublisher;
      /* 
       * @var string ReportItem element "ItemName"
       * @access private
       */
      private $itemName;
      /* 
       * @var COUNTER\ItemDataType ReportItem element "ItemData"
       * @access private
       */
      private $itemDataType;
      /* 
       * @var array one or more COUNTER\Metric elements
       * @access private
       */
      private $itemPerformance;
 
      public function __construct($itemPlatform, $itemName, $itemDataType, $itemPerformance, $parentItem = NULL, $itemIdentifiers = array(), $itemContributors = array(), $itemDates = array(), $itemAttributes = array(), $itemPublisher = '') {
         foreach (array('itemPlatform', 'itemPublisher', 'itemName', 'itemDataType') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         if (!in_array($itemDataType, $this->getItemDataTypes())) {
            throw new \Exception('Invalid item data type: '.$itemDataType);
         }
         $this->itemPerformance = $this->validateOneOrMoreOf($itemPerformance, 'Metric');
         $this->parentItem = $this->validateZeroOrOneOf($parentItem, 'ParentItem');
         $this->itemIdentifier = $this->validateZeroOrMoreOf($itemIdentifiers, 'Identifier');
         $this->itemContributor = $this->validateZeroOrMoreOf($itemContributors, 'ItemContributor');
         $this->itemDate = $this->validateZeroOrMoreOf($itemDates, 'ItemDate');
         $this->itemAttribute = $this->validateZeroOrMoreOf($itemAttributes, 'ItemAttribute');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['ItemPlatform']) && isset($array['ItemName']) && isset($array['ItemDataType']) && isset($array['ItemPerformance'])) {
               // Nicely structured associative array
               $performance = parent::buildMultiple('COUNTER\Metric', $array['ItemPerformance']);
               $ids = parent::buildMultiple('COUNTER\Identifier', isset($array['ItemIdentifier']) ? $array['ItemIdentifier'] : array());
               $contributors = parent::buildMultiple('COUNTER\ItemContributor', isset($array['ItemContributor']) ? $array['ItemContributor'] : array());
               $dates = parent::buildMultiple('COUNTER\ItemDate', isset($array['ItemDate']) ? $array['ItemDate'] : array());
               $attributes = parent::buildMultiple('COUNTER\ItemAttribute', isset($array['ItemAttribute']) ? $array['ItemAttribute'] : array());
               return new self(
                  $array['ItemPlatform'],
                  $array['ItemName'],
                  $array['ItemDataType'],
                  $performance,
                  isset($array['ParentItem']) ? ParentItem::build($array['ParentItem']) : NULL,
                  $ids,
                  $contributors,
                  $dates,
                  $attributes,
                  isset($array['ItemPublisher']) ? $array['ItemPublisher'] : ''
               );
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ReportItems'));
         if ($this->parentItem) {
            $root->appendChild($doc->importNode($this->parentItem->asDOMDocument()->documentElement, true));
         }
         if ($this->itemIdentifier) {
            foreach ($this->itemIdentifier as $id) {
               $root->appendChild($doc->importNode($id->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemContributor) {
            foreach ($this->itemContributor as $contrib) {
               $root->appendChild($doc->importNode($contrib->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemDate) {
            foreach ($this->itemDate as $date) {
               $root->appendChild($doc->importNode($date->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemAttribute) {
            foreach ($this->itemAttribute as $attrib) {
               $root->appendChild($doc->importNode($attrib->asDOMDocument()->documentElement, true));
            }
         }
         $root->appendChild($doc->createElement('ItemPlatform'))->appendChild($doc->createTextNode($this->itemPlatform));
         if ($this->itemPublisher) {
            $root->appendChild($doc->createElement('ItemPublisher'))->appendChild($doc->createTextNode($this->itemPublisher));
         }
         $root->appendChild($doc->createElement('ItemName'))->appendChild($doc->createTextNode($this->itemName));
         $root->appendChild($doc->createElement('ItemDataType'))->appendChild($doc->createTextNode($this->itemDataType));
         foreach ($this->itemPerformance as $perf) {
            $root->appendChild($doc->importNode($perf->asDOMDocument()->documentElement, true));
         }
         return $doc;
      }
   }
 
   class ParentItem extends ReportBuilder {
      /* 
       * @var array zero or more COUNTER\Identifier elements
       * @access private
       */
      private $itemIdentifier;
      /* 
       * @var array zero or more COUNTER\ItemContributor elements
       * @access private
       */
      private $itemContributor;
      /* 
       * @var array zero or more COUNTER\ItemDate elements
       * @access private
       */
      private $itemDate;
      /* 
       * @var array zero or more COUNTER\ItemAttribute elements
       * @access private
       */
      private $itemAttribute;
      /* 
       * @var string ParentItem element "ItemPublisher"
       * @access private
       */
      private $itemPublisher;
      /* 
       * @var string ParentItem element "ItemName"
       * @access private
       */
      private $itemName;
      /* 
       * @var COUNTER\DataType ParentItem element "ItemDataType"
       * @access private
       */
      private $itemDataType;
 
      public function __construct($itemName, $itemDataType, $itemIdentifiers = array(), $itemContributors = array(), $itemDates = array(), $itemAttributes = array(), $itemPublisher = '') {
         foreach (array('itemName', 'itemDataType', 'itemPublisher') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         if (!in_array($itemDataType, $this->getItemDataTypes())) {
            throw new \Exception('Invalid type: '.$type);
         }
         $this->itemIdentifier = $this->validateZeroOrMoreOf($itemIdentifiers, 'Identifier');
         $this->itemContributor = $this->validateZeroOrMoreOf($itemContributors, 'ItemContributor');
         $this->itemDate = $this->validateZeroOrMoreOf($itemDates, 'ItemDate');
         $this->itemAttribute = $this->validateZeroOrMoreOf($itemAttributes, 'ItemAttribute');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['ItemName']) && isset($array['ItemDataType'])) {
               // Nicely structured associative array
               $ids = parent::buildMultiple('COUNTER\Identifier', isset($array['ItemIdentifier']) ? $array['ItemIdentifier']: array());
               $contributors = parent::buildMultiple('COUNTER\ItemContributor', isset($array['ItemContributor']) ? $array['ItemContributor'] : array());
               $dates = parent::buildMultiple('COUNTER\ItemDate', isset($array['ItemDate']) ? $array['ItemDate'] : array());
               $attributes = parent::buildMultiple('COUNTER\ItemAttribute', isset($array['ItemAttribute']) ? $array['ItemAttribute'] : array());
               return new self(
                  $array['ItemName'],
                  $array['ItemDataType'],
                  $ids,
                  $contributors,
                  $dates,
                  $attributes,
                  isset($array['ItemPublisher']) ? $array['ItemPublisher'] : ''
               );
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ParentItem'));
         if ($this->itemIdentifier) {
            foreach ($this->itemIdentifier as $id) {
               $root->appendChild($doc->importNode($id->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemContributor) {
            foreach ($this->itemContributor as $contrib) {
               $root->appendChild($doc->importNode($contrib->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemDate) {
            foreach ($this->itemDate as $date) {
               $root->appendChild($doc->importNode($date->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemAttribute) {
            foreach ($this->itemAttribute as $attrib) {
               $root->appendChild($doc->importNode($attrib->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemPublisher) {
            $root->appendChild($doc->createElement('ItemPublisher'))->appendChild($doc->createTextNode($this->itemPublisher));
         }
         $root->appendChild($doc->createElement('ItemName'))->appendChild($doc->createTextNode($this->itemName));
         $root->appendChild($doc->createElement('ItemDataType'))->appendChild($doc->createTextNode($this->itemDataType));
         return $doc;
      }
   }
 
   class ItemContributor extends ReportBuilder {
      /* 
       * @var array zero or more COUNTER\ItemContributorID elements
       * @access private
       */
      private $itemContributorId;
      /* 
       * @var string ItemContributor element "Name"
       * @access private
       */
      private $itemContributorName;
      /* 
       * @var string ItemContributor element "Affiliation"
       * @access private
       */
      private $itemContributorAffiliation;
      /* 
       * @var string ItemContributor element "Role"
       * @access private
       */
      private $itemContributorRole;
 
      public function __construct($itemContributorIds = array(), $itemContributorName = '', $itemContributorAffiliations = array(), $itemContributorRoles = array()) {
         $this->itemContributorId = $this->validateZeroOrMoreOf($itemContributorIds, 'ItemContributorId');
         $this->itemContributorName = $this->validateString($itemContributorName);
         $this->itemContributorAffiliation = $this->validateStrings($itemContributorAffiliations);
         $this->itemContributorRole = $this->validateStrings($itemContributorRoles);
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['ItemContributorID']) || isset($array['ItemContributorName']) || isset($array['ItemContributorAffiliation']) || isset($array['ItemContributorRole'])) {
               // Nicely structured associative array
               $ids = parent::buildMultiple('COUNTER\ItemContributorId', isset($array['ItemContributorID']) ? $array['ItemContributorID'] : array());
               return new self(
                  $ids,
                  isset($array['ItemContributorName']) ? $array['ItemContributorName'] : '',
                  isset($array['ItemContributorAffiliation']) ? $array['ItemContributorAffiliation'] : '',
                  isset($array['ItemContributorRole']) ? $array['ItemContributorRole'] : ''
               );
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ItemContributor'));
         if ($this->itemContributorId) {
            foreach ($this->itemContributorId as $id) {
               $root->appendChild($doc->importNode($id->asDOMDocument()->documentElement, true));
            }
         }
         if ($this->itemContributorName) {
            $root->appendChild($doc->createElement('ItemContributorName'))->appendChild($doc->createTextNode($this->itemContributorName));
         }
         if ($this->itemContributorAffiliation) {
            foreach ($this->itemContributorAffiliation as $affiliation) {
               $root->appendChild($doc->createElement('ItemContributorAffiliation', $affiliation));
            }
         }
         if ($this->itemContributorRole) {
            foreach ($this->itemContributorRole as $role) {
               $root->appendChild($doc->createElement('ItemContributorRole', $role));
            }
         }
         return $doc;
      }
   }
 
   class ItemContributorId extends ReportBuilder {
      /* 
       * @var string ItemContributorID element "Type"
       * @access private
       */
      private $type;
      /* 
       * @var string ItemContributorID element "Value"
       * @access private
       */
      private $value;
 
      public function __construct($type, $value) {
         foreach (array('type', 'value') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         if (!in_array($type, $this->getContributorIdentifierTypes())) {
            throw new \Exception('Invalid type: '.$type);
         }
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['Type']) && isset($array['Value'])) {
               // Nicely structured associative array
               return new self($array['Type'], $array['Value']);
            } elseif (count(array_keys($array)) == 1 && parent::isAssociative($array)) {
               // Loosely structured associative array (type => value)
               foreach ($array as $k => $v) {
                  return new self($k, $v);
               }
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ItemContributorID'));
         $root->appendChild($doc->createElement('Type'))->appendChild($doc->createTextNode($this->type));
         $root->appendChild($doc->createElement('Value'))->appendChild($doc->createTextNode($this->value));
         return $doc;
      }
   }
 
   class Identifier extends ReportBuilder {
      /* 
       * @var string Identifier element "Type"
       * @access private
       */
      private $type;
      /* 
       * @var string Identifier element "Type"
       * @access private
       */
      private $value;
 
      public function __construct($type, $value) {
         foreach (array('type', 'value') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         if (!in_array($type, $this->getIdentifierTypes())) {
            throw new \Exception('Invalid type: '.$type);
         }
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['Type']) && isset($array['Value'])) {
               // Nicely structured associative array
               return new self($array['Type'], $array['Value']);
            } elseif (count(array_keys($array)) == 1 && parent::isAssociative($array)) {
               // Loosely structured associative array (type => value)
               foreach ($array as $k => $v) {
                  return new self($k, $v);
               }
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ItemIdentifier'));
         $root->appendChild($doc->createElement('Type'))->appendChild($doc->createTextNode($this->type));
         $root->appendChild($doc->createElement('Value'))->appendChild($doc->createTextNode($this->value));
         return $doc;
      }
   }
 
   class ItemDate extends ReportBuilder{
      /* 
       * @var string ItemDate element "Type"
       * @access private
       */
      private $type;
      /* 
       * @var string ItemDate element "Value"
       * @access private
       */
      private $value;
 
      public function __construct($type, $value) {
         $this->type = $this->validateString($type);
         if (!in_array($type, $this->getDateTypes())) {
            throw new \Exception('Invalid type: '.$type);
         }
         $this->value = $this->validateOneOf($value, '\DateTime');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['Type']) && isset($array['Value'])) {
               // Nicely structured associative array
               return new self($array['Type'], $array['Value']);
            } elseif (count(array_keys($array)) == 1 && parent::isAssociative($array)) {
               // Loosely structured associative array (type => value)
               foreach ($array as $k => $v) {
                  return new self($k, $v);
               }
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ItemDate'));
         $root->appendChild($doc->createElement('Type'))->appendChild($doc->createTextNode($this->type));
         $root->appendChild($doc->createElement('Value'))->appendChild($doc->createTextNode(date_format($this->value, 'Y-m-d')));
         return $doc;
      }
   }
 
   class ItemAttribute extends ReportBuilder {
      /* 
       * @var string ItemAttribute element "Type"
       * @access private
       */
      private $type;
      /* 
       * @var string ItemAttribute element "Value"
       * @access private
       */
      private $value;
 
      public function __construct($type, $value) {
         foreach (array('type', 'value') as $arg) {
            $this->$arg = $this->validateString($$arg);
         }
         if (!in_array($type, $this->getAttributeTypes())) {
            throw new \Exception('Invalid type: '.$type);
         }
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['Type']) && isset($array['Value'])) {
               // Nicely structured associative array
               return new self($array['Type'], $array['Value']);
            } elseif (count(array_keys($array)) == 1 && parent::isAssociative($array)) {
               // Loosely structured associative array (type => value)
               foreach ($array as $k => $v) {
                  return new self($k, $v);
               }
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ItemAttribute'));
         $root->appendChild($doc->createElement('Type'))->appendChild($doc->createTextNode($this->type));
         $root->appendChild($doc->createElement('Value'))->appendChild($doc->createTextNode($this->value));
         return $doc;
      }
   }
 
   class Metric extends ReportBuilder {
      /* 
       * @var int Metric element "PubYr"
       * @access private
       */
      private $pubYr;
      /* 
       * @var int Metric element "PubYrFrom"
       * @access private
       */
      private $pubYrFrom;
      /* 
       * @var int Metric element "PubYrTo"
       * @access private
       */
      private $pubYrTo;
      /* 
       * @var COUNTER\DateRange Metric element "Period"
       * @access private
       */
      private $period;
      /* 
       * @var COUNTER\Category Metric element "Category"
       * @access private
       */
      private $category;
      /* 
       * @var array one or more COUNTER\PerformanceCounter elements
       * @access private
       */
      private $instance;
 
      public function __construct($period, $category, $instances, $pubYrFrom = NULL, $pubYrTo = NULL, $pubYr = NULL) {
         $this->period = $this->validateOneOf($period, 'DateRange');
         $this->category = $this->validateString($category);
         if (!in_array($category, $this->getCategories())) {
            throw new \Exception('Invalid category: '.$category);
         }
         $this->instance = $this->validateOneOrMoreOf($instances, 'PerformanceCounter');
         if ($pubYrFrom) {
            $this->pubYrFrom = $this->validatePositiveInteger($pubYrFrom);
         }
         if ($pubYrTo) {
            $this->pubYrTo = $this->validatePositiveInteger($pubYrTo);
         }
         if ($pubYr) {
            $this->pubYr = $this->validatePositiveInteger($pubYr);
         }
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['Period']) && isset($array['Instance']) && isset($array['Category'])) {
               // Nicely structured associative array
               $instances = parent::buildMultiple('COUNTER\PerformanceCounter', $array['Instance']);
               return new self(
                  DateRange::build($array['Period']),
                  $array['Category'],
                  $instances,
                  isset($array['PubYrFrom']) ? $array['PubYrFrom']: NULL,
                  isset($array['PubYrTo']) ? $array['PubYrTo'] : NULL,
                  isset($array['PubYr']) ? $array['PubYr'] : NULL
               );
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('ItemPerformance'));
         if ($this->period) {
            $root->appendChild($doc->importNode($this->period->asDOMDocument()->documentElement, true));
         }
         if ($this->category) {
            $root->appendChild($doc->createElement('Category'))->appendChild($doc->createTextNode($this->category));
         }
         foreach ($this->instance as $instance) {
            $root->appendChild($doc->importNode($instance->asDOMDocument()->documentElement, true));
         }
         foreach (array('pubYr', 'pubYrFrom', 'pubYrTo') as $pubYrKey) {
            if ($this->$pubYrKey) {
               $root->appendChild($doc->createElement(ucfirst($pubYrKey)))->appendChild($doc->createTextNode($this->$pubYrKey));
               $attr = $doc->createAttribute(ucfirst($pubYrKey));
               $attr->value = $this->$pubYrKey;
               $root->appendChild($attr);
            }
         }
         return $doc;
      }
 
      }
 
   class DateRange extends ReportBuilder {
      /* 
       * @var \DateTime DateRange element "Begin"
       * @access private
       */
      private $begin;
      /* 
       * @var \DateTime DateRange element "End"
       * @access private
       */
      private $end;
 
      public function __construct($begin, $end) {
         $this->begin = $this->validateOneOf($begin, '\DateTime');
         $this->end = $this->validateOneOf($end, '\DateTime');
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['Begin']) && isset($array['End'])) {
               // Nicely structured associative array
               return new self($array['Begin'], $array['End']);
            } elseif (count(array_keys($array)) == 2 && !parent::isAssociative($array)) {
               // Unstructured array of two elements, assume begin and end dates
               return new self($array[0], $array[1]);
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('Period'));
         $root->appendChild($doc->createElement('Begin'))->appendChild($doc->createTextNode(date_format($this->begin, 'Y-m-d')));
         $root->appendChild($doc->createElement('End'))->appendChild($doc->createTextNode(date_format($this->end, 'Y-m-d')));
         return $doc;
      }
   }
 
   class PerformanceCounter extends ReportBuilder {
      /* 
       * @var COUNTER\MetricType PerformanceCounter element "MetricType"
       * @access private
       */
      private $metricType;
      /* 
       * @var int PerformanceCounter element "Count"
       * @access private
       */
      private $count;
 
      public function __construct($metricType, $count) {
         $this->metricType = $this->validateString($metricType);
         if (!in_array($metricType, $this->getMetricTypes())) {
            throw new \Exception('Invalid metric type: '.$metricType);
         }
         $this->count = $this->validatePositiveInteger($count);
      }
 
      public static function build($array) {
         if (is_array($array)) {
            if (isset($array['MetricType']) && isset($array['Count'])) {
               // Nicely structured associative array
               return new self($array['MetricType'], $array['Count']);
            } elseif (count(array_keys($array)) == 1 && parent::isAssociative($array)) {
               // Loosely structured associative array (type => count)
               foreach ($array as $k => $v) {
                  return new self($k, $v);
               }
            }
         }
         parent::build($array);
      }
 
      public function asDOMDocument() {
         $doc = new \DOMDocument();
         $root = $doc->appendChild($doc->createElement('Instance'));
         $root->appendChild($doc->createElement('MetricType'))->appendChild($doc->createTextNode($this->metricType));
         $root->appendChild($doc->createElement('Count'))->appendChild($doc->createTextNode($this->count));
         return $doc;
      }
   }
 
}