returns the spring environment properties
@return
160924
public Map<String, String> getEnvProperty() {
		Map<String, String> res = new TreeMap<String, String>();
		MutablePropertySources mps = env.getPropertySources();
        Iterator<PropertySource<?>> iter = mps.iterator();
        while (iter.hasNext()) {
            PropertySource<?> ps = iter.next();
            if (ps instanceof EnumerablePropertySource<?>) {
                for (String propName : ((EnumerablePropertySource<?>) ps).getPropertyNames()) {
                	try {
                		res.put(propName, env.getProperty(propName));
					} catch (Exception e) {
						LOGGER.warn("unresolveable property: " + propName);
						res.put(propName, "UNRESOLVEABLE");
					}
                	
                }
            }
        }
        return res;
	}
914358
public List<EnvironmentType> getAllEnvironmentTypes() throws GreenPepperServerException {
        try {
            sessionService.startSession();

            List<EnvironmentType> envTypes = sutDao.getAllEnvironmentTypes();

            log.debug("Retrieved All Environment Types number: " + envTypes.size());

            return envTypes;
        } catch (Exception ex) {
            throw handleException(ERROR, ex);
        } finally {
            sessionService.closeSession();
        }
    }
997917
public Map getProperties() {
        if (tc.isEntryEnabled())
            SibTr.entry(this, tc, "getProperties");
        if (tc.isEntryEnabled())
            SibTr.exit(this, tc, "getProperties");
        return null;
    }
117396
@Override
    public Properties getProperties() {
        Properties properties = new Properties();
        if (persistenceUnitXml.getProperties() != null && persistenceUnitXml.getProperties().getProperty() != null) {
            for (Persistence.PersistenceUnit.Properties.Property p : persistenceUnitXml.getProperties().getProperty()) {
                properties.put(p.getName(), p.getValue());
            }
        }
        return properties;
    }
480548
private static Properties getWindowsShellVariables()
        throws EnvironmentException
    {
        Properties properties = new Properties();
        // build the command based on the shell used: cmd.exe or command.com
        StringBuffer buffer = new StringBuffer( getWindowsUserShell() );
        buffer.append( " /C SET" );
        String cmdExec = buffer.toString();

        int exitValue = readEnvironment( cmdExec, properties );
        if( 0 != exitValue )
        {
            String message = "Environment process failed with non-zero exit code of " + exitValue;
            throw new EnvironmentException( message );
        }

        return properties;
    }
1179073
public static ApplicationEnvironment get() {
        return INSTANCE.updateAndGet((env) -> {
            if (env != null) {
                return env;
            }

            try (AutoCloseable handle = Performance.time("Load application environment")) {
                return new ApplicationEnvironment();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
990511
public Properties getProperties() {
          Properties rtnProperties = null;

          // Convert this Properties from the class defined in JAXB
          // (com.ibm.ws.jpa.pxml21.Persistence.PersistenceUnit.Properties)
          // to standard JDK classes (java.util.Properties).

          com.ibm.ws.jpa.pxml21.Persistence.PersistenceUnit.Properties puProperties = ivPUnit.getProperties();

          if (puProperties != null) {
               List<com.ibm.ws.jpa.pxml21.Persistence.PersistenceUnit.Properties.Property> propertyList =
                    puProperties.getProperty();
               if (propertyList != null && !propertyList.isEmpty()) {
                    rtnProperties = new Properties();
                    for (com.ibm.ws.jpa.pxml21.Persistence.PersistenceUnit.Properties.Property puProperty : propertyList) {
                         // It is possible that a syntax error will exist in the persistence.xml
                         // where the property or value is null. Neither is acceptable for
                         // a Hashtable and will result in an exception.
                         try {
                              rtnProperties.setProperty(puProperty.getName(), puProperty.getValue());
                         } catch (Throwable ex) {
                              FFDCFilter.processException(ex, CLASS_NAME + ".getProperties", "219", this);
                              Tr.error(tc, "PROPERTY_SYNTAX_ERROR_IN_PERSISTENCE_XML_CWWJP0039E",
                                 ivPUnit.getName(), puProperty.getName(), puProperty.getValue(), ex);
                              String exMsg =
                                   "A severe error occurred while processing the properties "
                                        + "within the persistence.xml of Persistence Unit: " + ivPUnit.getName()
                                        + " (Property = " + puProperty.getName() + ", Value = " + puProperty.getValue()
                                        + ").";
                              throw new RuntimeException(exMsg, ex);
                         }
                    }
               }
          }
          return rtnProperties;
     }
611610
public ArrayList getProperties(){
		ArrayList properties = new ArrayList();
		if (configEntry.properties != null){
			Iterator it = configEntry.properties.values().iterator();
			while (it.hasNext()){
				Property property = new Property((com.ibm.ws.cache.config.Property)it.next());
				properties.add(property);
			}
		}
		return properties;
	}
344506
public Map<String, Object> getProperties() {
        Map<String, Object> result = null;
        if (body != null) {
            Map<String, Object> prop;
            try {
                prop = body.getProperties();
            } catch (IllegalStateException e) {
                // handle when both object and json are null for this body
                return null;
            }
            if (result == null) {
                result = new HashMap<String, Object>();
            }
            result.putAll(prop);
        }
        return result;
    }
1078984
public Map<String, Object> getProperties() {
        Map<String, Object> localProps = myProps;
        if (localProps == null) {
            localProps = new HashMap<String, Object>();
            if (config != null && !config.isEmpty()) {
                for (Map.Entry<String, Object> entry : config.entrySet()) {
                    if (entry.getValue() instanceof String) {
                        localProps.put(entry.getKey(), entry.getValue());
                        continue;
                    }
                    if (entry.getValue() instanceof Boolean) {
                        Boolean boolVal = (Boolean) entry.getValue();
                        localProps.put(entry.getKey(), boolVal.toString());
                        continue;
                    }
                    if (entry.getValue() instanceof Integer) {
                        Integer IntVal = (Integer) entry.getValue();
                        localProps.put(entry.getKey(), IntVal.toString());
                        continue;
                    }
                }
            }
            myProps = localProps;
        }
        return localProps;
    }
442510
@SuppressWarnings("unchecked")
    public Hashtable getEnvironment() {
        Properties env = new Properties();

        env.put(Context.INITIAL_CONTEXT_FACTORY, _contextFactory);
        String url = null;
        if(_providerUrl != null) {
            url =  _providerUrl;
        } else {
            if (_hostname != null) {
                url = "ldap://" + _hostname + "/";
                if (_port != 0) {
                    url += ":" + _port + "/";
                }

                LOG.warn("Using hostname and port.  Use providerUrl instead: " + url);
            }
        }
        env.put(Context.PROVIDER_URL, url);

        if (_authenticationMethod != null) {
            env.put(Context.SECURITY_AUTHENTICATION, _authenticationMethod);
        }

        if (_bindDn != null) {
            env.put(Context.SECURITY_PRINCIPAL, _bindDn);
        }

        if (_bindPassword != null) {
            env.put(Context.SECURITY_CREDENTIALS, _bindPassword);
        }
        env.put("com.sun.jndi.ldap.read.timeout", Long.toString(_timeoutRead));
        env.put("com.sun.jndi.ldap.connect.timeout", Long.toString(_timeoutConnect));

        // Set the SSLContextFactory to implementation that validates cert subject
        if (url != null && url.startsWith("ldaps") && _ldapsVerifyHostname) {
            try {
                URI uri = new URI(url);
                HostnameVerifyingSSLSocketFactory.setTargetHost(uri.getHost());
                env.put("java.naming.ldap.factory.socket",
                        "com.dtolabs.rundeck.jetty.jaas.HostnameVerifyingSSLSocketFactory");
            }
            catch (URISyntaxException e) {
                throw new RuntimeException(e);
            }
        }

        return env;
    }
424562
public Map<String, String> getEnvironmentVariables() {
    final Props props = getJobProps();
    final Map<String, String> envMap = props.getMapByPrefix(ENV_PREFIX);
    return envMap;
  }
915169
private Properties getArtifactProperties() {
        Properties properties = new Properties();
        try (InputStream stream = Main.class.getResourceAsStream("/project.properties")) {
            properties.load(stream);
        } catch (IOException e) {
            logger.error("Failed to get version ", e);
        }
        return properties;
    }
1244570
public static String get() {
		String env = System.getProperty("JOGGER_ENV");
		if (env == null) {
			env = System.getenv("JOGGER_ENV");
		}

		if (env == null) {
			return "dev";
		}

		return env;
	}
69059
public ValueMap getProperties() {
    if (this.properties == null) {
      this.properties = new ValueMapDecorator(new HashMap<String, Object>());
    }
    return this.properties;
  }
1089780
public ServiceCall<Environment> getEnvironment(GetEnvironmentOptions getEnvironmentOptions) {
    Validator.notNull(getEnvironmentOptions, "getEnvironmentOptions cannot be null");
    String[] pathSegments = { "v1/environments" };
    String[] pathParameters = { getEnvironmentOptions.environmentId() };
    RequestBuilder builder = RequestBuilder.get(RequestBuilder.constructHttpUrl(getEndPoint(), pathSegments,
        pathParameters));
    builder.query("version", versionDate);
    Map<String, String> sdkHeaders = SdkCommon.getSdkHeaders("discovery", "v1", "getEnvironment");
    for (Entry<String, String> header : sdkHeaders.entrySet()) {
      builder.header(header.getKey(), header.getValue());
    }
    builder.header("Accept", "application/json");
    return createServiceCall(builder.build(), ResponseConverterUtils.getObject(Environment.class));
  }
1343659
@Override
    @InterfaceAudience.Public
    public Map<String, Object> getProperties() {
        Map<String, Object> properties = revisionInternal.getProperties();
        if (!checkedProperties) {
            if (properties == null) {
                if (loadProperties() == true) {
                    properties = revisionInternal.getProperties();
                }
            }
            checkedProperties = true;
        }
        return properties != null ? Collections.unmodifiableMap(properties) : null;
    }