Returns part of the data for the attribute

@param string $dataMember

@return string
426952
public function getDataMember( $dataMember )
    {
        if( $dataMember === 'related_images' )
        {
            $images = array();
            $relations = $this->ContentObjectAttribute->attribute( 'content' );
            foreach ( $relations['relation_list'] as $relation )
            {
                $object = eZContentObject::fetch( $relation['contentobject_id'] );
                if( $object instanceof eZContentObject )
                {
                    $dataMap = $object->attribute( 'data_map' );
                    foreach ( $dataMap as $attribute )
                    {
                        /** @var eZContentObjectAttribute $attribute */
                        if ( $attribute->attribute( 'data_type_string' ) !== eZImageType::DATA_TYPE_STRING )
                        {
                            continue;
                        }

                        if ( $attribute->hasContent() )
                        {
                            $imageAliasHandler = $attribute->attribute( 'content' );
                            $imageAlias = $imageAliasHandler->imageAlias( 'opengraph' );
                            if( $imageAlias['is_valid'] == 1 )
                            {
                                $images[] = eZSys::serverURL() . '/' . $imageAlias['full_path'];
                            }
                        }
                    }
                }
            }

            if ( empty( $images ) )
            {
                $images[] = eZSys::serverURL() . eZURLOperator::eZImage( null, 'opengraph_default_image.png', '' );
            }

            return $images;
        }

        return $this->getData();
    }
1195100
public static String getData(String dataUrl) {
        int indexOfComma = dataUrl.indexOf(',');
        return dataUrl.substring(indexOfComma + 1);
    }
813740
public function extractDefaultDataFromDataStructure($dataStructure)
    {
        $returnXML = '';
        $sheetArray = [];
        if ($dataStructure) {
            $structureArray = GeneralUtility::xml2array($dataStructure);
            if (!isset($structureArray['sheets']) && isset($structureArray['ROOT'])) {
                $structureArray['sheets']['sDEF']['ROOT'] = $structureArray['ROOT'];
                unset($structureArray['ROOT']);
            }
            if (isset($structureArray['sheets']) && !empty($structureArray['sheets'])) {
                foreach ($structureArray['sheets'] as $sheetName => $sheet) {
                    if (is_array($sheet['ROOT']['el']) && !empty($sheet['ROOT']['el'])) {
                        $elArray = [];
                        foreach ($sheet['ROOT']['el'] as $elName => $elConf) {
                            $config = $elConf['TCEforms']['config'];
                            $elArray[$elName]['vDEF'] = $config['default'];
                            if (!$elArray[$elName]['vDEF'] && $config['type'] === 'select' && !empty($config['items'])) {
                                $elArray[$elName]['vDEF'] = $config['items'][0][1];
                            }
                        }
                        $sheetArray['data'][$sheetName]['lDEF'] = $elArray;
                    }
                }
            }
            if (!empty($sheetArray)) {
                $flexformTools = GeneralUtility::makeInstance(FlexFormTools::class);
                $returnXML = $flexformTools->flexArray2Xml($sheetArray, true);
            }
        }

        return $returnXML;
    }
939234
protected function getProperty($dataName)
    {
        $dataName = explode('.', trim($dataName));

        if (count($dataName) != 2) {
            throw new Exception('You are set invalid date.');
        }

        $tableAlias = $dataName[0];
        $colName = $dataName[1];

        if ($this->query->repository()->alias() == $tableAlias) {
            return $colName;
        } elseif (array_key_exists($tableAlias, $this->query->contain())) {
            return [
                'propertyPath' => $this->query
                    ->eagerLoader()->normalized($this->query->repository())[$tableAlias]['propertyPath'],
                'field' => $colName
            ];
        }
    }
1208526
public function getPart(string $contentType)
    {
        if (! isset($this->parts[$contentType])) {
            return null;
        }

        return $this->parts[$contentType];
    }
775646
protected function getDataboxTimeEstimation(\databox $databox)
    {
        $sql = 'SELECT r.coll_id, r.type, r.record_id, s.path, s.file, r.xml
                FROM record r, subdef s
                        WHERE ISNULL(uuid)
                        AND s.record_id = r.record_id AND s.name="document"
                        AND parent_record_id = 0';

        $stmt = $databox->get_connection()->prepare($sql);
        $stmt->execute();
        $quantity = $stmt->rowCount();
        $stmt->closeCursor();

        return $quantity;
    }
996386
public static function fromDataString($dataString)
    {
        $expression = '([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(\[\])?)';  // php's expression syntax: http://www.php.net/manual/en/language.oop5.basic.php, modified with optional []
        if (preg_match_all('~[*\s]+' . $expression . ':' . $expression . '(:' . $expression . ')?+~', $dataString, $matches)) {
            $vars = $matches[1];
            $types = $matches[3];
            $scopes = $matches[6];

            $entity = new ClassEntity();
            $members = self::getMembersFor($vars, $scopes, $types);
            $entity->setMembers($members);

            if (preg_match("/DATASTRING: ([a-zA-Z]+)/", $dataString, $nameMatch)) {
                $entity->setName($nameMatch[1]);
            }

            return $entity;
        }
    }
686691
public function GetItemType( $dataPool )
	{
		if ( $this->_func->Name == "string-to-codepoints" )
			return XPath2ResultType::Number;
		return parent::GetItemType( $dataPool );
	}
709179
public function getMemberOf()
    {
        $dns = $this->getAttribute($this->schema->memberOf());

        // Normalize returned distinguished names if the attribute is null.
        return is_array($dns) ? $dns : [];
    }
1069273
protected function getData($dataRow)
    {
        $data = [];
        $relateTable = $this->getParentTableName();
        $regexp = "/{$relateTable}_(?P<name>.+)/i";
        foreach ($dataRow as $field => $value) {
            if (preg_match($regexp, $field, $matched)) {
                $data[$matched['name']] = $value;
            }
        }
        return $data;
    }
892479
public static function getDataList($dataFiled = 'text')
    {
        $result = [];
        foreach (static::getData() as $key => $value) {
            $result[$key] = $value[$dataFiled];
        }
        return $result;
    }
71800
protected function parseData($dataRaw) {
		$data = [];
		
		foreach ($dataRaw as $key => $value) {
			$data = array_replace_recursive($data, $this->parseKey($key, $value));
		}
		
		return $data;
	}
1364714
function dataMap()
    {
        if ( !isset( $this->DataMap[$this->Version] ) )
        {
            $attributes = $this->fetchAttributes( false, true, $this->Version );
            foreach ( $attributes as $attribute )
            {
                $this->DataMap[$this->Version][$attribute->attribute( 'identifier' )] = $attribute;
            }
        }
        return $this->DataMap[$this->Version];
    }
1140507
public function getData()
    {
        $relationObject = $this->ContentObjectAttribute->attribute( 'content' );

        if ( $relationObject instanceof eZContentObject )
        {
            return trim( $relationObject->attribute( 'name' ) );
        }

        return "";
    }
394443
private function getElementData(\SimpleXMLElement $element, array $dataProvider): array
    {
        $type = (string)$element->attributes()['type'];

        $type = ($type !== 'double') ? $type : 'float';

        $data = [
            'name' => (string)$element->attributes()['name'],
            'allownull' => (bool)$element->attributes()['allownull'],
            'default' => (string)$element->attributes()['default'],
            'type' => $this->getVariableType($type),
            'is_collection' => $this->isCollection($type),
            'is_dataprovider' => $this->isDataProvider($type),
            'isCamelCase' => $dataProvider['configs']['convertUnderlines']
        ];

        $singleton = (string)$element->attributes()['singleton'];
        if ($singleton !== '') {
            $data['singleton'] = (string)$element->attributes()['singleton'];
            $data['singleton_type'] = $this->getSingleVariableType($type);
        }

        return $data;
    }
353554
public function getLastUpdate()
    {
        try {
            $stmt = $this->statementContainer->prepare(
                "SELECT value FROM {$this->prefix}meta
                    WHERE name = :name"
            );
            $stmt->execute(array(
                ":name" => MetaData::LASTMODIFIED,
            ));
            $result = $stmt->fetch();
            if ($result === false) {
                throw new DataBackendException();

            }
            $stmt->closeCursor();
            return $result["value"];

        } catch (\PDOException $e) {
            $stmt->closeCursor();
            throw new DataBackendIOException($e->getMessage(), $e->getCode(), $e);

        }
    }
206632
public function GetReturnType( $dataPool )
	{
		if ( $this->_func->ResultType == XPath2ResultType::Any && $this->getCount() > 0 )
		{
			/**
			 * @var XPath2ResultType $resType
			 */
			$resType = $this->getAbstractNode(0)->GetItemType( $dataPool );
			if ( $resType == XPath2ResultType::NodeSet )
				return XPath2ResultType::Any;
			return $resType;
		}
		return $this->_func->ResultType;
	}