delle richieste get (?param1=value1&param2=value2....)
16451
public function base_uri(){
    	$uri = $this->uri();
		if (($strpos = strpos($uri, '?')) !== false) 
			$uri = substr($uri, 0, $strpos);
		return $uri;
    }
615492
def in_(self, *values):
        ''' 
        '''
        return QueryExpression({
            self : { '$in' : [self.get_type().wrap_value(value) for value in values] }
        })
588762
def getCommon(self, st1, st2):
		
		fl = len(st1)
		shorter = len(st2)
		if fl < shorter:
			shorter = fl

		i = 0
		while i < shorter:
			if st1[i] != st2[i]:
				break
			i += 1
		return i
382830
function(model_name, model_schema, options) {
        if(!model_name || typeof(model_name) != "string")
            throw("Si deve specificare un nome per il modello");

        options = options || {};
        options.mismatch_behaviour = options.mismatch_behaviour || 'fail';
        if(options.mismatch_behaviour !== 'fail' && options.mismatch_behaviour !== 'drop')
            throw 'Valid option values for "mismatch_behaviour": "fail" , "drop". Got: "'+options.mismatch_behaviour+'"';

        //model_schema = schemer.normalize_model_schema(model_schema);
        schemer.validate_model_schema(model_schema);

        var base_properties = {
            name : model_name,
            schema : model_schema,
            keyspace : this._keyspace,
            mismatch_behaviour : options.mismatch_behaviour,
            define_connection : this._define_connection,
            cql : this._client,
            get_constructor : this.get_model.bind(this,model_name),
            connect: this.connect.bind(this)
        };

        return (this._models[model_name] = this._generate_model(base_properties));
    }
497156
def safe_get(d, key, def_val=None):
    
    if d.has_key(key):
        return d[key]
    else:
        return def_val
167751
public List< T> getAllByHql(String secondHalfOfHql, Object paramValue1, Type paramType1, Object paramValue2, Type paramType2) {
        return getAllByHql(secondHalfOfHql, new Object[] {paramValue1, paramValue2}, new Type[]{paramType2, paramType2}, null, null);
    }
1335175
def _parse_parameters(val_type, val):
    
    if val_type == "logical":
        return val == "T"
    elif val_type == "int":
        return int(val)
    elif val_type == "string":
        return val.strip()
    else:
        return float(val)
339556
def _resolveParam(self, param):
        
        if isinstance(param, Param):
            self._shouldOwn(param)
            return param
        elif isinstance(param, basestring):
            return self.getParam(param)
        else:
            raise ValueError("Cannot resolve %r as a param." % param)
893636
def convert(self, value, param, ctx):
        
        self.gandi = ctx.obj
        value = click.Choice.convert(self, value, param, ctx)
        return int(value)
147411
@Override
    public double getValue(IntDoubleVector params) {
        double sum = params.dot(params);
        sum *= 1./2. * lambda;
        return - sum;
    }
876519
def p_params(self, p):
        ''
        p[0] = p[1] + (p[2],)
        p.set_lineno(0, p.lineno(1))
997819
def get(self, option, default=None):
        ''''''
        val = self[option]
        return (val is None and default) or val
557424
def given(self):
        """"""
        if self._primary.value[0] and self._primary.value[2]:
            return self._primary.value[0] + ' ' + self._primary.value[2]
        return self._primary.value[0] or self._primary.value[2]
436307
def get_value(self, value):
        
        next_key = ":v%d" % self._next_value
        self._next_value += 1
        self._values[next_key] = value
        return next_key
1266567
function getIn(obj, keys, orValue) {
  var k = keys[0],
      ks = keys.slice(1);
  return get(obj, k) && ks.length ? getIn(obj[k], ks, orValue) : get(obj, k, orValue);
}
1013324
def get(self, **kwargs):
        
        clone = self.filter(**kwargs)
        num = len(clone)
        if num == 1:
            return clone._result_cache[0]
        if not num:
            raise Task.DoesNotExist(
                'Task matching query does not exist. '
                'Lookup parameters were {0}'.format(kwargs),
            )
        raise ValueError(
            'get() returned more than one Task -- it returned {0}! '
            'Lookup parameters were {1}'.format(num, kwargs),
        )
699970
def get_by_value(cls, value):
        
        for constant in cls.iterconstants():
            if constant.value == value:
                return constant
        raise ValueError(
            "Constant with value \"{0}\" is not present in \"{1}\""
            .format(value, cls)
        )