1: <?php
  2: 
  3: /**
  4:  * Picon Framework
  5:  * http://code.google.com/p/picon-framework/
  6:  *
  7:  * Copyright (C) 2011-2012 Martin Cassidy <martin.cassidy@webquub.com>
  8: 
  9:  * Picon Framework is free software: you can redistribute it and/or modify
 10:  * it under the terms of the GNU General Public License as published by
 11:  * the Free Software Foundation, either version 3 of the License, or
 12:  * (at your option) any later version.
 13: 
 14:  * Picon Framework is distributed in the hope that it will be useful,
 15:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17:  *  General Public License for more details.
 18: 
 19:  * You should have received a copy of the GNU General Public License
 20:  * along with Picon Framework.  If not, see <http://www.gnu.org/licenses/>.
 21:  * */
 22: 
 23: namespace picon;
 24: 
 25: /**
 26:  * Helper class for finding specific tags in markup
 27:  * 
 28:  * @todo refactor to remove duplicate code
 29:  * @todo alter to return an array if multiple matching tags exist
 30:  * @author Martin Cassidy
 31:  * @package utilities
 32:  */
 33: class MarkupUtils
 34: {
 35:     private function __constructor()
 36:     {
 37:         
 38:     }
 39:     
 40:     public static function findComponentTag($markup, $componentTagId, Component $component)
 41:     {
 42:         if(is_array($markup))
 43:         {
 44:             $componentTag = null;
 45:             foreach($markup as $element)
 46:             {
 47:                 self::validateElement($element);
 48:                 $componentTag = self::internalFindComponentTag($element, $componentTagId, $component);
 49:                 if($componentTag!=null)
 50:                 {
 51:                     break;
 52:                 }
 53:             }
 54:             return $componentTag;
 55:         }
 56:         else
 57:         {
 58:             self::validateElement($markup);
 59:             return self::findComponentTag($markup->getChildren(), $componentTagId, $component);
 60:         }
 61:     }
 62:     
 63:     private static function validateElement($element)
 64:     {
 65:         if(!($element instanceof XmlElement))
 66:         {
 67:             throw new \InvalidArgumentException(sprintf("Expected XmlElement %s given.", gettype($element)));
 68:         }
 69:     }
 70:     
 71:     private static function internalFindComponentTag(XmlElement $markup, $componentTagId, Component $component)
 72:     {
 73:         if($markup instanceof ComponentTag && $markup->getComponentTagId()==$componentTagId)
 74:         {
 75:             return $markup;
 76:         }
 77:         else
 78:         {
 79:             if(($markup instanceof MarkupElement) && $markup->hasChildren() && (!($markup instanceof ComponentTag) || $component->getId()==$markup->getComponentTagId()))
 80:             {
 81:                 $componentTag = null;
 82:                 foreach($markup->getChildren() as $element)
 83:                 {
 84:                     if($element instanceof MarkupElement)
 85:                     {
 86:                         $componentTag = self::internalFindComponentTag($element, $componentTagId, $component);
 87:                         if($componentTag!=null)
 88:                         {
 89:                             return $componentTag;
 90:                         }
 91:                     }
 92:                 }
 93:             }
 94:             return null;
 95:         }
 96:     }
 97:     
 98:     public static function findPiconTag($type, $markup)
 99:     {
100:         if(is_array($markup))
101:         {
102:             $piconTag = null;
103:             foreach($markup as $element)
104:             {
105:                 self::validateElement($element);
106:                 $piconTag = self::internalFindPiconTag($element, $type);
107:                 if($piconTag!=null)
108:                 {
109:                     break;
110:                 }
111:             }
112:             return $piconTag;
113:         }
114:         else
115:         {
116:             self::validateElement($markup);
117:             return self::internalFindPiconTag($markup, $type);
118:         }
119:     }
120:     
121:     private static function internalFindPiconTag(MarkupElement $markup, $type)
122:     {
123:         if($markup instanceof PiconTag && $markup->getName()=='picon:'.$type)
124:         {
125:             return $markup;
126:         }
127:         else
128:         {
129:             if($markup->hasChildren())
130:             {
131:                 $piconTag = null;
132:                 foreach($markup->getChildren() as $element)
133:                 {
134:                     if($element instanceof MarkupElement)
135:                     {
136:                         $piconTag = self::internalFindPiconTag($element, $type);
137:                         if($piconTag!=null)
138:                         {
139:                             return $piconTag;
140:                         }
141:                     }
142:                 }
143:             }
144:             return null;
145:         }
146:     }
147: }
148: 
149: ?>
150: