Looks up a proxy object.
512465
public Object lookup(String type, String url)
        throws IOException
    {
        return new BurlapRemote(type, url);
    }
594735
function FixtureProxy(fixture, childIndex) {
  this.aabb = new AABB();
  this.fixture = fixture;
  this.childIndex = childIndex;
  this.proxyId;
}
340112
function lookup(uri, opts) {
    if (typeof uri === "object") {
      opts = uri;
      uri = undefined;
    }

    opts = opts || {};

    var parsed = url_1(uri);
    var source = parsed.source;
    var id = parsed.id;
    var path = parsed.path;
    var sameNamespace = cache[id] && path in cache[id].nsps;
    var newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;

    var io;

    if (newConnection) {
      debug("ignoring socket cache for %s", source);
      io = manager(source, opts);
    } else {
      if (!cache[id]) {
        debug("new io instance for %s", source);
        cache[id] = manager(source, opts);
      }
      io = cache[id];
    }
    if (parsed.query && !opts.query) {
      opts.query = parsed.query;
    }
    return io.socket(parsed.path, opts);
  }
595221
def _map_unity_proxy_to_object(value):
    
    vtype = type(value)
    if vtype in _proxy_map:
        return _proxy_map[vtype](value)
    elif vtype == list:
        return [_map_unity_proxy_to_object(v) for v in value]
    elif vtype == dict:
        return {k:_map_unity_proxy_to_object(v) for k,v in value.items()}
    else:
        return value
901803
def loads(self, param):
        '''
        
        '''
        if isinstance(param, ProxyRef):
            try:
                return self.lookup_url(param.url, param.klass, param.module)
            except HostError:
                print "Can't lookup for the actor received with the call. \
                    It does not exist or the url is unreachable.", param
                raise HostError(param)
        elif isinstance(param, list):
            return [self.loads(elem) for elem in param]
        elif isinstance(param, tuple):
            return tuple([self.loads(elem) for elem in param])
        elif isinstance(param, dict):
            new_dict = param
            for key in new_dict.keys():
                new_dict[key] = self.loads(new_dict[key])
            return new_dict
        else:
            return param
1126410
def get(self, instance, **kwargs):
        
        # The default value
        default = self.getDefault(instance)

        # Retrieve the proxy object
        proxy_object = self.get_proxy(instance)

        # Return None if we could not find a proxied object, e.g. through
        # the proxy expression 'context.getSample()' on an AR
        if proxy_object is None:
            logger.debug("Expression '{}' did not return a valid Proxy Object on {}"
                         .format(self.proxy, instance))
            return default

        # Lookup the proxied field by name
        field_name = self.getName()
        field = proxy_object.getField(field_name)

        # Bail out if the proxy object has no identical named field
        if field is None:
            raise KeyError("Object '{}' with id '{}' has no field named '{}'".format(
                proxy_object.portal_type, proxy_object.getId(), field_name))

        # return the value of the proxy field
        return field.get(proxy_object)
1107995
def get_proxy(self):
        
        if self.proxy_list is None or len(self.proxy_list) <= 0:
            return None, None, None, None
        self.proxy_index += 1
        self.proxy_index = self.proxy_index % len(self.proxy_list)
        item = self.proxy_list[self.proxy_index]
        if len(item) == 2:
            return item[0], item[1], None, None
        else:
            return item[0], item[1], item[2], item[3]
1089632
private Object extractObjectToStore(Object obj)
    {
        Object result = obj;
        // only do something if obj != null
        if(result != null)
        {
            // ProxyObjects only have to be updated if their real
            // subjects have been loaded
            result = getProxyFactory().getRealObjectIfMaterialized(obj);
            // null for unmaterialized Proxy
            if (result == null)
            {
                if(logger.isDebugEnabled())
                    logger.debug("No materialized object could be found -> nothing to store," +
                            " object was " + ObjectUtils.identityToString(obj));
            }
        }
        return result;
    }
1032031
private Proxy lookupProxy(String hostKey, String portKey, Proxy.Type type, int defaultPort) {
        String host = System.getProperty(hostKey);
        if (host == null || host.isEmpty()) {
            return null;
        }

        int port = getSystemPropertyInt(portKey, defaultPort);
        return new Proxy(type, InetSocketAddress.createUnresolved(host, port));
    }
715232
def objectproxy_realaddress(obj):
    
    voidp = QROOT.TPython.ObjectProxy_AsVoidPtr(obj)
    return C.addressof(C.c_char.from_buffer(voidp))
74654
function proxyProperty(proto, property, type) {
    let desc = {};
    if (type === 0) {
        desc.value = function(...args) {
            checkNode.call(this);
            return this.node[property].call(this.node, ...args);
        };
    } else if (type > 0) {
        desc.get = function() {
            checkNode.call(this);
            return this.node[property];
        };
        if (type > 1) {
            desc.set = function(val) {
                checkNode.call(this);
                return this.node[property] = val;
            };
        }
    }
    Object.defineProperty(proto, property, desc);
}
1313240
async def get_http_proxy(cls) -> typing.Optional[str]:
        
        data = await cls.get_config("http_proxy")
        return None if data is None or data == "" else data
403771
def getProxyForObject(self, obj):
        
        proxied = self.proxied_objects.get(id(obj))

        if proxied is None:
            from pyamf import flex

            proxied = flex.proxy_object(obj)

            self.addProxyObject(obj, proxied)

        return proxied
727592
def is_proxy(elt):
    

    if ismethod(elt):
        elt = get_method_function(elt)

    result = hasattr(elt, __PROXIFIED__)

    return result
585810
def find_object(self, object_type):
        """"""
        node = self
        while node is not None:
            if isinstance(node.obj, object_type):
                return node.obj
            node = node.parent
1050223
function(proxy, isReversed){
		if(arguments.length === 1){
			isReversed = arguments[0];
			proxy = new HSVDistanceProxy();
		}

		if(this.colors.length === 0){
			return this;
		}

		// Remove the darkest color from the stack,
		// put it in the sorted list as starting element.
		var root = this.getDarkest(),
			stack = this.colors.slice(0),
			sorted = [];

		stack.splice(stack.indexOf(root),1);
		sorted.push(root);

		// Now find the color in the stack closest to that color.
		// Take this color from the stack and add it to the sorted list.
		// Now find the color closest to that color, etc.
		var sortedCount = 0;
		while(stack.length > 1){
			var closest = stack[0],
				lastSorted = sorted[sortedCount],
				distance = proxy.distanceBetween(closest, lastSorted);

			for(var i = stack.length - 1; i >= 0; i--){
				var c = stack[i],
					d = proxy.distanceBetween(c, lastSorted);
				if(d < distance){
					closest = c;
					distance = d;
				}
			}
			stack.splice(stack.indexOf(closest),1);
			sorted.push(closest);
			sortedCount++;
		}
		sorted.push(stack[0]);
		if(isReversed){
			sorted.reverse();
		}
		this.colors = sorted;
		return this;
	}
352784
def find(self, resource_id, query=None):
        

        return self.proxy.find(resource_id, query=query)