Returns for given parameter <i>_name</i> the instance of class
{@link Person}.

@param _name name to search in the cache
@throws EFapsException on error
@return instance of class {@link Person}
@see #CACHE
@see #getFromDB
176495
public static Person get(final String _name)
        throws EFapsException
    {
        final Cache<String, Person> cache = InfinispanCache.get().<String, Person>getCache(Person.NAMECACHE);
        if (!cache.containsKey(_name)) {
            Person.getPersonFromDB(Person.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
1300781
public static Command get(final String _name)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Command>get(_name, Command.class, CIAdminUserInterface.Command.getType());
    }
1039975
public static Menu get(final String _name)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Menu>get(_name, Menu.class, CIAdminUserInterface.Menu.getType());
    }
1148395
@Override
    public Return execute(final Parameter _parameter)
        throws EFapsException
    {
        Return ret = null;
        _parameter.put(ParameterValues.PROPERTIES, new HashMap<>(super.evalProperties()));
        try {
            EventDefinition.LOG.debug("Invoking method '{}' for Resource '{}'", this.methodName, this.resourceName);
            final Class<?> cls = Class.forName(this.resourceName, true, EFapsClassLoader.getInstance());
            final Method method = cls.getMethod(this.methodName, new Class[] { Parameter.class });
            ret = (Return) method.invoke(cls.newInstance(), _parameter);
            EventDefinition.LOG.debug("Terminated invokation of method '{}' for Resource '{}'",
                            this.methodName, this.resourceName);
        } catch (final SecurityException e) {
            EventDefinition.LOG.error("security wrong: '{}'", this.resourceName, e);
        } catch (final IllegalArgumentException e) {
            EventDefinition.LOG.error("arguments invalid : '{}'- '{}'", this.resourceName, this.methodName, e);
        } catch (final IllegalAccessException e) {
            EventDefinition.LOG.error("could not access class: '{}'", this.resourceName, e);
        } catch (final InvocationTargetException e) {
            EventDefinition.LOG.error("could not invoke method: '{}' in class: '{}'", this.methodName,
                            this.resourceName, e);
            throw (EFapsException) e.getCause();
        } catch (final ClassNotFoundException e) {
            EventDefinition.LOG.error("class not found: '{}" + this.resourceName, e);
        } catch (final NoSuchMethodException e) {
            EventDefinition.LOG.error("could not find method: '{}' in class '{}'",
                            new Object[] { this.methodName, this.resourceName, e });
        } catch (final InstantiationException e) {
            EventDefinition.LOG.error("could not instantiat Class: '{}'", this.resourceName, e);
        }
        return ret;
    }
737739
public T getObjectFromNameClassPair(NameClassPair nameClassPair) {
		if (!(nameClassPair instanceof SearchResult)) {
			throw new IllegalArgumentException("Parameter must be an instance of SearchResult");
		}

		SearchResult searchResult = (SearchResult) nameClassPair;
		Attributes attributes = searchResult.getAttributes();
		try {
			return mapper.mapFromAttributes(attributes);
		}
		catch (javax.naming.NamingException e) {
			throw LdapUtils.convertLdapException(e);
		}
	}
126870
def get_profile_class(name):
    
    if name not in CLASS_CACHE:
        profile_data = PROFILES[name]
        profile_name = clean(name)
        class_name = '{}{}Profile'.format(
            profile_name[0].upper(), profile_name[1:])
        new_class = type(class_name, (BaseProfile,), {'profile_data': profile_data})
        CLASS_CACHE[name] = new_class

    return CLASS_CACHE[name]
1216907
def lookupByName(self, name):
        
        res = yield queue.executeInThread(self.connection.lookupByName, name)
        return self.DomainClass(self, res)
996626
private final CClassLoader getLoaderByName(final String name) {
		try {

			CClassLoader loader = (CClassLoader) this.childrenMap.get(name);

			if (loader == null) {
				loader = CClassLoader.createLoader(this, name);
				this.childrenMap.put(name, loader);
			}

			return loader;
		} finally {
			try {

			} catch (final Exception ignore) {
			}
		}
	}
838559
public static MsgPhrase get(final long _id)
        throws EFapsException
    {
        final Cache<Long, MsgPhrase> cache = InfinispanCache.get().<Long, MsgPhrase>getCache(MsgPhrase.IDCACHE);
        if (!cache.containsKey(_id)) {
            MsgPhrase.loadMsgPhrase(_id);
        }
        return cache.get(_id);
    }
88888
public static AccessSet get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, AccessSet> cache = InfinispanCache.get().<String, AccessSet>getCache(AccessSet.NAMECACHE);
        if (!cache.containsKey(_name)) {
            AccessSet.getAccessSetFromDB(AccessSet.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
1187407
public static function get($name = null)
    {
        $name = $name ?: self::_DEFAULT;
        if (!isset(self::$caches[$name])) {
            throw new CacheException("Cache '$name' not found");
        }
        return self::$caches[$name];
    }
984468
public Object getObject()
        throws EFapsException
    {
        Object ret = null;
        if (this.valueSelect == null) {
            // if the fromSelect has data
            if (this.fromSelect.hasResult()) {
                // and there are more than one id the current object must not be null
                if (this.idList.size() > 1 && this.currentObject != null) {
                    ret = this.fromSelect.getMainOneSelect().getObject(this.currentObject);
                // or if there is only one id the first objectvalue must not be null
                } else if (this.idList.size() == 1 && this.objectList.get(0) != null) {
                    ret = this.fromSelect.getMainOneSelect().getObject(this.currentObject);
                }
            }
        } else {
            // if the currentObject is not null it means that the values are
            // retrieved by iteration through the object list
            if (this.currentId != null) {
                ret = this.valueSelect.getValue(this.currentObject);
            } else {
                ret = this.valueSelect.getValue(this.objectList);
            }
        }
        return ret;
    }
668370
@Override
    public Object getMember(String name) {
        switch (name) {
            case "version":
                return F_version;
            case "sparkContext":
                return F_sparkContext;
            case "sqlContext":
                return F_sqlContext;
//            case "listenerManager":
//                return F_listenerManager;
//            case "experimental":
//                return F_experimental;
            case "udf":
                return F_udf;
            case "streams":
                return F_streams;
            case "newSession":
                return F_newSession;
//            case "emptyDataset":
//                return F_emptyDataset;
            case "createDataFrame":
                return F_createDataFrame;
            case "createDataFrameFromJson":
                return F_createDataFrameFromJson;
            case "baseRelationToDataFrame":
                return F_baseRelationToDataFrame;
            case "createDataset":
                return F_createDataset;
            case "createDatasetFromJson":
                return F_createDatasetFromJson;
            case "range":
                return F_range;
            case "table":
                return F_table;
            case "sql":
                return F_sql;
            case "read":
                return F_read;
            case "readStream":
                return F_readStream;
            case "stop":
                return F_stop;
        }
        return super.getMember(name);
    }
870481
public Class<?> getClassByEntityName(String name) {
        if (StringUtils.isBlank(name)) {
            throw new IllegalArgumentException("name cannot be null or empty.");
        }
        return entries.get(name);
    }
380677
@SuppressWarnings("unchecked")
    public <T> T getNamedObject(String name) {
        return (T)_named.get(name);
    }
710512
protected List<Instance> getSuper(final Instance _instance)
        throws EFapsException
    {
        final List<Instance> ret = new ArrayList<>();
        final QueryBuilder queryBldr = new QueryBuilder(getClassName4Type2Type());
        queryBldr.addWhereAttrEqValue(CIAdminProgram.Program2Program.From, _instance.getId());
        final MultiPrintQuery multi = queryBldr.getPrint();
        multi.addAttribute(CIAdminProgram.Program2Program.To);
        multi.execute();
        if (multi.next()) {
            final Instance instance = Instance.get(getClassName4Type().getType(),
                                             multi.<Long>getAttribute(CIAdminProgram.Program2Program.To));
            ret.add(instance);
            ret.addAll(getSuper(instance));
        }
        return ret;
    }
318958
private static Class getByClass(String name) {
        try {
            return Thread.currentThread().getContextClassLoader().loadClass(name);
        } catch (Throwable e) {
        }
        return null;
    }