Parses the placeholder
171546
private function parse()
    {
        if (!self::$placeholders) {
            self::loadConfig();
        }
        $this->type = '';
        $this->modifiers = self::$lModifiers;
        $ph = $this->placeholder;
        if ($ph == '') {
            return true;
        }
        $comp = explode('-', $ph);
        if (count($comp) > 1) {
            $type = array_shift($comp);
            if (isset(self::$longs[$type])) {
                $this->type = self::$longs[$type];
            } elseif (isset(self::$longModifiers[$type])) {
                $this->modifiers[self::$longModifiers[$type]] = true;
            } else {
                return $this->error();
            }
            foreach ($comp as $c) {
                if (isset(self::$longModifiers[$c])) {
                    $this->modifiers[self::$longModifiers[$c]] = true;
                } else {
                    return $this->error();
                }
            }
            return true;
        }
        if (isset(self::$longs[$ph])) {
            $this->type = self::$longs[$ph];
            return true;
        }
        if (isset(self::$longModifiers[$ph])) {
            $this->modifiers[self::$longModifiers[$ph]] = true;
            return true;
        }
        $type = $ph[0];
        if (isset(self::$placeholders[$type])) {
            $this->type = $type;
        } elseif (isset(self::$lModifiers[$type])) {
            $this->modifiers[$type] = true;
        } else {
            return $this->error();
        }
        $len = strlen($ph);
        for ($i = 1; $i < $len; $i++) {
            $modifier = $ph[$i];
            if (isset(self::$lModifiers[$modifier])) {
                $this->modifiers[$modifier] = true;
            } else {
                return $this->error();
            }
        }
        return true;
    }
1160951
def fill_placeholders(self, tags):
        """"""
        def change_p_node_tags(node, children):
            if isinstance(node, Placeholder):
                value = ConstExpr(tags[node.name])
                return value
            else:
                return node.clone(children)

        return map_tree(change_p_node_tags, self)
825130
public function getPlaceholder(): Placeholder
    {
        if ($this->placeholderInstance === null) {
            $this->placeholderInstance = new Placeholder();
        }

        return $this->placeholderInstance;
    }
180193
static boolean validate(String value, List<JQLPlaceHolder> placeHolders, int pos) {
		return placeHolders.get(pos).value.equals(value);
	}
700610
private void parse()
    {
        this.elements = new ArrayList<>();

        try {
            for (Tokenizer tokenizer = new Tokenizer(this.rawVersion); tokenizer.next();) {
                Element element = new Element(tokenizer);
                this.elements.add(element);
                if (element.getVersionType() != Type.STABLE) {
                    this.type = element.getVersionType();
                }
            }

            trimPadding(this.elements);
        } catch (Exception e) {
            // Make sure to never fail no matter what
            LOGGER.error("Failed to parse version [" + this.rawVersion + "]", e);
            this.elements.add(new Element(this.rawVersion));
        }
    }
504073
def do_jsonplaceholder(parser, token):
    
    name, params = parse_placeholder(parser, token)
    return JsonPlaceholderNode(name, **params)
419759
function extractPlaceholders(messageBundle) {
	      var messageMap = messageBundle.getMessageMap();
	      var placeholders = {};
	      Object.keys(messageMap).forEach(function (msgId) {
	          placeholders[msgId] = messageMap[msgId].placeholders;
	      });
	      return placeholders;
	  }
1291650
protected final String resolvePlaceholder(final String placeholderWithDefault, final Properties props,
                                              final int systemPropertiesMode) {
        String placeholder = getPlaceholder(placeholderWithDefault);
        String resolved = super.resolvePlaceholder(placeholder, props, systemPropertiesMode);
        if (resolved == null) {
            resolved = getDefault(placeholderWithDefault);
        }
        return resolved;
    }
649537
def _collect_placeholders_required(
            self):
        
        self.log.info('starting the ``_collect_placeholders_required`` method')

        phs = self.settings["frankenstein"]["placeholder delimiters"]
        phsString = "|".join(phs)

        matchObject = re.finditer(
            r'(%(phsString)s)([^\s]*?)\1' % locals(),
            string=self.contentString,
            flags=re.S  # re.S
        )

        phDict = {}
        for match in matchObject:
            phDict[match.group(2)] = None

        self.phDict = phDict

        self.log.info(
            'completed the ``_collect_placeholders_required`` method')
        return None
1069449
def set_placeholder(self, text):
        
        if self._placeholder != text:
            self._placeholder = text
            if not self.hasFocus():
                self.update()
539157
function getPlaceholderElement() {
        var placeholder;
        angular.forEach(element.children(), function(childNode) {
          var child = angular.element(childNode);
          if (child.hasClass('dndPlaceholder')) {
            placeholder = child;
          }
        });
        return placeholder || angular.element("<li class='dndPlaceholder'></li>");
      }
1002595
def _get_placeholder_arg(arg_name, placeholder):
    
    if placeholder is None:
        raise RuntimeWarning(u"placeholder object is None")
    elif isinstance(placeholder, Placeholder):
        return placeholder
    elif isinstance(placeholder, Manager):
        manager = placeholder
        try:
            parent_object = manager.instance  # read RelatedManager code
        except AttributeError:
            parent_object = None

        try:
            placeholder = manager.all()[0]
            if parent_object is not None:
                placeholder.parent = parent_object  # Fill GFK cache
            return placeholder
        except IndexError:
            raise RuntimeWarning(u"No placeholders found for query '{0}.all.0'".format(arg_name))
    else:
        raise ValueError(u"The field '{0}' does not refer to a placeholder object!".format(arg_name))
1238116
def do_contactplaceholder(parser, token):
    
    name, params = parse_placeholder(parser, token)
    return ContactPlaceholderNode(name, **params)
98237
function parseTag(position, tokens) {
	let token;
	let tag = {
		name : null,
		self : false,
		open : true
	};

	while (token = tokens[position++]) {
		// tag's end found so parsing must stop
		if (token.type === TokenTypes.TagEnd) {
			break;
		}

		// save the tag's name and continue parsing
		if (!tag.name && token.type === TokenTypes.TagName) {
			tag.name = token.value;
			continue;
		}

		// if a "/" is found after the tag's name, then it's a self-closing tag
		if (token.type === TokenTypes.TagClose) {
			tag.self = tag.open = !!tag.name;
		}
	}

	return tag;
}
378305
function getPlaceholder(column) {
      var placeholder = this.isFilterable(column) && column.filterOptions.placeholder || "Filter ".concat(column.label);
      return placeholder;
    }
886539
def _base_placeholder(self):
        
        layout, idx = self.part.slide_layout, self._element.ph_idx
        return layout.placeholders.get(idx=idx)
855505
function (placeholderPath) {
            var outputContent;
            var typeUtil = ariaUtilsType;
            var pageConfig = this._pageConfigs[this.currentPageId];
            if (pageConfig) {
                var placeholders = pageConfig.pageComposition.placeholders;
                var content = placeholders[placeholderPath] || [];
                outputContent = [];
                var plainContent;
                if (!typeUtil.isArray(content)) {
                    content = [content];
                }

                for (var i = 0, ii = content.length; i < ii; i++) {
                    var item = content[i];
                    if (typeUtil.isObject(item)) {
                        if (this._lazyContent && item.lazy) {
                            outputContent.push({
                                loading : true,
                                width : item.lazy.width || null,
                                height : item.lazy.height || null,
                                color : item.lazy.color || null,
                                innerHTML : item.lazy.innerHTML || null
                            });
                        } else {
                            if (item.template) {
                                outputContent.push(this._getTemplateCfg(item, pageConfig));
                            } else if (item.contentId) {
                                plainContent = this._getPlaceholderContents(pageConfig, item.contentId);
                                outputContent = outputContent.concat(plainContent);
                            }
                        }
                    } else {
                        outputContent.push(item);
                    }
                }
            }
            return outputContent;
        }