Returns whether the value is inside the cluster
 Params:
 +value+: value to compare
 Output:
 :ok or :shorter or :longer
482828
def inside_cluster(value)
      limits = get_limits
      left = limits[0]
      right = limits[1]

      :ok if left <= value && right >= value
      :shorter if left >= value
      :longer if right <= value
    end
538704
def has_full_stack(self, value):
        
        if value == self._defaults['hasFullStack'] and 'hasFullStack' in self._values:
            del self._values['hasFullStack']
        else:
            self._values['hasFullStack'] = value
300563
def contains_value(self, value):
        
        check_not_none(value, "value can't be None")
        value_data = self._to_data(value)
        return self._encode_invoke(multi_map_contains_value_codec, value=value_data)
529305
def rank(self, value):
        ''''''
        value = self.value_pickler.dumps(value)
        return self.backend_structure().rank(value)
728007
def __within2(value, within=None, errmsg=None, dtype=None):
    ''''''
    valid, _value = False, value
    if dtype:
        try:
            _value = dtype(value)  # TODO: this is a bit loose when dtype is a class
            valid = _value in within
        except ValueError:
            pass
    else:
        valid = _value in within
    if errmsg is None:
        if dtype:
            typename = getattr(dtype, '__name__',
                               hasattr(dtype, '__class__')
                               and getattr(dtype.__class__, 'name', dtype))
            errmsg = '{0} within \'{1}\''.format(typename, within)
        else:
            errmsg = 'within \'{0}\''.format(within)
    return (valid, _value, errmsg)
181584
def flag(short_name, long_name, description, &block)
			return define_value(short_name, long_name, description, true, false, block)
		end
325782
def _has_match(self, assembled_summary):
        ''''''
        if assembled_summary.startswith('yes'):
            if self.data[0]['var_only'] == '0' or self._to_cluster_summary_has_known_nonsynonymous(assembled_summary) == 'yes':
                return 'yes'
            else:
                return 'no'
        else:
            return 'no'
393709
def ok(self):
        
        try:
            v = float(self._value)
            if v < self.fmin or v > self.fmax:
                return False
            else:
                return True
        except:
            return False
853289
public boolean containsValue(Object value) {
		// the value is a direct hit from our cache
		if(cache.containsValue(value))
			return true;
		// the value is a direct hit from our hashmap
		if(container.containsValue(value))
			return true;
		
		// otherwise, the value isn't within this object
		return false;
	}
582872
def run(self, value):
        
        if self.pass_ and not value.strip():
            return True

        if self.minimum <= len((value.strip() if self.strip else value)) <= self.maximum:
            return True

        self.error = self.error.format(value, self.minimum, self.maximum)
        return False
410574
def ok(self):
        
        try:
            v = int(self._value)
            chunk = self.mfac.value()
            if v < self.imin or v > self.imax or (v % chunk != 0):
                return False
            else:
                return True
        except:
            return False
437849
def grouping_val(self):
        
        grouping = self.grouping
        if grouping is None:
            return ST_Grouping.STANDARD
        val = grouping.val
        if val is None:
            return ST_Grouping.STANDARD
        return val
23985
def has_value(cls, value: int) -> bool:
        """"""
        return any(value == item.value for item in cls)
463558
@Override
    public boolean containsValue(Object value) {
        try {
            lockAllSegments();
            for (LinkedHashMapSegment<K, V> seg : segments) {
                if (seg.containsValue(value))
                    return true;
            }
            return false;
        } finally {
            unlockAllSegments();
        }
    }
337395
def comparison_value(value, position)
			return value if value.class != Range
			position == :first ? value.first : value.last
		end
1035352
def value
      val = self.lazy_proc?(@value) ? self.coerce(@value.call) : @value
      val.respond_to?(:returned_value) ? val.returned_value : val
    end
978078
def is_clustered(self):
        
        self.open()
        clust = lvm_vg_is_clustered(self.handle)
        self.close()
        return bool(clust)