getter of a value corresponding to a key.
@return mixed                     value corresponding to the key
@throws DbManagementException     if key is not present in values array
541803
public function getValue($key){
        
        if(!array_key_exists($key, $this->values)){
            throw new DbManagementException(DbManagementException::UNEXISTING_KEY);
        }
        return $this->values[$val];
    }
382837
public function __getter($key)
    {
        if (isset($key, $this->ignoreData[$key])) {
            return $this->ignoreData[$key];
        }

        $attrs = $this->getAttrs();

        $value = null;

        if (isset($attrs[$key], $attrs[$key]['type'])) {
            if (in_array($attrs[$key]['type'], array(self::DATA_TYPE_REFERENCE, self::DATA_TYPE_REFERENCES))) {
                return $this->loadRef($key);
            } elseif (in_array($attrs[$key]['type'], array(self::DATA_TYPE_EMBED, self::DATA_TYPE_EMBEDS))) {
                return $this->loadEmbed($key);
            }
        }

        if (isset($this->cleanData[$key])) {
            $value = $this->parseValue($key, $this->cleanData[$key],$this->getAttrs());
            return $value;
        }

    }
642698
public function getValues(): array
    {
        $result = array();

        foreach ($this->_definition as $key => $value) {
            $result[$key] = $this->$key;
        }

        return $result;
    }
76310
public function getValue() {
		$value = array();
		foreach ($this->decorated->getValue() as $key => $decoratedFieldValue) {
			if (array_key_exists(self::PROPERTY_NAME, $decoratedFieldValue)) {
				$value[$key] = $decoratedFieldValue[self::PROPERTY_NAME];
			}
		}
		return $value;
	}
1308194
public function getValueAttribute()
    {
        if (!isset($this->cachedValue)) {
            $this->cachedValue = $this->getDataTypeRegistry()
                ->getHandlerForType($this->type)
                ->unserializeValue($this->attributes['value']);
        }

        return $this->cachedValue;
    }
268107
public function getValue($key)
	{
		if ($this->item instanceof LeanMapper\Entity) {
			return $this->getLeanMapperEntityProperty($this->item, $key);

		} elseif ($this->item instanceof Nextras\Orm\Entity\Entity) {
			return $this->getNextrasEntityProperty($this->item, $key);

		} elseif ($this->item instanceof DibiRow) {
			return $this->item->{$this->formatDibiRowKey($key)};

		} elseif ($this->item instanceof ActiveRow) {
			return $this->getActiveRowProperty($this->item, $key);

		} elseif ($this->item instanceof Nette\Database\Row) {
			return $this->item->{$key};

		} elseif (is_array($this->item)) {
			$arrayValue = $this->item[$key];

			if (is_object($arrayValue) && method_exists($arrayValue, '__toString')) {
				return $arrayValue->__toString();
			}

			return $arrayValue;

		} else {
			/**
			 * Doctrine entity
			 */
			return $this->getDoctrineEntityProperty($this->item, $key);
		}
	}
556038
public function getRelationValue($key)
    {
        $relation = parent::getRelationValue($key);

        if ($relation instanceof Collection) {
            $relation->each(function ($model) {
                $this->setRelationConnection($model);
            });

            return $relation;
        }

        $this->setRelationConnection($relation);

        return $relation;
    }
591090
public function get_value() {
		$value  = parent::get_value();

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

		return $value;
	}
1219114
public function key()
    {
        // TODO: Track position internally to avoid repeated info() calls
        if ( ! $this->useIdentifierKeys) {
            $info = $this->mongoCursor->info();

            return isset($info['at']) ? $info['at'] : null;
        }

        return $this->mongoCursor->key();
    }
417809
public function getValue()
    {
        switch ($this->method) {
            case 'createTable':
                $columns = [];

                foreach ((array)$this->data as $column => $schema) {
                    $columns[] = TableColumnFactory::build([
                        'schema' => $this->schema,
                        'name' => $column,
                        'type' => $schema['type'],
                        'length' => $schema['length'] ?? null,
                        'isNotNull' => $schema['isNotNull'] ?? null,
                        'isUnique' => $schema['isUnique'] ?? null,
                        'isPrimaryKey' => $schema['isPrimaryKey'] ?? null,
                        'check' => $schema['check'] ?? null,
                        'default' => $schema['default'] ?? null,
                        'append' => $schema['append'] ?? null,
                        'isUnsigned' => $schema['isUnsigned'] ?? null,
                        'comment' => !empty($schema['comment']) ? $schema['comment'] : null,
                    ]);
                }
                return $columns;

            case 'renameColumn':
                return [
                    'old' => $this->data[0],
                    'new' => $this->data[1],
                ];

            case 'addColumn':
            case 'alterColumn':
                return TableColumnFactory::build([
                    'schema' => $this->schema,
                    'name' => $this->data[0],
                    'type' => $this->data[1]['type'],
                    'length' => $this->data[1]['length'] ?? null,
                    'isNotNull' => $this->data[1]['isNotNull'] ?? null,
                    'isUnique' => $this->data[1]['isUnique'] ?? null,
                    'isPrimaryKey' => $this->data[1]['isPrimaryKey'] ?? null,
                    'check' => $this->data[1]['check'] ?? null,
                    'default' => $this->data[1]['default'] ?? null,
                    'append' => $this->data[1]['append'] ?? null,
                    'isUnsigned' => $this->data[1]['isUnsigned'] ?? null,
                    'comment' => !empty($this->data[1]['comment']) ? $this->data[1]['comment'] : null,
                ]);

            case 'addPrimaryKey':
                return new TablePrimaryKey([
                    'name' => $this->data[0],
                    'columns' => $this->data[1],
                ]);

            case 'addForeignKey':
                return new TableForeignKey([
                    'name' => $this->data[0],
                    'columns' => $this->data[1],
                    'refTable' => $this->data[2],
                    'refColumns' => $this->data[3],
                ]);

            case 'createIndex':
                return new TableIndex([
                    'name' => $this->data[0],
                    'columns' => $this->data[1],
                    'unique' => $this->data[2],
                ]);

            case 'addCommentOnColumn':
                return [
                    'name' => $this->data[0],
                    'comment' => $this->data[1],
                ];

            case 'renameTable':
            case 'dropTable':
            case 'dropColumn':
            case 'dropPrimaryKey':
            case 'dropForeignKey':
            case 'dropIndex':
            case 'dropCommentFromColumn':
            default:
                return $this->data;
        }
    }
717871
public function get($key) {
        if (array_key_exists($key, $this->_fields)) {
            if (gettype($this->_fields['' . $key . '']) == 'object') {
                return $this->_fields['' . $key . '']->value;
            }
            else {
                return $this->_fields['' . $key . ''];
            }
        }
        else {
            throw new MissingEntityException('The field "' . $key . '" doesn\'t exist in ' . $this->_name);
        }
    }
1189559
public function getValue($name) {
    // return pk values as they are parts of the oid
    $mapper = ObjectFactory::getInstance('persistenceFacade')->getMapper($this->getType());
    $pkNames = $mapper->getPkNames();
    for ($i=0, $count=sizeof($pkNames); $i<$count; $i++) {
      if ($name == $pkNames[$i]) {
        $ids = $this->oid->getId();
        return $ids[$i];
      }
    }
    return $this->__call(__FUNCTION__, [$name]);
  }
1308804
public function get($key) {
		$row = $this->db->dal()->from($this->getTable())->where('key', $key)->first();
		if(isset($row['value'])) {
			$res = unserialize($row['value']);
			if(isset($res['_dataType']) && isset($res['input']))
				return $this->types[$res['_dataType']][1]($res['input']);
			else
				return $res;
		}
	}
1335068
public function getValueField()
    {
        if ($this->_valueField === null) {
            $class = $this->modelClass;
            $this->_valueField = implode("", $class::primaryKey());
        }
        
        return $this->_valueField;
    }
1316675
public function getValue($key) {
		if(isset($this->jsonArray[$key])) {
			return $this->jsonArray[$key];
		}

		return NULL;
	}
1352322
public function getAllKeyValues()
    {
        $query = $this->_table->query();

        $query->formatResults(function (ResultSet $results) {
            return $results->map(function ($row) {
                if ($row['serialized'] === true) {
                    $row['value'] = unserialize($row['value']);
                }
                return $row;
            });
        });

        $settings = [];

        foreach ($query->all() as $row) {
            $key = $row['scope'] . '__' . $row[$this->config('fields.key')];
            $value = $row[$this->config('fields.value')];
            $settings[$key] = $value;
        }

        return Hash::expand($settings, '__');
    }
580316
public function getValue()
    {
        $parts = $this->literalParts;
        
        reset($this->encodedParts);
        ksort($this->encodedParts);
        while (current($this->encodedParts) !== false) {
            $parts[key($this->encodedParts)] = $this->getNextEncodedValue();
        }
        
        ksort($parts);
        return array_reduce(
            $parts,
            function ($carry, $item) {
                return $carry . $item;
            },
            ''
        );
    }