return groupMembership;
    }

<<<<<<< HEAD
    private void checkIfIdentityTypeExists(IdentityType identityType, SecurityContext ctx) {
=======
    private IdentityStore getContextualStoreForFeature(IdentityStoreInvocationContext ctx, FeatureGroup feature,
            FeatureOperation operation) {
        return getContextualStoreForFeature(ctx, feature, operation, null);
    }

    private IdentityStore getContextualStoreForFeature(final IdentityStoreInvocationContext ctx, FeatureGroup feature,
            FeatureOperation operation, Class relationshipClass) {
        String realmName = (ctx.getRealm() != null) ? ctx.getRealm().getName() : Realm.DEFAULT_REALM;

        if (!realmStores.containsKey(realmName)) {
            LOGGER.identityManagerRealmNotConfigured(realmName);
            throw MESSAGES.storeConfigRealmNotConfigured(realmName);
        }

        Set configs = realmStores.get(realmName);

        IdentityStoreConfiguration config = null;
        boolean supportedRelationshipClass = true;

        for (IdentityStoreConfiguration cfg : configs) {
            if (relationshipClass != null) {
                if (cfg.getFeatureSet().supportsRelationship(relationshipClass)) {
                    if (cfg.getFeatureSet().supportsRelationshipFeature(relationshipClass, operation)) {
                        config = cfg;
                        break;
                    }
                } else {
                    supportedRelationshipClass = false;
                }
            } else if (cfg.getFeatureSet().supports(feature, operation)) {
                config = cfg;
                break;
            }
        }

        if (config == null) {
            LOGGER.identityManagerUnsupportedOperation(feature, operation);

            if (!supportedRelationshipClass) {
                throw MESSAGES.storeConfigUnsupportedRelationshipType(relationshipClass);
            } else {
                throw MESSAGES.storeConfigUnsupportedOperation(feature, operation, feature, operation);
            }
        }

        @SuppressWarnings("unchecked")
        final IdentityStore store = storeFactory.createIdentityStore(config, ctx);

        final IdentityStoreConfiguration configuration = config;

        @SuppressWarnings("unchecked")
        IdentityStore storeProxy = (IdentityStore) Proxy
                .newProxyInstance(store.getClass().getClassLoader(),
                        new Class[] { IdentityStore.class, PartitionStore.class }, new InvocationHandler() {

                            @Override
                            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                try {
                                    IdentityStoreInvocationContext.set(ctx);

                                    contextFactory.initContextForStore(ctx, store);

                                    store.setup(configuration, ctx);

                                    return method.invoke(store, args);
                                } catch (IdentityManagementException e) {
                                    throw e;
                                } catch (Exception e) {
                                    if (e.getCause() != null) {
                                        throw e.getCause();
                                    }

                                    throw e;
                                } finally {
                                    IdentityStoreInvocationContext.remove();
                                }

                            }
                        });

        LOGGER.debugf("Performing operation [%s.%s] on IdentityStore [%s] using Partition [%s]", feature, operation,
                storeProxy, ctx.getPartition());

        return storeProxy;
    }

    private IdentityStoreInvocationContext createContext() {
        IdentityStoreInvocationContext context = IdentityStoreInvocationContext.get();

        if (context == null) {
            context = this.contextFactory.createContext(this);

            context.setRealm(currentRealm.get());
            context.setTier(currentTier.get());
        }

        return context;
    }

    private void checkIfIdentityTypeExists(IdentityType identityType, IdentityStoreInvocationContext ctx) {
>>>>>>> 85963897fdbc847d1736fc1ad69434b6b4b1e9c5
        if (identityType == null) {
            throw MESSAGES.nullArgument("IdentityType");
        }

        return groupMembership;
    }


    private void checkIfIdentityTypeExists(IdentityType identityType, SecurityContext ctx) {
        if (identityType == null) {
            throw MESSAGES.nullArgument("IdentityType");
        }