@Override public Set<V> get() { return EnumSet.noneOf(clazz); } }
@Override public boolean contains(Object object) { return delegate.contains(object); }
protected void parseRemote(final XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { final int count = reader.getAttributeCount(); ModelNode operation = Util.createAddOperation(SUBSYSTEM_PATH.append(SERVICE, REMOTE)); final EnumSet<EJB3SubsystemXMLAttribute> required = EnumSet.of(EJB3SubsystemXMLAttribute.CONNECTOR_REF, EJB3SubsystemXMLAttribute.THREAD_POOL_NAME); for (int i = 0; i < count; i++) { requireNoNamespaceAttribute(reader, i); final String value = reader.getAttributeValue(i); final EJB3SubsystemXMLAttribute attribute = EJB3SubsystemXMLAttribute.forName(reader.getAttributeLocalName(i)); required.remove(attribute); switch (attribute) { case CONNECTOR_REF: EJB3RemoteResourceDefinition.CONNECTOR_REF.parseAndSetParameter(value, operation, reader); break; case THREAD_POOL_NAME: EJB3RemoteResourceDefinition.THREAD_POOL_NAME.parseAndSetParameter(value, operation, reader); break; default: throw unexpectedAttribute(reader, i); } } if (!required.isEmpty()) { throw missingRequired(reader, required); } operation.get(EJB3SubsystemModel.EXECUTE_IN_WORKER).set(new ModelNode(false)); requireNoContent(reader); operations.add(operation); }
private void parseAuthorization(List<ModelNode> list, PathAddress parentAddress, XMLExtendedStreamReader reader) throws XMLStreamException { requireNoAttributes(reader); PathAddress address = parentAddress.append(AUTHORIZATION, CLASSIC); ModelNode op = Util.createAddOperation(address); list.add(op); while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); switch (element) { case POLICY_MODULE: { EnumSet<Attribute> required = EnumSet.of(Attribute.CODE, Attribute.FLAG); EnumSet<Attribute> notAllowed = EnumSet.of(Attribute.TYPE, Attribute.LOGIN_MODULE_STACK_REF); parseCommonModule(reader, address, POLICY_MODULE, required, notAllowed, list); break; } default: { throw unexpectedElement(reader); } } } }
@Override public ServiceConfigurator configure(OperationContext context, ModelNode model) throws OperationFailedException { this.mode = ModelNodes.asEnum(MODE.resolveModelAttribute(context, model), TransactionMode.class); this.locking = ModelNodes.asEnum(LOCKING.resolveModelAttribute(context, model), LockingMode.class); this.timeout = STOP_TIMEOUT.resolveModelAttribute(context, model).asLong(); this.transactionDependency = !EnumSet.of(TransactionMode.NONE, TransactionMode.BATCH).contains(this.mode) ? new ServiceDependency(context.getCapabilityServiceName(LOCAL_TRANSACTION_PROVIDER.getName(), null)) : null; this.tsrDependency = this.mode == TransactionMode.NON_XA ? new ServiceSupplierDependency<>(context.getCapabilityServiceName(TRANSACTION_SYNCHRONIZATION_REGISTRY.getName(), null)) : null; return this; }
@Override public void readElement(XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { PathAddress address = PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, SecurityExtension.SUBSYSTEM_NAME)); final ModelNode subsystemNode = Util.createAddOperation(address); operations.add(subsystemNode); requireNoAttributes(reader); final EnumSet<Element> visited = EnumSet.noneOf(Element.class); while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); if (!visited.add(element)) { throw unexpectedElement(reader); } readElement(reader, element, operations, address, subsystemNode); } }
@Override public Object instantiate(Class objectClass, FSTObjectInput in, FSTClazzInfo serializationInfo, FSTClazzInfo.FSTFieldInfo referencee, int streamPosition) throws Exception { int len = in.readInt(); Class elemCl = FSTUtil.getRealEnumClass(in.getClassForName( in.readStringUTF() )); EnumSet enSet = EnumSet.noneOf(elemCl); in.registerObject(enSet,streamPosition,serializationInfo, referencee); // IMPORTANT, else tracking double objects will fail for (int i = 0; i < len; i++) { String val = in.readStringUTF(); enSet.add(Enum.valueOf(elemCl,val)); } return enSet; } }
private void parseCustomStore(XMLExtendedStreamReader reader, PathAddress cacheAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { PathAddress address = cacheAddress.append(CustomStoreResourceDefinition.PATH); PathAddress operationKey = cacheAddress.append(StoreResourceDefinition.WILDCARD_PATH); if (operations.containsKey(operationKey)) { throw ParseUtils.unexpectedElement(reader); } ModelNode operation = Util.createAddOperation(address); operations.put(operationKey, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { XMLAttribute attribute = XMLAttribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case CLASS: { readAttribute(reader, i, operation, CustomStoreResourceDefinition.Attribute.CLASS); break; } default: { this.parseStoreAttribute(reader, i, operation); } } } if (!operation.hasDefined(CustomStoreResourceDefinition.Attribute.CLASS.getName())) { throw ParseUtils.missingRequired(reader, EnumSet.of(XMLAttribute.CLASS)); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseStoreElement(reader, address, operations); } }
@GwtIncompatible // java.lang.ref.WeakReference private static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> populateCache( Class<T> enumClass) { Map<String, WeakReference<? extends Enum<?>>> result = new HashMap<>(); for (T enumInstance : EnumSet.allOf(enumClass)) { result.put(enumInstance.name(), new WeakReference<Enum<?>>(enumInstance)); } enumConstantCache.put(enumClass, result); return result; }
private void parseJobRepository(final XMLExtendedStreamReader reader, final PathAddress subsystemAddress, final String name, final List<ModelNode> ops) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final String localName = reader.getLocalName(); final Element element = Element.forName(localName); if (element == Element.IN_MEMORY) { ops.add(Util.createAddOperation(subsystemAddress.append(InMemoryJobRepositoryDefinition.NAME, name))); ParseUtils.requireNoContent(reader); } else if (element == Element.JDBC) { final Map<Attribute, String> attributes = AttributeParsers.readRequiredAttributes(reader, EnumSet.of(Attribute.DATA_SOURCE)); final ModelNode op = Util.createAddOperation(subsystemAddress.append(JdbcJobRepositoryDefinition.NAME, name)); JdbcJobRepositoryDefinition.DATA_SOURCE.parseAndSetParameter(attributes.get(Attribute.DATA_SOURCE), op, reader); ops.add(op); ParseUtils.requireNoContent(reader); } else { throw ParseUtils.unexpectedElement(reader); } } } }
@Test public void getHandlerHttpOptions() { List<HttpMethod> allMethodExceptTrace = new ArrayList<>(Arrays.asList(HttpMethod.values())); allMethodExceptTrace.remove(HttpMethod.TRACE); testHttpOptions("/foo", EnumSet.of(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS)); testHttpOptions("/person/1", EnumSet.of(HttpMethod.PUT, HttpMethod.OPTIONS)); testHttpOptions("/persons", EnumSet.copyOf(allMethodExceptTrace)); testHttpOptions("/something", EnumSet.of(HttpMethod.PUT, HttpMethod.POST)); }
private void parseLoginModules(XMLExtendedStreamReader reader, PathAddress parentAddress, List<ModelNode> list) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); switch (element) { case LOGIN_MODULE: { EnumSet<Attribute> required = EnumSet.of(Attribute.CODE, Attribute.FLAG); EnumSet<Attribute> notAllowed = EnumSet.of(Attribute.TYPE, Attribute.LOGIN_MODULE_STACK_REF); parseCommonModule(reader, parentAddress, LOGIN_MODULE, required, notAllowed, list); break; } default: { throw unexpectedElement(reader); } } } }