GetSchemaType
@param XPathItem $item
@return XmlSchemaType
338468
public static function GetSchemaType( $item )
	{
		if ( $nav instanceof XPath2Item )
		{
			return $item->getSchemaType();
		}

		if ( $nav instanceof XPathNavigator )
		{
			/**
			 * @var XPathNavigator $nav
			 */
			$nav = $item;
			$xmlType = $nav->getSchemaType();
			if ( is_null( $xmlType ) )
			{
				return XmlSchema::$UntypedAtomic;
			}
			return $xmlType;
		}
		return $item->getSchemaType();
	}
981212
public function getValueType()
	{
		if ( $this->_value instanceof IXmlSchemaType )
		{
			return Type::FromValue( $this->_value );
		}
		else
		{
			$qn = $this->_xmlType->QualifiedName;
			$xmlType = $qn->prefix ? "{$qn->prefix}:{$qn->localName}" : "{$qn->localName}";
			return Type::XmlTypeToType( $xmlType );
		}

		return Type::FromValue( $this->_value );
	}
274782
public function get($item)
    {
        $data = $this->getData();

        return empty($data->$item) ? null : $data->$item;
    }
944135
public static function getSchemaVersion($xml)
    {
        $doiXML = new \DOMDocument();
        $doiXML->loadXML($xml);

        $resources = $doiXML->getElementsByTagName('resource');
        $theSchema = 'unknown';
        if ($resources->length > 0) {
            if (isset($resources->item(0)->attributes->item(0)->name)) {
                $theSchema = substr($resources->item(0)->attributes->item(0)->nodeValue,
                    strpos($resources->item(0)->attributes->item(0)->nodeValue,
                        "/meta/kernel") + 5);
            }
        }

        return $theSchema;
    }
772517
public function getUrlFor($item)
    {
        $routeGenerator = $this->routerGenerator;
        if (is_callable($routeGenerator)) {
            return $routeGenerator($item);
        }

        return null;
    }
469600
public function get_item_value($item) {
        if ($this->structure instanceof mod_feedback_completion) {
            return $this->structure->get_item_value($item);
        }
        return null;
    }
794223
public function getItemUrl($item)
    {
        $item = $this->getItem($item);
        return $item ? $item->normalizedUrl : null;
    }
377526
public static function getSchemaType( $domNode )
	{
		try
		{
			$types = SchemaTypes::getInstance();
			$type = $types->getTypeForDOMNode( $domNode );
			if ( $type )
			{
				// TODO Kludge alert!! The XBRL_Types class wrongly used the prefix 'xsd' instead of 'xs'
				//      This needs to be fixed but for now convert 'xs' to 'xsd'
				// BMS 2018-04-09 This can be retired
				// if ( strpos( $type, "xs:" ) === 0 ) $type = str_replace( "xs:", "xsd:", $type );

				$resolves = SchemaTypes::getInstance()->resolvesToBaseType( $type, array( "xs:anySimpleType", "xsd:anySimpleType" ) );
				if ( $resolves )
				{
					return DOMSchemaType::GetBuiltInSimpleTypeByQName( $type );
				}
			}

			return XmlSchema::$AnyType;
		}
		catch ( SchemaException $ex )
		{}

		return XmlSchema::$UntypedAtomic;

	}
134383
public static function TokenizedTypeFromXmlType( $type )
	{
		// Sanity check
		if ( is_null( $type )  || ! is_string( $type ) )
		{
			return XmlTokenizedType::None;
		}

		$types = SchemaTypes::getInstance();
		$atom = $types->getAtomicType( $type );

		return isset( XmlTokenizedType::$typeToCodeMap[ $atom ] )
			? XmlTokenizedType::$typeToCodeMap[ $atom ]
			: XmlTokenizedType::None;
	}
715368
public static function get($item, $default = null)
	{
		is_null(static::$default_check_value) and static::$default_check_value = pack('H*', 'DEADBEEFCAFE');

		if (isset(static::$items[$item]))
		{
			return static::$items[$item];
		}
		elseif ( ! isset(static::$itemcache[$item]))
		{
			$val = \Fuel::value(\Arr::get(static::$items, $item, static::$default_check_value));

			if ($val === static::$default_check_value)
			{
				return $default;
			}

			if ( ! is_scalar($val))
			{
				return $val;
			}

			static::$itemcache[$item] = $val;
		}

		return static::$itemcache[$item];
	}
709364
public function itemType() {
    $itemtype = $this->getAttribute('itemtype');
    if (!empty($itemtype)) {
      return $this->tokenList($itemtype);
    }
    // Return NULL instead of the empty string returned by getAttributes so we
    // can use the function for boolean tests.
    return NULL;
  }
534812
protected function getItemTypeConfiguration(Item $item, $language = 0)
    {
        $indexConfigurationName = $item->getIndexingConfigurationName();
        $fields = $this->getFieldConfigurationFromItemRecordPage($item, $language, $indexConfigurationName);
        if (count($fields) === 0) {
            $fields = $this->getFieldConfigurationFromItemRootPage($item, $language, $indexConfigurationName);
            if (count($fields) === 0) {
                throw new \RuntimeException('The item indexing configuration "' . $item->getIndexingConfigurationName() .
                    '" on root page uid ' . $item->getRootPageUid() . ' could not be found!', 1455530112);
            }
        }

        return $fields;
    }
81351
protected function getOriginCover(Item $item)
    {
        if (!$this->origin_dir) {
            $this->origin_dir = $this->kernel->locateResource('@AnimeDbCatalogBundle/Resources/private/images/');
        }

        return $this->origin_dir.$item->getItem()->getCover();
    }
1062778
public function getXSDType($type)
    {
        if ($this->isXDSType($type)) {
            return self::$XSDTypes[strtolower($type)];
        } elseif ($type) {
            if (strpos($type, '[]')) {
                if ($this->isXDSType(str_replace('[]', '', $type))) {
                    return self::$XSDTypes['array'];
                }
            }

            return $this->addComplexType($type);
        } else {
            return null;
        }
    }
825328
public function getXmlType()
	{
		if ( ! property_exists( $this->domNode, "schemaType" ) )
		{
			$effectiveNode = $this->domNode->nodeType == XML_TEXT_NODE ? $this->domNode->parentNode : $this->domNode;
			$this->domNode->schemaType = DOMSchemaType::getSchemaType( $effectiveNode );
		}
		return $this->domNode->schemaType;
	}
410238
private function getCurrentItem(ItemInterface $item)
    {
        foreach ($item->getChildren() as $child) {
            if ($this->matcher->isCurrent($child)) {
                return $child;
            } else {
                $child = $this->getCurrentItem($child);
                if ($child) {
                    return $child;
                }
            }
        }

        return null;
    }
200417
public static function get($item)
    {
        if (isset($_POST[$item])) {
            return $_POST[$item];
        } elseif (isset($_GET[$item])) {
            return $_GET[$item];
        } else {
            return '';
        }
    }