Retrieves a value from the `directives` array.
967734
function loadDirective(index) {
    ngDevMode && assertDefined(directives, 'Directives array should be defined if reading a dir.');
    ngDevMode && assertDataInRange(index, directives);
    return directives[index];
}
779955
def _parse_directive(self, directive):
        
        words = directive.split()
        if len(words) == 1 and words[0] not in ('include', 'exclude',
                                                'global-include',
                                                'global-exclude',
                                                'recursive-include',
                                                'recursive-exclude',
                                                'graft', 'prune'):
            # no action given, let's use the default 'include'
            words.insert(0, 'include')

        action = words[0]
        patterns = thedir = dir_pattern = None

        if action in ('include', 'exclude',
                      'global-include', 'global-exclude'):
            if len(words) < 2:
                raise DistlibException(
                    '%r expects <pattern1> <pattern2> ...' % action)

            patterns = [convert_path(word) for word in words[1:]]

        elif action in ('recursive-include', 'recursive-exclude'):
            if len(words) < 3:
                raise DistlibException(
                    '%r expects <dir> <pattern1> <pattern2> ...' % action)

            thedir = convert_path(words[1])
            patterns = [convert_path(word) for word in words[2:]]

        elif action in ('graft', 'prune'):
            if len(words) != 2:
                raise DistlibException(
                    '%r expects a single <dir_pattern>' % action)

            dir_pattern = convert_path(words[1])

        else:
            raise DistlibException('unknown action %r' % action)

        return action, patterns, thedir, dir_pattern
1046064
function() {
      var values = inputEx.TimeRange.superclass.getValue.call(this);

		var returnedValue = [];
		returnedValue.push(values[0]+":"+values[1]);
		returnedValue.push(values[2]+":"+values[3]);
		
      return returnedValue;
   }
434293
protected function updateFromDirectives(array $directives)
    {
        $this->directives = $directives;
        $this->values = array();

        foreach ($directives as $key => $value) {
            $this->values[] = $value === true ? $key : "{$key}={$value}";
        }
    }
713321
public function getValue()
    {
        if ($this->children) {
            $value = array();
            foreach ($this->children as $childKey => $child) {
                $childValue = $child->getValue();
                if (isset($childValue)) {
                    $value[$childKey] = $childValue;
                }
            }
        }
        return !empty($value) ? $value : $this->value;
    }
623467
function _findValue(&$values)
    {
        if (empty($values)) {
            return null;
        }
        $elementName = $this->getName();
        if (isset($values[$elementName])) {
            return $values[$elementName];
        } elseif (strpos($elementName, '[')) {
            $keys = str_replace(
                array('\\', '\'', ']', '['), array('\\\\', '\\\'', '', "']['"),
                $elementName
            );
            $arrayKeys = explode("']['", $keys);
            return HTML_QuickForm_utils::recursiveValue($values, $arrayKeys);
        } else {
            return null;
        }
    }
259395
function toSearchArgumentArray(value) {
        if (value) {
            if (angular.isArray(value))
                return value;
            if (angular.isString(value))
                return value.split(',');
        }
        return [];
    }
599721
public function getValue()
    {
        $value = $this->argument->getValue();
        return $value === null || $value === [] ? $this->argument->getDefaultValue() : $value;
    }
1091066
function getValue(data, path) {
  if (typeof data !== 'object' || data === null) {
    return void 0;
  } else if (path.length === 1) {
    return data[path[0]];
  }
  return getValue(data[path[0]], path.slice(1));
}
1223950
def parse_directive_location(lexer: Lexer) -> NameNode:
    """"""
    start = lexer.token
    name = parse_name(lexer)
    if name.value in .__members__:
        return name
    raise unexpected(lexer, start)
739494
function (value) {
            if (value && this.controller && this.controller.getDisplayTextFromValue) {
                return this.controller.getDisplayTextFromValue(this._cfg.prefill);
            } else {
                return value;
            }
        }
317318
function getValue(item, keyOrPath) {
  const keys = keyOrPath.split('.');
  const used = [];
  while (keys.length > 0) {
    const key = keys.shift();
    used.push(key);
    if (!isValid(item[key])) {
      throw new Error(`path ${used.join('.')} is not an object`);
    }
    item = item[key];
  }
  return item[keys[0]];
}
1083448
public function getValue()
    {
        $values = array();
        foreach ($this as $child) {
            $value = $child->getValue();
            if (null !== $value) {
                if ($child instanceof HTML_QuickForm2_Container
                    && !$child->prependsName()
                ) {
                    $values = self::arrayMerge($values, $value);
                } else {
                    $name = $child->getName();
                    if (!strpos($name, '[')) {
                        $values[$name] = $value;
                    } else {
                        $tokens   =  explode('[', str_replace(']', '', $name));
                        $valueAry =& $values;
                        do {
                            $token = array_shift($tokens);
                            if (!isset($valueAry[$token])) {
                                $valueAry[$token] = array();
                            }
                            $valueAry =& $valueAry[$token];
                        } while (count($tokens) > 1);
                        $valueAry[$tokens[0]] = $value;
                    }
                }
            }
        }
        return empty($values)? null: $this->applyFilters($values);
    }
447502
function getTag(dom) {
  return dom.tagName && __TAG_IMPL[getAttr(dom, IS_DIRECTIVE) ||
    getAttr(dom, IS_DIRECTIVE) || dom.tagName.toLowerCase()]
}
317488
private function getValuesAsArray()
    {
        if ($this->value === null) {
            return is_array($this->defaultValue) 
                ? $this->defaultValue 
                : [ $this->defaultValue ];
        }
        return $this->value;
    }
373276
function resolveDirectiveValue(directive, part) {
  // Directives are synchronous, so it's safe to read and delete value
  directive(part);
  const value = part._value;
  part._value = undefined;
  return value;
}
1133318
function getSelectValue (elem) {
  var value, option, i
  var options = elem.options
  var index = elem.selectedIndex
  var one = elem.type === 'select-one'
  var values = one ? null : []
  var max = one ? index + 1 : options.length

  if (index < 0) {
    i = max
  } else {
    i = one ? index : 0
  }

  // Loop through all the selected options
  for (; i < max; i++) {
    option = options[i]

    // Support: IE <=9 only
    // IE8-9 doesn't update selected after form reset
    if ((option.selected || i === index) &&

        // Don't return options that are disabled or in a disabled optgroup
        !option.disabled &&
        (!option.parentNode.disabled ||
          option.parentNode.tagName.toLowerCase() === 'optgroup')) {
      // Get the specific value for the option
      value = option.value

      // We don't need an array for one selects
      if (one) {
        return value
      }

      // Multi-Selects return an array
      values.push(value)
    }
  }

  return values
}