import org.togglz.core.Feature; //导入依赖的package包/类
public static RemoteFeatureState from(FeatureState featureState) {
  RemoteFeatureState remoteFeatureState = new RemoteFeatureState();
  RemoteFeature feature = new RemoteFeature();
  Feature featureFromGivenState = featureState.getFeature();
  feature.setName(featureFromGivenState.name());
  
  if(featureFromGivenState instanceof FeatureMetaData) {
    FeatureMetaData metaData = (FeatureMetaData) featureFromGivenState;
    feature.setLabel(metaData.getLabel());
    feature.setEnabledByDefault(metaData.isEnabledByDefault());
  }   
      
  remoteFeatureState.setFeature(feature);
  remoteFeatureState.setEnabled(featureState.isEnabled());
  remoteFeatureState.setStrategyId(featureState.getStrategyId());
  
  remoteFeatureState.setParameters(new HashMap<>(2));    
  featureState.getParameterMap().forEach((k,v) -> remoteFeatureState.getParameters().put(k, v));
  return remoteFeatureState;
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
private StateRepository createInMemoryStateRepository() {
    return new StateRepository() {

        Logger LOG = getLogger(TogglzConfiguration.class);

        private Map<String, FeatureState> featureStore = new ConcurrentHashMap<>();

        @Autowired
        UserProvider userProvider;

        @Override
        public FeatureState getFeatureState(final Feature feature) {
            if (featureStore.containsKey(feature.name())) {
                return featureStore.get(feature.name());
            }
            return new FeatureState(feature, false);
        }

        @Override
        public void setFeatureState(final FeatureState featureState) {
            featureStore.put(featureState.getFeature().name(), featureState);
            LOG.info((!StringUtils.isEmpty(userProvider.getCurrentUser().getName()) ? "User '" + userProvider.getCurrentUser().getName() + "'" : "Unknown user")
                    + (featureState.isEnabled() ? " enabled " : " disabled ") + "feature " + featureState.getFeature().name());
        }
    };
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
protected List<String> getFeatureUsers(Feature feature) {
	List<String> users = new ArrayList<String>();
	try {
		InitialContext jndiContext = getInitialContext();
		String value = (String)jndiContext.lookup(feature.name()+".users");
		if(value != null) {
			value = value.trim();
			if( !value.equals("")) {
				users = Arrays.asList(value.split("( )*,( )*"));
			}
		}
	} catch (NamingException e) {
		logger.debug("unable to fetch user lists for feature "+feature.name());
	}
	return users;
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
/**
 * Create a simple dummy Togglz config for test
 * @param featureClass
 * @return
 */
private TogglzConfig DummyTogglzConfigForTest(final Class<? extends Feature> featureClass) {
	return new TogglzConfig() {
		
		@Override
		public UserProvider getUserProvider() {
			return new NoOpUserProvider();
		}
		
		@Override
		public StateRepository getStateRepository() {
			return new InMemoryStateRepository();
		}
		
		@Override
		public Class<? extends Feature> getFeatureClass() {
			return featureClass;
		}
	};
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public FeatureMetaData getMetaData(Feature feature) {
  if (feature instanceof RemoteFeature) {
    return (RemoteFeature)feature;
  }
  return null;
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
private Map<String, FeatureToggleRepresentation> buildTogglzState(final Class<? extends Feature> featureClass) {
    final Feature[] features = featureClass.getEnumConstants();
    return stream(features)
            .collect(
                    toMap(Feature::name, this::toFeatureToggleRepresentation)
            );
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
private FeatureToggleRepresentation toFeatureToggleRepresentation(final Feature feature) {
    final Label label = getLabelAnnotation(feature);
    return new FeatureToggleRepresentation(
            label != null ? label.value() : feature.name(),
            getFeatureManager().getFeatureState(feature).isEnabled(),
            null);
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
public static void allDisabledFeatureConfig(final Class<? extends Feature> featureClass) {
    TestFeatureManager featureManager = new TestFeatureManager(featureClass);
    for (Feature feature : featureClass.getEnumConstants()) {
            featureManager.disable(feature);
    }
    TestFeatureManagerProvider.setFeatureManager(featureManager);
    clearCache();
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
private static void enableAllFeaturesThatAreOkToEnableByDefaultInAllTests(final Class<? extends Feature> featureClass, final TestFeatureManager featureManager) {
    for (Feature feature : featureClass.getEnumConstants()) {
        if (shouldRunInTests(feature)) {
            featureManager.enable(feature);
        }
    }
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
public FeatureState getFeatureState(Feature feature) {

        DataFindRequest request = new DataFindRequest(entityName, version);
        request.where(withValue("application", eq, application));
        request.select(
                Projection.array("features",
                        withValue("feature", eq, feature.name()),
                        true,
                        Projection.includeFieldRecursively("*"),
                        null
                )
        );

        try {
            LBTogglz[] result = lbClient.data(request, LBTogglz[].class);

            if (result != null && result.length==1&&result[0].getFeatures()!=null && result[0].getFeatures().size()==1) {
                LBTogglz.Toggle toggle = result[0].getFeatures().iterator().next();
                FeatureState state = new FeatureState(feature);

                state.setEnabled(toggle.isEnabled());

                String strategyValue = toggle.getStrategy();
                if (strategyValue!=null) {
                    state.setStrategyId(strategyValue.trim());
                }

                List<LBTogglz.Toggle.Parameter> parameters = toggle.getParameters();
                if (parameters!=null) {
                    for (LBTogglz.Toggle.Parameter parameter : parameters) {
                        state.setParameter(parameter.getKey(), parameter.getValue().trim());
                    }
                }

                return state;
            }
        } catch (LightblueException e) {
            e.printStackTrace();
        }

        return null;
    }
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public Set<Feature> getFeatures() {
  Set<Feature> features = new HashSet<>();
  featureStateRepository.findAll().forEach(s -> features.add(s.getFeature()));
  return features;
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public boolean isActive(Feature feature) {
  return featureStateRepository.findByFeatureName(feature.name()).getEnabled();
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public FeatureState getFeatureState(Feature feature) {
  return RemoteFeatureState.toFeatureState(featureStateRepository.findByFeatureName(feature.name()));
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public Class<? extends Feature> getFeatureClass() {
    return Features.class;
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public Class<? extends Feature> getFeatureClass() {
    return featureClassProvider.getFeatureClass();
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
private FeatureTogglesRepresentation(final Class<? extends Feature> featureClass) {
    this.features = buildTogglzState(featureClass);
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public Class<? extends Feature> getFeatureClass() {
    return TestFeatures.class;
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
public TestFeatureManager(Class<? extends Feature> featureEnum) {
    Validate.notNull(featureEnum, "The featureEnum argument is required");
    Validate.isTrue(featureEnum.isEnum(), "This feature manager currently only works with feature enums");
    this.featureEnum = featureEnum;
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public Set<Feature> getFeatures() {
    return new HashSet<Feature>(Arrays.asList(featureEnum.getEnumConstants()));
}
 

import org.togglz.core.Feature; //导入依赖的package包/类
@Override
public FeatureMetaData getMetaData(Feature feature) {
    return new EnumFeatureMetaData(feature);
}