Parameter: String
506807
public function getPathFromFile($filename)
	{
		$i = strrpos($filename, self::getSlash());

		if ($i!== false)
		{
			return substr($filename, 0, $i);
		}
		else
		{
			return $filename;
		}
	}
464232
def string(description: str, **kwargs) -> typing.Type:
    
    kwargs['description'] = description
    return type('String', (String,), kwargs)
265764
private void setString(String s) {
        _string.reset();
        _string.append(s);
        _length = s.length();
    }
1345038
function parseParamString(paramString) {
    var obj = {};

    if ( typeof paramString !== "undefined" ){
        paramString
            .substring(1, paramString.length - 1) //strip off { and }
            .replace(/([a-zA-z-]+)=(.*?)(, |$)/g, function(_, header, val) {
              //Force "true" and "false" into Boolean
              if (val === "true") val = true;
              if (val === "false") val = false;

              obj[header.toLowerCase()] = val;
            });
    }

    return obj;
}
224455
function(name, value) {
            var parameters = this.parameters;

            if (arguments.length < 1)
                return parameters[name] || parameters['/' + name];

            if (value !== parameters[name]) {
                parameters[name] = value;
            }
        }
2852
function str(input) {
  if (!is('String', input)) return;
  return root[input] || (root.require || require)(input);
}
1140052
function params(p) {

  var result = "";
  _.each(p, function (val) {
    result = result + spliter + val;
  });

  return result;
}
1139073
private void parseParameters(String input) {
        for (String param : input.split("&")) {
            String[] pair = param.split("=");

            String name = (pair.length > 0) ? pair[0] : null;
            String value = (pair.length > 1) ? pair[1] : null;

            if (name != null) {
                setParameter(name, value);
            }
        }
    }
1252370
public static Object getParameterValueFromString(String parameterClass, String value) throws Exception {
	   return getParameterValueFromString(parameterClass, value, null);
   }
865866
def do_parameter(self,args):
        """"""
        parser = CommandArgumentParser("parameter")
        parser.add_argument(dest="id",help="Parameter to print")
        args = vars(parser.parse_args(args))
        
        print "printing parameter {}".format(args['id'])
        try:
            index = int(args['id'])            
            parameter = self.wrappedStack['resourcesByTypeName']['parameters'][index]
        except ValueError:
            parameter = self.wrappedStack['resourcesByTypeName']['parameters'][args['id']]

        print(parameter.resource_status)
80223
public String parameterToString(Object param) {
        if (param == null) {
            return "";
        } else if (param instanceof Date || param instanceof DateTime || param instanceof LocalDate) {
            //Serialize to json string and remove the " enclosing characters
            String jsonStr = json.serialize(param);
            return jsonStr.substring(1, jsonStr.length() - 1);
        } else if (param instanceof Collection) {
            StringBuilder b = new StringBuilder();
            for (Object o : (Collection)param) {
                if (b.length() > 0) {
                    b.append(",");
                }
                b.append(String.valueOf(o));
            }
            return b.toString();
        } else {
            return String.valueOf(param);
        }
    }
854972
public void addNextString(String string)
    {
        int iLength = string.length();
        char charLength = (char)iLength;
        String strNew = m_string + charLength + string;
        m_string = strNew;
    }
889595
def hasParam(self, paramName):
        
        if isinstance(paramName, basestring):
            p = getattr(self, paramName, None)
            return isinstance(p, Param)
        else:
            raise TypeError("hasParam(): paramName must be a string")
803959
def _paramstr(ins):
    
    (tmp, output) = _str_oper(ins.quad[1])
    output.pop()  # Remove a register flag (useless here)
    tmp = ins.quad[1][0] in ('#', '_')  # Determine if the string must be duplicated

    if tmp:
        output.append('call __LOADSTR')  # Must be duplicated
        REQUIRES.add('loadstr.asm')

    output.append('push hl')
    return output
664319
public static String paramMapToString(final Map<String, String[]> parameters) {

        final StringBuffer result = new StringBuffer();
        for (final String key : parameters.keySet()) {
            String[] values = parameters.get(key);
            if (null == values) {
                result.append(key).append('&');
            } else {
                for (final String value : parameters.get(key)) {
                    result.append(key).append('=').append(CmsEncoder.encode(value)).append('&');
                }
            }
        }
        // remove last '&'
        if (result.length() > 0) {
            result.setLength(result.length() - 1);
        }
        return result.toString();
    }
979044
def p_param(self, p):
        ''
        paramlist = [Parameter(rname, rvalue, lineno=p.lineno(2))
                     for rname, rvalue in p[2]]
        p[0] = Decl(tuple(paramlist), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
1248453
function paramsFromStringPath(path, paramsObj) {
        //Get all the parameter names from the path.
        var elements = path.split('/');
        var params = elements.reduce(function(params, element) {
            if (element.charAt(0) === ':') {
                var paramName = element.slice(1);
                params.push(paramsObj[paramName]);
            }
            return params;
        }, []);
        return params;
    }