Stop selectively ignoring certain types when wrapping attributes.

        :param class type: The class/type definition to stop ignoring.

        :rtype list(type): The current list of ignored types
182537
def wrapper__unignore(self, type_):
        
        if type_ in self.__exclusion_list:
            self.__exclusion_list.remove( type_ )
        return self.__exclusion_list
1266327
def klass_for_type(type, singular=false)
      type = type.singularize unless singular
      type.classify.constantize
    end
1208436
public final void registerIgnoreAll(final Class type, String... excludeColumns) {
        Set<String> set = ignoreAlls.get(type);
        if (set == null) {
            ignoreAlls.put(type, new HashSet<>(Arrays.asList(excludeColumns)));
        } else {
            set.addAll(Arrays.asList(excludeColumns));
        }
    }
1127947
def all_subclasses(cls: type) -> Tuple[type, ...]:
    
    subclasses = []
    for subclass in cls.__subclasses__():
        subclasses.append(subclass)
        subclasses.extend(all_subclasses(subclass))
    return tuple(subclasses)
885369
def stub(base_class=None, **attributes):
    
    if base_class is None:
        base_class = object

    members = {
        "__init__": lambda self: None,
        "__new__": lambda *args, **kw: object.__new__(
            *args, *kw
        ),  # remove __new__ and metaclass behavior from object
        "__metaclass__": None,
    }
    members.update(attributes)
    # let's create a python class on-the-fly :)
    return type(f"{base_class.__name__}Stub", (base_class,), members)()
32988
public static <T> Typed<T> wrap(final Class<T> type) {
        return TypeUtils.wrap((Type) type);
    }
301130
public void markParentClasses(TypeElement type) {
    while (type != null) {
      String typeID = ElementReferenceMapper.stitchClassIdentifier(type, env.elementUtil());
      ReferenceNode node = elementReferenceMap.get(typeID);
      if (node == null) {
        ErrorUtil.warning("Encountered .class parent class while accessing: " + typeID);
        return;
      }
      if (node.reachable) {
        return;
      }
      node.reachable = true;
      if (ElementUtil.isStatic(type)) {
        return;
      }
      type = ElementUtil.getDeclaringClass(type);
    }
  }
848017
public static Class<?> wrap(final Class<?> type) {
	if (!type.isPrimitive()) {
	    throw new IllegalArgumentException("Not primitive");
	}
	return PRIMITIVES_WRAPPERS.get(type);
    }
615136
public ClassReloadingStrategy reset(Class<?>... type) throws IOException {
        return type.length == 0
                ? this
                : reset(ClassFileLocator.ForClassLoader.of(type[0].getClassLoader()), type);
    }
433532
public void notThrown(Class<? extends Throwable> type) {
    Throwable thrown = getSpecificationContext().getThrownException();
    if (thrown == null) return;
    if (type.isAssignableFrom(thrown.getClass())) {
      throw new UnallowedExceptionThrownError(type, thrown);
    }
    ExceptionUtil.sneakyThrow(thrown);
  }
429287
def typechecked_class(cls, force = False, force_recursive = False):
    
    return _typechecked_class(cls, set(), force, force_recursive)
309376
def listify(obj, ignore=(list, tuple, type(None))):
    '''  '''
    return obj if isinstance(obj, ignore) else [obj]
610123
def wrapped_attributes(list = {}, for_definition = false)
      return unless (bracket = accept :brackets)

      accept_newline
      attributes_assignments list, true, for_definition
      accept_newline

      accept_stripped bracket.to_sym, :*

      list
    end
703924
public static Class<?> wrapArrayType(Class<?> type) {
        Class<?> clazz = primToWrapArrayClasses.get(type);
	    return null != clazz ? clazz : type;
	}
631232
def set_forbidden_types(self, types):
        
        if self._forbidden_types == types:
            return
        self._forbidden_types = types
        self.invalidateFilter()
1173261
public static <T> AttributeType<T> newTypeOf(final Class<T> type) {
	return new AttributeType<T>(type) {};
    }
902971
public static boolean isClassVetoed(Class<?> type) {
        if (type.isAnnotationPresent(Vetoed.class)) {
            return true;
        }
        return isPackageVetoed(type.getPackage());
    }