getValue

@return  array
968814
public function getValue()
    {
        $value = parent::getValue();

        if (is_string($value)) {
            $value = explode(',', $value);
        }

        return $value;
    }
727448
public function getValue()
    {
        $values = array();
        foreach (array_keys($this->pages) as $id) {
            $pageValues = $this->getSessionContainer()->getValues($id);
            // skip elements representing actions
            foreach ($pageValues as $key => $value) {
                if (0 !== strpos($key, '_qf')) {
                    if (isset($values[$key]) && is_array($value)) {
                        $values[$key] = self::arrayMerge($values[$key], $value);
                    } else {
                        $values[$key] = $value;
                    }
                }
            }
        }
        return $values;
    }
591090
public function get_value() {
		$value  = parent::get_value();

		if ( is_array( $value ) ) {
			$value = json_encode( $value );
		}

		return $value;
	}
467899
public function getValue() {
		$value = $this->value;
		foreach($this->outputs as $inflector) {
			$value = $inflector($value);
		}
		return $value;
	}
271423
public function getValue()
    {
        if ( ! isset($this->input[$this->inputName])) {
            return null;
        }

        return $this->input[$this->inputName];
    }
19032
final public static function getValues(): array
    {
        if (isset(self::$cache[static::class])) {
            return self::$cache[static::class];
        }

        $rc = new \ReflectionClass(static::class);

        return self::$cache[static::class] = $rc->getConstants();
    }
1302181
public function getValues()
    {
        $values = array();
        foreach ($this->rows as $name => $row) {
            $values[$name] = $row->getValue();
        }

        return $values;
    }
320858
public function getValue() {
    $value = [];
    $definitions = $this->entityTypeManager->getDefinitions();

    foreach ($definitions as $definition) {
      $entity_type_id = $definition->id();
      // We don't need to add config entities.
      if ($definition instanceof ConfigEntityType) {
        continue;
      }

      $entity_bundle_info = \Drupal::service('entity_type.bundle.info');
      $bundle_info = $entity_bundle_info->getBundleInfo($entity_type_id);
      $bundles = [];

      if (count($bundle_info) > 1) {
        foreach ($bundle_info as $bundle_id => $bundle_data) {
          // Suppress warning about unused variable.
          unset($bundle_data);
          $keys = $definition->getKeys();
          $bundle_key = $keys['bundle'] === NULL ? 'bundle' : $keys['bundle'];

          $query = \Drupal::entityQuery($entity_type_id);
          $query->condition($bundle_key, $bundle_id);
          $query->count();
          $count = $query->execute();

          $row = [
            'bundle' => $bundle_id,
            'count' => $count,
          ];

          $bundles[] = $row;
        }
      }

      $storage = $this->entityTypeManager->getStorage($entity_type_id);
      $query = $storage->getAggregateQuery();
      $query->count();
      $count = $query->execute();

      $entity = [
        'entity_type' => $entity_type_id,
        'count' => $count,
        'bundles' => $bundles,
      ];

      $value[$entity_type_id] = $entity;
    }

    return $value;
  }
1079761
public function getValue()
    {
        if (!empty($this->elements)) {
            $value = [];
            foreach ($this->elements as $el) {
                if ($el->getKey() !== null) {
                    $value[$el->getKey()] = $el->getValue();
                } else {
                    $value[] = $el->getValue();
                }
            }

            return $value;
        } else {
            return $this->value;
        }
    }
695294
public function getValue()
    {
        return $this->storage->getValue($this->name, $this->defaultValue, $this->type);
    }
98636
public function getParsedValue()
    {
        if ($this->parsedValue) {
            return $this->parsedValue;
        }

        $parsedValue = Convert::json2array($this->dataValue());
        return $this->parsedValue = ArrayData::create((array) $parsedValue);
    }
928170
protected function getValue() {
        if (($this->data == '0' || !empty($this->data)) && !is_object($this->data)) {
            $value = ($this->parent && is_array($this->data)) ? $this->data[0] : $this->data;
        } else if ($this->options->default == '0' || !empty($this->options->default)) {
            $value = $this->options->default;
        } else if (($this->options->value == '0' || !empty($this->options->value)) && !is_object($this->options->value)) {
            $value = $this->options->value;
        }

        if ($this->options->processValue) {
            $value = call_user_func($this->options->processValue, $value);
        }
        return $value;
    }
797411
public function getValue(): string
    {
        if (!$this->validated && $this->defaultValue !== null) {
            return $this->defaultValue;
        }

        if ($this->value === null) {
            return '';
        }

        return $this->value;
    }
832486
public function getValue()
    {
        if ( ! $this->isSet() and isset($this->default))
        {
            $this->setValue($this->default, true);
        }

        return $this->value;
    }
298667
public function getValues()
    {
        $contentType = $this->getContenttype();
        if (!isset($contentType['fields'])) {
            return [];
        }

        $allValues = $this->toArray();

        return array_intersect_key($allValues, ($contentType['fields']));
    }
1268802
public function getValue() {
    $version = 0;
    $profile = \Drupal::installProfile();
    if ($profile === 'social') {
      $info = system_get_info('module', $profile);
      $version = $info['version'];
    }
    return [
      'version' => $version,
    ];
  }
1003023
public function getValue()
    {
        // if size of children smaller than minimum
        if (count($this->properties) < $this->getMinOccurs()) {
            for ($i = count($this->properties); $i < $this->getMinOccurs(); ++$i) {
                $this->initProperties($i, $this->getDefaultTypeName());
            }
        }

        $data = [];
        foreach ($this->properties as $type) {
            $result = ['type' => $type->getName()];
            foreach ($type->getChildProperties() as $property) {
                $result[$property->getName()] = $property->getValue();
            }
            $data[] = $result;
        }

        return $data;
    }