Gets a {@code TechSet} with the technologies included, if selected, and excluded if not.

@return a TechSet with the technologies included and excluded
@see TechSet#include(Tech)
@see TechSet#exclude(Tech)
347507
public TechSet getTechSet() {
        TechSet techSet = new TechSet();
        Iterator<Entry<Tech, DefaultMutableTreeNode>> iter = techToNodeMap.entrySet().iterator();
        while (iter.hasNext()) {
            Entry<Tech, DefaultMutableTreeNode> node = iter.next();
            TreePath tp = this.getPath(node.getValue());
            Tech tech = node.getKey();
            if (techTree.isSelectedFully(tp)) {
                techSet.include(tech);
            } else {
                techSet.exclude(tech);
            }
        }
        return techSet;
    }
528594
public static techsupport[] get(nitro_service client) throws Exception
	{
		techsupport resource = new techsupport();
		resource.validate("get");
		return (techsupport[]) resource.get_resources(client);
	}
871323
public com.google.api.ads.admanager.axis.v201902.Technology[] getExcludedMobileDeviceSubmodels() {
        return excludedMobileDeviceSubmodels;
    }
572723
public java.util.List<ConfigurationSet> getConfigurationSets() {
        if (configurationSets == null) {
            configurationSets = new com.amazonaws.internal.SdkInternalList<ConfigurationSet>();
        }
        return configurationSets;
    }
150333
public InvestigationTechnique getInvestigationTechnique() {
    if (GeneRegulationTemplate_Type.featOkTst && ((GeneRegulationTemplate_Type)jcasType).casFeat_investigationTechnique == null)
      jcasType.jcas.throwFeatMissing("investigationTechnique", "de.julielab.jules.types.bootstrep.GeneRegulationTemplate");
    return (InvestigationTechnique)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((GeneRegulationTemplate_Type)jcasType).casFeatCode_investigationTechnique)));}
286384
public List<Include<ExceptionClassFilter<T>>> getAllInclude()
   {
      List<Include<ExceptionClassFilter<T>>> list = new ArrayList<Include<ExceptionClassFilter<T>>>();
      List<Node> nodeList = childNode.get("include");
      for(Node node: nodeList)
      {
         Include<ExceptionClassFilter<T>>  type = new IncludeImpl<ExceptionClassFilter<T>>(this, "include", childNode, node);
         list.add(type);
      }
      return list;
   }
938118
public OptionsBuilder excludes(/* @Nullable */ Collection<String> excludes) {

		if (excludes != null && !excludes.isEmpty()) {
			if (!options.containsKey(Options.EXCLUDES)) {
				options.put(Options.EXCLUDES, new ArrayList<Object>());
			}

			List<Object> allIncludes = (List<Object>) options.get(Options.EXCLUDES);
			allIncludes.addAll(excludes);
		}
		return this;
	}
377846
public List<IfClassAvailable<Exclude<T>>> getAllIfClassAvailable()
   {
      List<IfClassAvailable<Exclude<T>>> list = new ArrayList<IfClassAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-available");
      for(Node node: nodeList)
      {
         IfClassAvailable<Exclude<T>>  type = new IfClassAvailableImpl<Exclude<T>>(this, "if-class-available", childNode, node);
         list.add(type);
      }
      return list;
   }
615517
@Override
    public Set<Class<?>> getComponents() {
        Set<Class<?>> set = new HashSet<>();
        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        Consumer<JsonArray> reader = array -> {
            if (array != null && array.size() > 0) {
                for (int i = 0; i < array.size(); i++) {
                    try {
                        set.add(cl.loadClass(array.getString(i)));
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };

        JsonArray features = config.getJsonArray(CONFIG_FEATURES, null);
        JsonArray components = config.getJsonArray(CONFIG_COMPONENTS, null);

        reader.accept(features);
        reader.accept(components);

        return set;
    }
170883
public void print() {
		System.out.println("TechSet: " + this.hashCode());
		for (Tech tech : includeTech) {
			System.out.println("\tInclude: " + tech);
		}
		for (Tech tech : excludeTech) {
			System.out.println("\tExclude: " + tech);
		}
		
	}
576036
public Set<String> keySet() {

		// Copy key set, so return value is independent from the object's internal data structure
		final Set<String> retVal = new HashSet<String>();

		synchronized (this.confData) {

			final Iterator<String> it = this.confData.keySet().iterator();
			while (it.hasNext()) {
				retVal.add(it.next());
			}
		}

		return retVal;
	}
517336
private Set<String> getTargetTechnologies()
    {
        WindupConfigurationModel wc = grCtx.getUnique(WindupConfigurationModel.class);
        Iterable<TechnologyReferenceModel> targetTechnologies = wc.getTargetTechnologies();
        Set<String> techs = new HashSet<>();
        for (TechnologyReferenceModel tech : targetTechnologies)
        {
            techs.add(tech.getTechnologyID());
        }
        return techs;
    }
1240013
public boolean getTpc() {
    if (PTBConstituent_Type.featOkTst && ((PTBConstituent_Type)jcasType).casFeat_tpc == null)
      jcasType.jcas.throwFeatMissing("tpc", "de.julielab.jules.types.PTBConstituent");
    return jcasType.ll_cas.ll_getBooleanValue(addr, ((PTBConstituent_Type)jcasType).casFeatCode_tpc);}
240756
public Set<String> keySet() {

        PropertyBundle p = this;
        Set<String> keys = new HashSet<>(p.key2values.keySet());

        while ((p = p.parent) != null) {
            keys.addAll(p.key2values.keySet());
        }

        return Collections.unmodifiableSet(keys);

    }
7588
public Set<Map.Entry<String, String>> getSetEntries() {
      Set<Map.Entry<String, String>> entries = optionSet.stream()
                                                        .filter(this::isSet)
                                                        .map(no -> Tuple2.of(no.getName(),
                                                                             Convert.convert(no.getValue(),
                                                                                             String.class)))
                                                        .collect(Collectors.toSet());
      entries.addAll(unamedOptions.entrySet());
      return entries;
   }
538361
private Set<Addon> getAddonsToScan()
    {
        AddonFilter filter = new AddonFilter()
        {
            @Override
            public boolean accept(Addon addon)
            {
                // make sure to include ourselves as well (even though we don't technically depend on ourselves)
                return addonDependsOnReporting(addon) || addon.equals(CssJsResourceRenderingRuleProvider.this.addon);
            }
        };

        return furnace.getAddonRegistry().getAddons(filter);
    }
869485
public String getSet() {
    if (Timex2_Type.featOkTst && ((Timex2_Type)jcasType).casFeat_set == null)
      jcasType.jcas.throwFeatMissing("set", "de.julielab.jules.types.ace.Timex2");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Timex2_Type)jcasType).casFeatCode_set);}