Returns a Get Object... same as "read"

@param cls
@return
@throws APIException
480437
public<T> Get<T> get(Class<T> cls) throws APIException {
		return new Get<T>(this,getDF(cls));
	}
211729
public static Map<String, Method> getClassReadMethods(Class<?> clazz) {
		Map<String, Method> readMethods = classReadMethods.get(clazz);
		if (readMethods == null) {
			cacheReadWriteMethodsAndBoxField(clazz);
			return classReadMethods.get(clazz);
		} else
			return readMethods;
	}
48248
public Serializer getSerializer(Class cl)
        throws HessianProtocolException
    {
        if (ObjectName.class.equals(cl)) {
            return new StringValueSerializer();
        }

        return null;
    }
1351369
def get(cls, scope=None):
        """"""
        if scope is None:
            scope = cls.default
        if isinstance(scope, string_types) and scope in cls._keywords:
            return getattr(cls, scope)
        return scope
294341
private <T> T read_(Class<T> clazz, Object id) {
		Map<String, Object> objects = objects(clazz);
		return (T) objects.get(id.toString());
	}
72081
@SuppressWarnings("unchecked")
    public <T> T getProperty(String key, Class<T> cls) {
        if (properties != null) {
            if (cls != null && cls != Object.class && cls != String.class
                    && !cls.isInterface() && !cls.isArray()) {
                // engine.getProperty("loaders", ClasspathLoader.class);
                key = key + "=" + cls.getName();
            }
            Object value = properties.get(key);
            if (value != null) {
                if (cls == String.class && value.getClass() != String.class) {
                    return (T) value.getClass().getName();
                }
                return (T) value;
            }
        }
        return null;
    }
842768
protected Object jsonDeserialize(byte[] in, Class<?> cls) {
        if (in == null || in.length == 0) {
            return null;
        }
        Object res = null;
        try {
            res = JsonUtils.json2Object(new String(in, "utf-8"), cls);
        } catch (UnsupportedEncodingException e) {
            logger.error("DeSerialize object fail ", e);
        }
        return res;
    }
9318
public static <T> T get(String className, Object... params) {
		final Class<T> clazz = ClassUtil.loadClass(className);
		return get(clazz, params);
	}
670003
private String get(String urlS) throws IOException {
        URL url = new URL(urlS);
        HttpURLConnection conn = prepareAuthorizedConnection(url);
        conn.setRequestMethod("GET");
        // Read response
        StringBuilder result = new StringBuilder();
        try (BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
            String line;
            while ((line = rd.readLine()) != null) {
                result.append(line);
            }
        }
        return result.toString();
    }
1049915
public Object get(Class entityClass, Serializable id) throws Exception {
		return get(entityClass, id, null);
	}
28599
public static ClassLoader getClassLoader(Class<?> cls) {
        ClassLoader cl = cls.getClassLoader();
        if (cl == null) {
            cl = getClassLoader();
        }
        return cl;
    }
429629
@SuppressWarnings("unchecked")
    public <T> T get(Class<T> cls) {
        T runtimeInstance = (T) runtimeServices.computeIfAbsent(cls, this::createRuntimeInstance);
        if (runtimeInstance == null) {
            throw new NoSuchElementException(cls.getName());
        } else {
            return runtimeInstance;
        }
    }
930068
public <T> T read(Class<T> clazz) {
        try {
            return readInternal(clazz);
        } catch (Exception e) {
            if (e instanceof RuntimeException) {
                throw (RuntimeException) e;
            }
            if (e instanceof IOException) {
                throw new UncheckedIOException((IOException) e);
            }
            throw new RuntimeException(e);
        }
    }
429958
public IJsonMarshaller getIJsonMarshallerInstance(Class<? extends IJsonMarshaller> cls) throws JsonMarshallerException {
		if(logger.isDebugEnabled()) {
			logger.debug("Try to get {} by CDI.select Unsatisfied: {}", cls.getName(), CDI.current().select(cls).isUnsatisfied());
		}
		if(CDI.current().select(cls).isUnsatisfied()) {
			throw new JsonMarshallerException(cls.getName()+" is Unsatisfied");
		}
		return CDI.current().select(cls).get();
	}
915230
public<T> Put<T> update(Class<T> cls) throws APIException {
		return new Put<T>(this,getDF(cls));
	}
1033505
public<T> Post<T> post(Class<T> cls) throws APIException {
		return new Post<T>(this,getDF(cls));
	}
820704
def get(cls):
        
        apikey = cls.__api_key or cls.__api_key_env_var

        if apikey:
            return apikey
        else:
            raise APIKeyMissingError("API key not set")