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

@param _name name of the type to get
@return instance of class {@link Type}
@throws CacheReloadException on error
170423
public static NumberGenerator get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, NumberGenerator> cache = InfinispanCache.get().<String, NumberGenerator>getCache(
                        NumberGenerator.NAMECACHE);
        if (!cache.containsKey(_name)) {
            NumberGenerator.getNumberGeneratorFromDB(NumberGenerator.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
615669
Class<?> getPropertyType( Clazz<?> clazz, String name )
	{
		ClassInfoCache cache = retrieveCache( clazz );

		Class<?> res = cache.getPropertyType( name );
		if( res != null )
			return res;

		Class<?> getterType = getGetterPropertyType( clazz, name );
		if( getterType == null )
			return null;

		Class<?> setterType = getSetterPropertyType( clazz, name );
		if( setterType == null )
			return null;

		if( getterType != setterType )
			return null;

		cache.setPropertyType( name, getterType );

		return getterType;
	}
1274574
public static Group get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, Group> cache = InfinispanCache.get().<String, Group>getCache(Group.IDCACHE);
        if (!cache.containsKey(_name) && !Group.getGroupFromDB(Group.SQL_NAME, _name)) {
            cache.put(_name, Group.NULL, 100, TimeUnit.SECONDS);
        }
        final Group ret = cache.get(_name);
        return ret.equals(Group.NULL) ? null : ret;
    }
57915
protected Type<?> loadType( String name )
    {
        Type<?> type = typeLoader.loadType( name );
        if (type == null) throw new TypeNotFoundException( name , this.getClass());
        return type;
    }
1059814
public ParsedField getParsableField(final String type, final String name) {
        return cache.get(ParsedField.makeId(type, name));
    }
1039975
public static Menu get(final String _name)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Menu>get(_name, Menu.class, CIAdminUserInterface.Menu.getType());
    }
285311
public static StatusGroup get(final String _typeName)
        throws CacheReloadException
    {
        final Cache<String, StatusGroup> cache = InfinispanCache.get().<String, StatusGroup>getCache(
                        Status.NAMECACHE4GRP);
        if (!cache.containsKey(_typeName)) {
            Status.getStatusGroupFromDB(Status.SQL_NAME4GRP, _typeName);
        }
        return cache.get(_typeName);
    }
748348
@Override
    public <T> T get(String name, Class<T> type) {
        Object value = get(name);
        if (value == null) {
            value = findInherited(name, type);
            if (value == null) {
                value = UNDEFINED;
            }
            put(name, value); // cache the found value
        }
        return value != UNDEFINED ? type.cast(value) : null;
    }
406302
public static final ClassInfo get(Class<?> type) {
    ClassInfo exist = cache.get(type);
    if (null != exist) return exist;
    synchronized (cache) {
      exist = cache.get(type);
      if (null != exist) return exist;

      Set<MethodInfo> methods = CollectUtils.newHashSet();
      Class<?> nextClass = type;
      int index = 0;
      Map<String, Class<?>> nextParamTypes = null;
      while (null != nextClass && Object.class != nextClass) {
        Method[] declaredMethods = nextClass.getDeclaredMethods();
        for (int i = 0, n = declaredMethods.length; i < n; i++) {
          Method method = declaredMethods[i];
          if (!goodMethod(method)) continue;
          Type[] types = method.getGenericParameterTypes();
          Class<?>[] paramsTypes = new Class<?>[types.length];
          for (int j = 0; j < types.length; j++) {
            Type t = types[j];
            if (t instanceof ParameterizedType) {
              paramsTypes[j] = (Class<?>) ((ParameterizedType) t).getRawType();
            } else if (t instanceof TypeVariable) {
              paramsTypes[j] = nextParamTypes.get(((TypeVariable<?>) t).getName());
            } else {
              paramsTypes[j] = (Class<?>) t;
            }
            if (null == paramsTypes[j]) paramsTypes[j] = Object.class;
          }
          if (!methods.add(new MethodInfo(index++, method, paramsTypes))) index--;
        }

        Type nextType = nextClass.getGenericSuperclass();
        nextClass = nextClass.getSuperclass();
        if (nextType instanceof ParameterizedType) {
          Map<String, Class<?>> tmp = CollectUtils.newHashMap();
          Type[] ps = ((ParameterizedType) nextType).getActualTypeArguments();
          TypeVariable<?>[] tvs = nextClass.getTypeParameters();
          for (int k = 0; k < ps.length; k++) {
            if (ps[k] instanceof Class<?>) {
              tmp.put(tvs[k].getName(), (Class<?>) ps[k]);
            } else if (ps[k] instanceof TypeVariable) {
              tmp.put(tvs[k].getName(), nextParamTypes.get(((TypeVariable<?>) ps[k]).getName()));
            }
          }
          nextParamTypes = tmp;
        } else {
          nextParamTypes = Collections.emptyMap();
        }
      }
      exist = new ClassInfo(methods);
      cache.put(type, exist);
      return exist;
    }
  }
234181
public Rpc rpc(String name) {
    for (Rpc rpc : rpcs) {
      if (rpc.name().equals(name)) {
        return rpc;
      }
    }
    return null;
  }
550957
public static Class<?> classForName(String name) throws ClassNotFoundException {
        if ("void".equals(name)) return void.class;
        if ("char".equals(name)) return char.class;
        if ("boolean".equals(name)) return boolean.class;
        if ("byte".equals(name)) return byte.class;
        if ("short".equals(name)) return short.class;
        if ("int".equals(name)) return int.class;
        if ("long".equals(name)) return long.class;
        if ("float".equals(name)) return float.class;
        if ("double".equals(name)) return double.class;
        return Class.forName(name, true, Thread.currentThread().getContextClassLoader());
    }
799767
public static Search get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Search>get(_id, Search.class, CIAdminUserInterface.Search.getType());
    }
400124
public <T> T getSessionObject(Class<T> type, String name) {

        T value = (T) session.get(name);
        if (logger.isDebugEnabled()) {
            logger.debug("Recovering object [" + name + "] from  session with value [" + value + "]");
        }
        return value;
    }
970782
public static SQLTable get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, SQLTable> cache = InfinispanCache.get().<String, SQLTable>getCache(SQLTable.NAMECACHE);
        if (!cache.containsKey(_name)) {
            SQLTable.getSQLTableFromDB(SQLTable.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
189382
public static Consortium get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, Consortium> cache = InfinispanCache.get().<String, Consortium>getCache(Consortium.IDCACHE);
        if (!cache.containsKey(_name) && !Consortium.getConsortiumFromDB(Consortium.SQL_NAME, _name)) {
            cache.put(_name, Consortium.NULL, 100, TimeUnit.SECONDS);
        }
        final Consortium ret = cache.get(_name);
        return ret.equals(Consortium.NULL) ? null : ret;
    }
1128544
@SuppressWarnings("unchecked")
    protected <T> T getFromCache(String cacheName, String key, Class<T> clazz) {
        Object obj = getFromCache(cacheName, key);
        if (obj == null) {
            return null;
        }
        if (clazz.isAssignableFrom(obj.getClass())) {
            return (T) obj;
        }
        return null;
    }
650531
public <T> T getNamedObject(String name, Class<T> type) {
        return type.cast(_named.get(name));
    }