tag::parameter[]
172028
@OnMessage("/socket/{name}")
    public void messageOnSeveralSockets(@Parameter("name") String name, @Body String message) {
        logger().info("Message received on {} : {}", name, message);
    }
415353
public List<Post> tagged(String tag, Map<String, ?> options) {
        if (options == null) {
            options = Collections.emptyMap();
        }
        Map<String, Object> soptions = JumblrClient.safeOptionMap(options);
        soptions.put("api_key", apiKey);
        soptions.put("tag", tag);
        return requestBuilder.get("/tagged", soptions).getTaggedPosts();
    }
273856
public static void d(String tag, String pattern, Object... parameters) {
        d(SUBSYSTEM.MAIN, tag, pattern, parameters);
    }
1364217
function add_tags( $tags )
	{
		$params = array();
		if (is_array($tags) && !empty($tags)) {
			$params['tags'] = join(',', $tags);
		} else {
			$params['tags'] = $tags;
		}
		return $this->oauth->post( 'tags/create', $params);
	}
119078
def _build_tag_param_list(params, tags):
    '''
    
    '''
    keys = sorted(tags.keys())
    i = 1
    for key in keys:
        value = tags[key]
        params['Tags.member.{0}.Key'.format(i)] = key
        if value is not None:
            params['Tags.member.{0}.Value'.format(i)] = value
        i += 1
531487
public function parseParameters($method, $tags, $availableEnums)
    {
        $ret = [];
        $constraints = [];
        if (isset($tags[self::T_CONSTRAINT])) {
            foreach ($this->mixedToArray($tags[self::T_CONSTRAINT]) as $constraint) {
                list($type, $parameter, $value) = $this->tokenize($constraint, 3);
                $parameter = ltrim($parameter, '$');
                if (!isset($constraints[$parameter])) {
                    $constraints[$parameter] = [];
                }
                $constraints[$parameter][$type] = $value;
            }
        }
        foreach (['parameter' => true, 'optparameter' => false] as $tag => $required) {
            if (isset($tags[$tag])) {
                $parameters = $this->mixedToArray($tags[$tag]);
                foreach ($parameters as $parameter) {
                    list($type, $name, $description) = $this->tokenize($parameter, 3);
                    $name = ltrim($name, '$');
                    $p = [];
                    $p['name'] = $name;

                    $http_method = $tags[self::T_METHOD];

                    $consumes = isset($tags[self::T_CONSUMES]) ? $tags[self::T_CONSUMES] : '';
                    switch ($consumes) {
                        case 'multipart/form-data':
                            $p['in'] = $this->haveParameter($method, $name) ? 'path' : 'formData';
                            break;

                        case 'application/x-www-form-urlencoded':
                            $p['in'] = $this->haveParameter($method, $name) ? 'path' : 'formData';
                            break;

                        default:
                            if (in_array($http_method, ['put', 'post'])) {
                                if ($this->isPathParameter($name, $tags[self::T_PATH])) {
                                    $p['in'] = 'path';
                                } else {
                                    $p['in'] = 'body';
                                }
                            } else {
                                if ($this->isPathParameter($name, $tags[self::T_PATH])) {
                                    $p['in'] = 'path';
                                } else {
                                    $p['in'] = $this->haveParameter($method, $name) ? 'query' : 'header';
                                }
                            }
                            break;
                    }
                    if (isset($constraints[$name])) {
                        foreach ($constraints[$name] as $constraint => $value) {
                            $p[$constraint] = $value;
                        }
                    }
                    if (!empty($description)) {
                        $p['description'] = $description;
                    }
                    $p['required'] = $required;
                    if (strpos($type, '[]') > 0) {
                        $type = str_replace('[]', '', $type);
                        if ($this->isDefinedType($type)) {
                            $p['schema'] = [
                                'type' => 'array',
                                'items' => [
                                    '$ref' => $this->getDefinition($type),
                                ]
                            ];
                        } else {
                            $p['type'] = 'array';
                            $p['items'] = ['type' => $type];
                            if (isset($availableEnums[$name])) {
                                $p['items']['enum'] = $availableEnums[$name];
                                $p['items']['default'] = count($availableEnums[$name]) ? $availableEnums[$name][0] : '';
                            }
                            $p['collectionFormat'] = 'csv';
                        }
                    } elseif ($this->isDefinedType($type)) {
                        $p['schema'] = ['$ref' => $this->getDefinition($type)];
                    } else {
                        list($type, $format) = $this->getTypeAndFormat($type);
                        $p['type'] = $type;
                        if ($format !== null) {
                            $p['format'] = $format;
                        }
                        if (isset($availableEnums[$name])) {
                            $p['enum'] = $availableEnums[$name];
                        }
                    }
                    $ret[] = $p;
                }
            }
        }
        return $ret;
    }
1182843
function ParamList(/* type | Param() arguments , ... */) {
		var params = [];
		var minSize = 0;
		var maxSize = 0;
		var easy = true;
		for (var i = 0, args; i < arguments.length; i++) {
			args = (arguments[i] instanceof Array) ? arguments[i] : [ arguments[i] ];
			params[i] = Param.parse.apply(null, args);
			maxSize += params[i].maxSize;

			// @tag 20180222 
			// 如果参数允许缺省，则在整个实参列表中占据的最小长度为 0。
			minSize += params[i].absent ? 0 : params[i].minSize;

			// 如果形参可缺省，或者为多占位或可变长度，则不适用简易模式。
			easy = easy && !( params[i].absent || params[i].arrayed );
		}

		this.easy = easy;
		this.minSize = minSize;
		this.maxSize = maxSize;

		this.params = params;
	}
372187
public function tagged()
    {
        $out = '';

        // call stream filters.
        foreach ($this->streamFilters as $f) {
            $this->tokens = call_user_func($f[1], $this->tokens);
        }
        foreach ($this->tokens as $t) {
            $type = $t[0];

            // speed is roughly 10% faster if we process the filters inside this
            // loop instead of separately.
            if (isset($this->filters[$type])) {
                foreach ($this->filters[$type] as $filter) {
                    $t = call_user_func($filter[1], $t);
                }
            }
            list($type, $string, $esc) = $t;

            if (!$esc) {
                $string = Utils::escapeString($string);
            }
            if ($type !== null) {
                $out .= Utils::tagBlock($type, $string);
            } else {
                $out .= $string;
            }
        }
        return $out;
    }
849777
public static function tags()
    {
        $args = func_get_args();
        $ret = NULL;
        foreach($args as $a)
        {
            $class = "";
            $id = "";
            $type = "";
            $text = "";
            
            if(isset($a['class']))
                $class = $a['class'];
            if(isset($a['id']))
                $id    = $a['id'];
            if(isset($a['type']))
                $type  = $a['type'];
            if(isset($a['text']))
                $text = $a['text'];
            
            unset($a['class'],$a['id'], $a['type'],$a['text']);
            
            $ret .= self::tag($type, $text, $class, $id, $a) . PHP_EOL;
            
        }
        
        return $ret;
    }
107695
function _tag_open( &$parser, $tag, $attributes ) {
		$this->currentElement = strtoupper( $tag );

		switch( $this->currentElement ) {
			case 'INDEX':
				if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
					$index = $this->addIndex( $attributes );
					xml_set_object( $parser,  $index );
				}
				break;
			case 'DATA':
				if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
					$data = $this->addData( $attributes );
					xml_set_object( $parser, $data );
				}
				break;
			case 'DROP':
				$this->drop();
				break;
			case 'FIELD':
				// Add a field
				$fieldName = $attributes['NAME'];
				$fieldType = $attributes['TYPE'];
				$fieldSize = isset( $attributes['SIZE'] ) ? $attributes['SIZE'] : NULL;
				$fieldOpts = !empty( $attributes['OPTS'] ) ? $attributes['OPTS'] : NULL;

				$this->addField( $fieldName, $fieldType, $fieldSize, $fieldOpts );
				break;
			case 'KEY':
			case 'NOTNULL':
			case 'AUTOINCREMENT':
			case 'DEFDATE':
			case 'DEFTIMESTAMP':
			case 'UNSIGNED':
				// Add a field option
				$this->addFieldOpt( $this->current_field, $this->currentElement );
				break;
			case 'DEFAULT':
				// Add a field option to the table object

				// Work around ADOdb datadict issue that misinterprets empty strings.
				if( $attributes['VALUE'] == '' ) {
					$attributes['VALUE'] = " '' ";
				}

				$this->addFieldOpt( $this->current_field, $this->currentElement, $attributes['VALUE'] );
				break;
			case 'OPT':
			case 'CONSTRAINT':
				// Accept platform-specific options
				$this->currentPlatform = ( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) );
				break;
			default:
				// print_r( array( $tag, $attributes ) );
		}
	}
953959
private function tagCloud( $params )
    {
        $parentNodeID = 0;
        $classIdentifier = '';
        $classIdentifierSQL = '';
        $pathString = '';
        $parentNodeIDSQL = '';
        $dbParams = array();
        $orderBySql = 'ORDER BY eztags.keyword ASC';

        if ( isset( $params['class_identifier'] ) )
            $classIdentifier = $params['class_identifier'];

        if ( isset( $params['parent_node_id'] ) )
            $parentNodeID = $params['parent_node_id'];

        if ( isset( $params['limit'] ) )
            $dbParams['limit'] = $params['limit'];

        if ( isset( $params['offset'] ) )
            $dbParams['offset'] = $params['offset'];

        if ( isset( $params['sort_by'] ) && is_array( $params['sort_by'] ) && !empty( $params['sort_by'] ) )
        {
            $orderBySql = 'ORDER BY ';
            $orderArr = is_string( $params['sort_by'][0] ) ? array( $params['sort_by'] ) : $params['sort_by'];

            foreach ( $orderArr as $key => $order )
            {
                if ( $key !== 0 ) $orderBySql .= ', ';
                $direction = isset( $order[1] ) ? $order[1] : false;
                switch( $order[0] )
                {
                    case 'keyword':
                    {
                        $orderBySql .= 'eztags.keyword ' . ( $direction ? 'ASC' : 'DESC' );
                    }break;
                    case 'count':
                    {
                        $orderBySql .= 'keyword_count ' . ( $direction ? 'ASC' : 'DESC' );
                    }break;
                }
            }
        }

        $db = eZDB::instance();

        if ( $classIdentifier )
        {
            $classID = eZContentObjectTreeNode::classIDByIdentifier( $classIdentifier );
            $classIdentifierSQL = "AND ezcontentobject.contentclass_id = '" . $classID . "'";
        }

        if ( $parentNodeID )
        {
            $node = eZContentObjectTreeNode::fetch( $parentNodeID );
            if ( $node )
                $pathString = "AND ezcontentobject_tree.path_string like '" . $node->attribute( 'path_string' ) . "%'";
            $parentNodeIDSQL = "AND ezcontentobject_tree.node_id != " . (int) $parentNodeID;
        }

        $showInvisibleNodesCond = eZContentObjectTreeNode::createShowInvisibleSQLString( true, false );
        $limitation = false;
        $limitationList = eZContentObjectTreeNode::getLimitationList( $limitation );
        $sqlPermissionChecking = eZContentObjectTreeNode::createPermissionCheckingSQL( $limitationList );

        $languageFilter = 'AND ' . eZContentLanguage::languagesSQLFilter( 'ezcontentobject' );
        $languageFilter .= 'AND ' . eZContentLanguage::languagesSQLFilter( 'ezcontentobject_attribute', 'language_id' );

        $rs = $db->arrayQuery( "SELECT eztags.id, eztags.keyword, COUNT(DISTINCT ezcontentobject.id) AS keyword_count
                                FROM eztags_attribute_link
                                LEFT JOIN ezcontentobject_attribute
                                    ON eztags_attribute_link.objectattribute_id = ezcontentobject_attribute.id
                                    AND eztags_attribute_link.objectattribute_version = ezcontentobject_attribute.version
                                LEFT JOIN ezcontentobject
                                    ON ezcontentobject_attribute.contentobject_id = ezcontentobject.id
                                LEFT JOIN ezcontentobject_tree
                                    ON ezcontentobject_attribute.contentobject_id = ezcontentobject_tree.contentobject_id
                                LEFT JOIN eztags
                                    ON eztags.id = eztags_attribute_link.keyword_id
                                LEFT JOIN eztags_keyword
                                    ON eztags.id = eztags_keyword.keyword_id
                                $sqlPermissionChecking[from]
                                WHERE " . eZContentLanguage::languagesSQLFilter( 'eztags' ) . "
                                    AND " . eZContentLanguage::sqlFilter( 'eztags_keyword', 'eztags' ) . "
                                    AND ezcontentobject.status = " . eZContentObject::STATUS_PUBLISHED . "
                                    AND ezcontentobject_attribute.version = ezcontentobject.current_version
                                    AND ezcontentobject_tree.main_node_id = ezcontentobject_tree.node_id
                                    $pathString
                                    $parentNodeIDSQL
                                    $classIdentifierSQL
                                    $showInvisibleNodesCond
                                    $sqlPermissionChecking[where]
                                    $languageFilter
                                GROUP BY eztags.id, eztags.keyword
                                $orderBySql", $dbParams );

        $tagsCountList = array();
        foreach( $rs as $row )
        {
            $tagsCountList[$row['id']] = $row['keyword_count'];
        }

        if ( empty( $tagsCountList ) )
            return array();
        
        /** @var eZTagsObject[] $tagObjects */
        $tagObjects = eZTagsObject::fetchList( array( 'id' => array( array_keys( $tagsCountList ) ) ) );
        if ( !is_array( $tagObjects ) || empty( $tagObjects ) )
            return array();

        $tagSortArray = array();
        $tagKeywords = array();
        $tagCounts = array();
        foreach ( $tagObjects as $tag )
        {
            $tagKeyword = $tag->attribute( 'keyword' );
            $tagCount = $tagsCountList[$tag->attribute( 'id' )];

            $tagSortArray[] = array(
                'keyword'   => $tagKeyword,
                'count'     => $tagCount,
                'tag'       => $tag
            );

            $tagKeywords[] = $tagKeyword;
            $tagCounts[] = $tagCount;
        }

        if ( isset( $params['post_sort_by'] ) )
        {
            if ( $params['post_sort_by'] === 'keyword' )
                array_multisort( $tagKeywords, SORT_ASC, SORT_LOCALE_STRING, $tagSortArray );
            else if ( $params['post_sort_by'] === 'keyword_reverse' )
                array_multisort( $tagKeywords, SORT_DESC, SORT_LOCALE_STRING, $tagSortArray );
            else if ( $params['post_sort_by'] === 'count' )
                array_multisort( $tagCounts, SORT_ASC, SORT_NUMERIC, $tagSortArray );
            else if ( $params['post_sort_by'] === 'count_reverse' )
                array_multisort( $tagCounts, SORT_DESC, SORT_NUMERIC, $tagSortArray );
        }

        $this->normalizeTagCounts( $tagSortArray, $tagCounts );

        return $tagSortArray;
    }
493077
public function parameterize($method)
    {
        $parameterArray = array();
        switch ($method) {
            case 'create':
                $parameterArray['Identifier'] = $this->getIdentifier();
                break;
            case 'update':
                $parameterArray['Identifier'] = $this->getIdentifier();
                break;
            case 'delete':
                break;
            case 'getOne':
                $parameterArray['count'] = 1;
                $parameterArray['offset'] = 0;
                break;
            case 'getAll':
                $parameterArray = $this->getFilter();
                break;
        }

        return $parameterArray;
    }
1082665
function _parseParameters(rule, parameter) {
    if (rule.toLowerCase() == 'regex') return [parameter];
    if (is_string(parameter)) {
      return parameter.split(',');
    };

    return [];
  }
446839
protected function processTaggedServices(ContainerBuilder $container, $manager, $tag, $method, $params = array())
    {
        if (!$container->hasDefinition($manager)) {
            return;
        }

        $definition = $container->getDefinition($manager);

        $taggedServices = $container->findTaggedServiceIds($tag);

        foreach ($taggedServices as $id => $attributes) {
            $methodParams = array();

            if (!empty($attributes)) {
                foreach ($params as $param) {
                    if (isset($attributes[0][$param])) {
                        $methodParams[] = $attributes[0][$param];
                    }
                }
            }

            $definition->addMethodCall(
                $method,
                array_merge(array(new Reference($id), $id), $methodParams)
            );
        }
    }
1144854
def get_parameters(parser, token):
    
    args = token.split_contents()
    if len(args) < 2:
        raise template.TemplateSyntaxError(
            "get_parameters tag takes at least 1 argument"
        )
    return GetParametersNode(args[1].strip())
675046
function parseAllTags(buf) {
  var result = [];
  var element;
  
  while (buf.length > 0) {
    element = parseTag(buf);
    buf = buf.slice(element.length);
    result.push(element.tag);
  }
  
  return result;
}
954461
function processTag(tag, targets) {
  if (tag.description) {
    tag.description = replaceLink(tag.description, targets);
  }
  if (tag.params) {
    tag.params.forEach(function (param) {
      if (param.description) {
        param.description = replaceLink(param.description, targets);
      }
    });
  }
  if (tag.members) {
    tag.members.forEach(function (member) {
      processTag(member, targets);
    });
  }
  if (tag.methods) {
    tag.methods.forEach(function (method) {
      processTag(method, targets);
    });
  }
}