Stores a reference to an attribute on o

        :param mixed o: Some object
        :param str method_name: The name of the attribute
        :param mixed member: The attribute
966309
def __store_other(self, o, method_name, member):
        
        self.__store__[ method_name ] = eval( "o." + method_name )
        self.__store__[ method_name[0].lower() + method_name[1:] ] = eval( "o." + method_name )
976498
def value_get(method_name):
    

    def value_get(value, context, **_params):
        method = getattr(value, method_name)
        return _get(method, context["key"], (), {})

    return value_get
1022261
def define_writer_method(attribute, method_name, visibility)
      define_method(method_name) { |value| attribute.set(self, value) }
      send(visibility, method_name)
    end
67293
def attribute(name, type)
      new_attribute = Attribute.new(name, type)

      attributes << new_attribute

      define_method(name) do
        self.class.attributes.find(name).value(self)
      end
      alias_method "#{name}?", name if type == Boolean

      new_attribute
    end
1337305
def method_caller(method_name, *args, **kwargs):
	
	def call_method(target):
		func = getattr(target, method_name)
		return func(*args, **kwargs)
	return call_method
1360220
private void storeMethod(Method method, Map<Key, Array> methodsMap) {
	Key methodName = KeyImpl.init(method.getName());

	Array methodArgs;
	synchronized (methodsMap) {
	    methodArgs = methodsMap.get(methodName);
	    if (methodArgs == null) {
		methodArgs = new ArrayImpl();
		methodsMap.put(methodName, methodArgs);
	    }
	}

	storeArgs(method, methodArgs);
	// Modifier.isStatic(method.getModifiers());
    }
1315669
def get_class_method(cls_or_inst, method_name):
    
    cls = cls_or_inst if isinstance(cls_or_inst, type) else cls_or_inst.__class__
    meth = getattr(cls, method_name, None)
    if isinstance(meth, property):
        meth = meth.fget
    elif isinstance(meth, cached_property):
        meth = meth.func
    return meth
1312006
def _pv_name_attribute(opts, key, is_name_attribute=true)
        if is_name_attribute
          if opts[key] == nil
            opts[key] = self.instance_variable_get("@name")
          end
        end
      end
1317487
def method_missing(m,*a,&b)
      name = m.to_s
      if name[-1] == '?'
        name = name[0...-1].upcase.to_sym
        if constants(false).include?(name)
          v = const_get(name)
          return (value & v) == v
        end
      elsif name[-1] == '='
        name = name[0...-1].upcase.to_sym
        if constants(false).include?(name)
          v = const_get(name)
          if a[0]
            @value |= v
          else
            @value &= ~v
          end
          @name = self.class.name_for(@value)
          return a[0]
        end
      end
      super m, *a, &b
    end
1118881
def get_method_returning_field_value(self, field_name):
        
        method = getattr(self, field_name, None)
        return method if method and callable(method) else None
1302028
def method_already_there(object_type, method_name, this_class_only=False):
    
    if this_class_only:
        return method_name in vars(object_type)  # or object_type.__dict__
    else:
        try:
            method = getattr(object_type, method_name)
        except AttributeError:
            return False
        else:
            return method is not None and method is not getattr(object, method_name, None)
748942
public MethodMember getMethod(String name, String descriptor) {
		for (MethodMember method : typedescriptor.getMethods()) {
			if (method.getName().equals(name) && method.getDescriptor().equals(descriptor)) {
				return method;
			}
		}
		throw new IllegalStateException("Unable to find member '" + name + descriptor + "' on type "
				+ this.dottedtypename);
	}
723218
protected int writeEnclosingMethodAttribute(Name attributeName, ClassSymbol c) {
        if (c.owner.kind != MTH && // neither a local class
            c.name != names.empty) // nor anonymous
            return 0;

        int alenIdx = writeAttr(attributeName);
        ClassSymbol enclClass = c.owner.enclClass();
        MethodSymbol enclMethod =
            (c.owner.type == null // local to init block
             || c.owner.kind != MTH) // or member init
            ? null
            : (MethodSymbol)c.owner;
        databuf.appendChar(pool.put(enclClass));
        databuf.appendChar(enclMethod == null ? 0 : pool.put(nameType(c.owner)));
        endAttr(alenIdx);
        return 1;
    }
823117
public boolean referencesMethod(ExecutableElement method)
    {
        TypeElement declaringClass = (TypeElement) method.getEnclosingElement();
        String fullyQualifiedname = declaringClass.getQualifiedName().toString();
        String name = method.getSimpleName().toString();
        assert name.indexOf('.') == -1;
        String descriptor = Descriptor.getDesriptor(method);
        return getRefIndex(Methodref.class, fullyQualifiedname, name, descriptor) != -1;
    }
1232820
def method_missing(name, *args, &block)
      return attributes[name.to_sym] if attributes.include?(name.to_sym)
      return super
    end
793296
def method_missing(meth, *args)
      m = meth.id2name
      if m =~ /=$/
        @attributes[m.chop.to_sym] = (args.length < 2 ? args[0] : args)
      else
        @attributes[m.to_sym]
      end
    end
302620
def get_default_reference(self, method):
        
        if method not in self._available_methods:
            raise ValueError('Unknown method: {0}'.format(method))
        return self._default_references.get(method)