-
CLIPSJNI.Environment
-
aima.core.agent.Environment
An abstract description of possible discrete Environments in which Agent(s) can perceive and act.
@author Ravi Mohan
@author Ciaran O'Reilly
@author Mike Stampone
-
br.com.caelum.vraptor.environment.Environment
An environment has a set of key/value properties to be used within your application
@author Alexandre Atoji
@author Guilherme Silveira
-
caltrop.interpreter.environment.Environment
-
cc.sketchchair.environments.Environment
Environments are 2d textures loaded from png's that can be places of a sketchPlane for reference.
@author gregsaul
-
ch.entities.javainstaller.ConfigReader.Environment
-
ch.entwine.weblounge.common.site.Environment
-
com.adaptrex.tools.environment.Environment
-
com.alphacsp.cit.Environment
@author Yoav Hakman
-
com.badlogic.gdx.graphics.g3d.Environment
-
com.cloudbees.clickstack.domain.environment.Environment
p-docs.cloudbees.com/plugins.html#setup-environment-variables"> genapp documentation / plugins / Setup Environment Variables
@author
Cyrille Le Clerc
-
com.dotcms.publisher.environment.bean.Environment
-
com.elega9t.commons.shell.Environment
-
com.google.appengine.tck.env.Environment
-
com.google.apphosting.api.ApiProxy.Environment
-
com.google.caliper.Environment
A description of an environment in which benchmarks are run. WARNING: a JSON representation of this class is stored on the app engine server. If any changes are made to this class, a deserialization adapter must be written for this class to ensure backwards compatibility.
Gwt-safe
-
com.google.checkout.sdk.commands.Environment
An implementation of EnvironmentInterface that builds itself from format strings. Use the constants {@link #PRODUCTION} and {@link #SANDBOX} for theappropriate environments. Since merchant ID and merchant key values are different in these environments, it's a good idea to reference this class only when you are creating an {@link ApiContext}, since then you can ensure that all three (id, key, and environment) match.
-
com.griddynamics.genesis.tools.environments.Environment
-
com.jigen.ant.Environment
-
com.jigen.xsd.Environment
-
com.mcorrigal.matchingEngine.given.Environment
-
com.melitronic.domain.entity.Environment
Entity implementation class for Entity: Environment
-
com.neemsoft.jmep.Environment
-
com.redhat.ceylon.tools.new_.Environment
-
com.sleepycat.db.Environment
an environment handle with default attributes. Environment env = new Environment(home, new EnvironmentConfig());
or
Environment env = new Environment(home, null);
Note that many Environment objects may access a single environment.
To create an environment or customize attributes, the application should customize the configuration class. For example:
EnvironmentConfig envConfig = new EnvironmentConfig(); envConfig.setTransactional(true); envConfig.setAllowCreate(true); envConfig.setCacheSize(1000000); Environment newlyCreatedEnv = new Environment(home, envConfig);
Environment handles are free-threaded unless {@link com.sleepycat.db.EnvironmentConfig#setThreaded EnvironmentConfig.setThreaded} is called to disable this before the environment is opened.
An environment handle is an Environment instance. More than one Environment instance may be created for the same physical directory, which is the same as saying that more than one Environment handle may be open at one time for a given environment.
The Environment handle should not be closed while any other handle remains open that is using it as a reference (for example, {@link com.sleepycat.db.Database Database} or {@link com.sleepycat.db.Transaction Transaction}. Once {@link com.sleepycat.db.Environment#close Environment.close}is called, this object may not be accessed again, regardless of whether or not it throws an exception.
-
com.sleepycat.je.Environment
an environment handle with default attributes. Environment env = new Environment(home, new EnvironmentConfig()); or
Environment env = new Environment(home, null);
Note that many Environment objects may access a single environment.
To create an environment or customize attributes, the application should customize the configuration class. For example:
EnvironmentConfig envConfig = new EnvironmentConfig(); envConfig.setTransactional(true); envConfig.setAllowCreate(true); envConfig.setCacheSize(1000000); Environment newlyCreatedEnv = new Environment(home, envConfig);
Note that environment configuration parameters can also be set through the <environment home>/je.properties file. This file takes precedence over any programmatically specified configuration parameters so that configuration changes can be made without recompiling. Environment configuration follows this order of precedence:
- Configuration parameters specified in <environment home>/je.properties take first precedence.
- Configuration parameters set in the EnvironmentConfig object used at Environment construction are next.
- Any configuration parameters not set by the application are set to system defaults, described along with the parameter name String constants in the EnvironmentConfig class.
An environment handle is an Environment instance. More than one Environment instance may be created for the same physical directory, which is the same as saying that more than one Environment handle may be open at one time for a given environment.
The Environment handle should not be closed while any other handle remains open that is using it as a reference (for example, {@link com.sleepycat.je.Database Database} or {@link com.sleepycat.je.Transaction Transaction}. Once {@link com.sleepycat.je.Environment#close Environment.close} is called, this object may not be accessed again.
-
com.sun.enterprise.admin.cli.Environment
The environment variables for CLI commands. An instance of this class is passed to each command to give it access to environment variables. Command implementations should access environment information from this class rather than using System.getenv. In multimode, the export command may change environment variables in the instance of this class that is shared by all commands.
@author Bill Shannon
-
com.tacitknowledge.flip.Environment
This class represents a place holder for all of the environment related information that is required by the Flip system, such as {@link Properties}, a list of {@link PropertyReader}s and context providers.
@author Serghei Soloviov
@author Petric Coroli
-
com.yammer.dropwizard.config.Environment
-
de.hunsicker.jalopy.storage.Environment
-
de.matrixweb.smaller.config.Environment
-
de.tuhrig.thofu.Environment
The implementation of the environment. The environment holds all operations, lambdas and variables in a single list. The list contains a key and a corresponding value. An environment can have a parent environment.
@author Thomas Uhrig (tuhrig.de)
-
eu.stratosphere.nephele.execution.Environment
The user code of every Nephele task runs inside an Environment
object. The environment provides important services to the task. It keeps track of setting up the communication channels and provides access to input splits, memory manager, etc.
-
fr.obeo.releng.targetplatform.Environment
A representation of the model object '
Environment'.
The following features are supported:
- {@link fr.obeo.releng.targetplatform.Environment#getEnv Env}
- {@link fr.obeo.releng.targetplatform.Environment#getOperatingSystem Operating System}
- {@link fr.obeo.releng.targetplatform.Environment#getWindowingSystem Windowing System}
- {@link fr.obeo.releng.targetplatform.Environment#getArchitecture Architecture}
- {@link fr.obeo.releng.targetplatform.Environment#getLocalization Localization}
- {@link fr.obeo.releng.targetplatform.Environment#getExecutionEnvironment Execution Environment}
@see fr.obeo.releng.targetplatform.TargetPlatformPackage#getEnvironment()
@model
@generated
-
fr.utbm.gi.vi51.framework.environment.Environment
Situated environment.
@author Stéphane GALLAND <stephane.galland@utbm.fr>
@version $Name$ $Revision$ $Date$
-
freemarker.core.Environment
Object that represents the runtime environment during template processing. For every invocation of a
Template.process() method, a new instance of this object is created, and then discarded when
process() returns. This object stores the set of temporary variables created by the template, the value of settings set by the template, the reference to the data model root, etc. Everything that is needed to fulfill the template processing job.
Data models that need to access the Environment object that represents the template processing on the current thread can use the {@link #getCurrentEnvironment()} method.
If you need to modify or read this object before or after the process call, use {@link Template#createProcessingEnvironment(Object rootMap,Writer out,ObjectWrapper wrapper)}
@author Jonathan Revusky
@author Attila Szegedi
-
fysix.engine.Environment
@author xnvmakl
-
gov.nysenate.openleg.Environment
-
grails.util.Environment
-
hudson.model.Environment
Represents some resources that are set up for the duration of a build to be torn down when the build is over.
This is often used to run a parallel server necessary during a build, such as an application server, a database reserved for the build, X server for performing UI tests, etc.
By having a plugin that does this, instead of asking each build script to do this, we can simplify the build script. {@link Environment} abstraction also givesyou guaranteed "tear down" phase, so that such resource won't keep running forever.
@since 1.286
@see BuildWrapper
@see NodeProperty
@see RunListener#setUpEnvironment(AbstractBuild,Launcher,BuildListener)
-
io.dropwizard.setup.Environment
A Dropwizard application's environment.
-
ise.mace.environment.Environment
The primary environment code for the games that we define. This will contain a list of all the groups, food etc. etc. that exist in the world.
-
it.freedomotic.model.environment.Environment
@author enrico
-
kiss.lang.Environment
This is the immutable environment used by the Kiss compiler Design intent: - Behaves like an immutable map of Symbols -> Values - Maintains a dependency graph for recompilation - Maintains a "result" value, so it can include an expression return value It is a first class object, but probably shouldn't be messed with outside of the kiss.core functions.
@author Mike
-
model.Environment
@author Xuyuan
-
net.celisdelafuente.java.Acacia.util.Environment
-
net.csdn.common.env.Environment
BlogInfo: william Date: 11-9-1 Time: 下午3:51
-
net.hasor.core.Environment
环境支持
@version : 2013-6-19
@author 赵永春 (zyc@hasor.net)
-
net.myexperiments.viciouscycle.view.Environment
-
oracle.adf.share.Environment
-
org.apache.cocoon.environment.Environment
Base interface for an environment abstraction
@author
Giacomo Pati
@author
Carsten Ziegeler
@version CVS $Id: Environment.java,v 1.1 2003/03/09 00:09:28 pier Exp $
-
org.apache.flink.runtime.execution.Environment
The user code of every Nephele task runs inside an Environment
object. The environment provides important services to the task. It keeps track of setting up the communication channels and provides access to input splits, memory manager, etc.
-
org.apache.geronimo.gshell.shell.Environment
-
org.apache.geronimo.jee.deployment.Environment
3.org/2001/XMLSchema}anyType"> <sequence> <element name="moduleId" type="{http://geronimo.apache.org/xml/ns/deployment-1.2}artifactType" minOccurs="0"/> <element name="dependencies" type="{http://geronimo.apache.org/xml/ns/deployment-1.2}dependenciesType" minOccurs="0"/> <element name="hidden-classes" type="{http://geronimo.apache.org/xml/ns/deployment-1.2}classFilterType" minOccurs="0"/> <element name="non-overridable-classes" type="{http://geronimo.apache.org/xml/ns/deployment-1.2}classFilterType" minOccurs="0"/> <element name="inverse-classloading" type="{http://geronimo.apache.org/xml/ns/deployment-1.2}emptyType" minOccurs="0"/> <element name="suppress-default-environment" type="{http://geronimo.apache.org/xml/ns/deployment-1.2}emptyType" minOccurs="0"/> </sequence> </restriction> </complexContent> </complexType>
@version $Rev: 642503 $ $Date: 2008-03-29 12:35:01 +0800 (Sat, 29 Mar 2008) $
-
org.apache.geronimo.kernel.repository.Environment
holds the data from the EnvironmentType xml while it is being resolved, transitively closed, etc.
@version $Rev: 409817 $ $Date: 2006-05-27 09:56:38 +0200 (Sat, 27 May 2006) $
-
org.apache.hadoop.streaming.Environment
This is a class used to get the current environment on the host machines running the map/reduce. This class assumes that setting the environment in streaming is allowed on windows/ix/linuz/freebsd/sunos/solaris/hp-ux
@author michel
-
org.apache.ibatis.mapping.Environment
-
org.apache.muse.core.Environment
Environment defines features related to the underlying platform and the endpoint's configuration in a generic way. It allows resources to ask for data or task completion that depends on a platform-specific API without introducing platform-specific API usage into implementation code.
@author Dan Jemiolo (danj)
-
org.apache.poi.hslf.record.Environment
Environment, which contains lots of settings for the document.
@author Nick Burch
-
org.apache.shiro.env.Environment
An {@code Environment} instance encapsulates all of the objects that Shiro requires to function. It is essentiallya 'meta' object from which all Shiro components can be obtained for an application.
An {@code Environment} instance is usually created as a result of parsing a Shiro configuration file. Theenvironment instance can be stored in any place the application deems necessary, and from it, can retrieve any of Shiro's components that might be necessary in implementing security behavior.
For example, the most obvious component accessible via an {@code Environment} instance is the application's{@link #getSecurityManager() securityManager}.
@since 1.2
-
org.apache.sshd.server.Environment
Interface providing access to the environment map and allowing the registration of listeners for certain signals.
@see org.apache.sshd.server.Signal
-
org.apache.tapestry.services.Environment
Provides access to environment services, which are almost always provided to enclosed components by enclosing components.
The Environment acts like a collection of stacks. Each stack contains environmental service providers of a given type.
-
org.apache.tapestry5.services.Environment
Provides access to environment objects, which are almost always provided to enclosed components by enclosing components. Environmental services are a form of very late binding.
The Environment acts like a collection of stacks. Each stack contains environmental objects of a given type. Most often, a stack has zero or one elements, but on occasion, a particular component will push an override onto the stack for the benefit of the components it encloses.
@see org.apache.tapestry5.annotations.Environmental
@see org.apache.tapestry5.services.EnvironmentalShadowBuilder
-
org.apache.tools.ant.types.Environment
-
org.apache.ws.util.jndi.tools.Environment
LOG-DONE DOCUMENT_ME
@author $author$
@version $Revision: 1.4 $
-
org.araneaframework.Environment
A special data structure providing encapsulation of data needed by different components. Every Aranea component has an environment. The environment can be inhereted from the parent or be standalone. No component knows from which component the Environment comes from.
Component does know about the hooks in the environment. As different contexts are added to the environment the component in need of them is reponsible of checking them and acting upon them.
@author "Toomas Römer"
@author Jevgeni Kabanov (ekabanov@webmedia.ee)
-
org.bukkit.World.Environment
-
org.candlepin.model.Environment
Represents an environment within an owner/organization. Environments are tracked primarily so we can enable/disable/promote content in specific places. Not all deployments of Candlepin will make use of this table, it will at times be completely empty.
-
org.constretto.spring.annotation.Environment
-
org.drools.runtime.Environment
-
org.elasticsearch.env.Environment
The environment of where things exists.
@author kimchy (shay.banon)
-
org.fakereplace.api.environment.Environment
@author Stuart Douglas
-
org.focusns.model.env.Environment
-
org.formulacompiler.runtime.internal.Environment
-
org.graphstream.util.Environment
Representation of a set of parameters.
The environment class mimics the environment variables available in any shell using a hash map of keys/values, the key being the variables names, excepted here they are called parameters.
In addition, this class provides facilities to:
- Read a parameter file and set the parameters from this file;
- Write a parameter file from the parameter of this environment;
- Parse the command line and get parameters from it;
- Take a class as argument and set all its fields having the same name as parameters in this class;
As in any shell, most of the time, the environment is global and accessible from any part of the system. Here a singleton instance of this class is created and accessible from anywhere in the JVM using the {@link #getGlobalEnvironment()} method (indeed the singleton instance iscreated at its first access). However, it is still possible to create a private instance of this class for use in a specific part of a program.
To read a file of parameters, simply call the {@link #readParameterFile(String)} method. In the same way, to write a set ofparameters to a file, call the {@link #writeParameterFile(String)} method.The format of the parameter file is given in the description of these methods.
To read parameters from he command line, call the {@link #readCommandLine(String[])} or{@link #readCommandLine(String[],Collection)} methods. These methods expecta format for the command line that is described in there respective documentations.
It is also possible to setup automatically the fields of an arbitrary object, provided these fields have name that match parameters in this environment. To do this call the {@link #initializeFieldsOf(Object)} method passing theobject to initialise as argument. The object to setup must provide methods of the form "setThing(Type)" where "Thing" or "thing" is the name of the field to set and "Type" is one of "int", "long", "float", "double", "String" and "boolean". For the boolean type, the accepted values meaning true are "true", "on", "1", and "yes", all other value are considered as false.
TODO: how (or when) does the default configuration file is read? TODO: how to handle parameters that cannot be setup in the {@link #initializeFieldsOf(Object)}?
@author Frédéric Guinand
@author Yoann Pigné
@author Antoine Dutot
@version 1.0 (jdk 1.5)
-
org.jab.docsearch.Environment
This class contains all variables for a running session.
The class is an Singlton.
@version $Id: Environment.java 43 2005-10-25 19:56:12Z henschel $
-
org.jboss.gravia.provision.Environment
The Provision environment
@author thomas.diesler@jboss.com
@since 06-May-2013
-
org.jboss.gravia.resolver.Environment
The Provision environment
@author thomas.diesler@jboss.com
@since 06-May-2013
-
org.jboss.metadata.javaee.spec.Environment
-
org.jbpm.env.Environment
maintains contextual information for a thread in a set of {@link Context}s.
Introduction
Objects have different lifecycles and different context's (aka scopes). An environment provides the structure to easily manage objects with different contexts.
Examples of contexts are:
- application: The application context is used to store e.g. data sources, session factories and other static resources needed by an application. The application context lives for the complete duration of the {@link EnvironmentFactory}. So if the {@link EnvironmentFactory} is maintained in a static member field, the application context lives for the duration of the application. The same application context is shared for all the Environments produced by one EnvironmentFactory.
- block: The block context is used for e.g. a transaction and transactional resources, user authentication. In combination with a {@link WireContext}, this results in an efficient and configurable use of transactional resources that need to be lazily initialized.
- The environment can accomodate other contexts as well. They can be added and removed dynamically. Examples of other potential contexts are web-request, web-session, web-application, business processDefinition, job, ...
An environment is typically installed like this
static EnvironmentFactory environmentFactory = new DefaultEnvironmentFactory(); ... Environment environment = environmentFactory.openEnvironment(); try { ... everything available in this block ... } finally { environment.close(); }
Purpose
The first purpose of the environment is to separate the application from the environment. Standard Java and Enterprise Java are quite different and an environment abstraction like this allows for the development of applications that can run in both Standard and Enterprise environments. Also test environments are easier to tweak this way.
A second purpose of the environment is to enable specific to global searching of resources. E.g. you could search for an 'adminEmailAddress' in the contexts 'processDefinition-execution', 'processDefinition-definition' and 'application' in the given order. That way, a global adminEmailAddress can be specified in the application context and it can be refined in more specific contexts processDefinition-definition or processDefinition-execution.
Search order
To find an object in the environment, a searchOrder can be specified. A search order is an sequence that specifies the order in which the contexts should be searched.
The default search order is the inverse sequence of how the contexts are added to the environment. This is because in general, we can assume that the more recent a context was added, the more specific it is.
Transaction, username and classloader
Three objects are used so frequently in an environment that they get special treatment:
- Transaction: an abstraction for marking a transaction with setRollbackOnly.
- Classloader: the current class loader.
- Username: the name of the currently authenticated user.
For these special properties, setters are also available. That is to support programmatic injection into the environment. Alternatively, they can be configured in one of the contexts.
@see EnvironmentFactory
@author Tom Baeyens
-
org.jbpm.pvm.internal.env.Environment
maintains contextual information for a thread in a set of {@link Context}s.
Introduction
Objects have different lifecycles and different context's (aka scopes). An environment provides the structure to easily manage objects with different contexts.
Examples of contexts are:
- process-engine: The process-engine context is used to store e.g. data sources, session factories and other static resources needed by an application. The process-engine context lives for the complete duration of the {@link EnvironmentFactory}. So if the {@link EnvironmentFactory} is maintained in a static member field, the process-engine context lives for the duration of the application. The same process-engine context is shared for all the Environments produced by one EnvironmentFactory.
- environment: The environment context is used for e.g. a transaction and transactional resources, user authentication. This results in an efficient and configurable use of transactional resources that need to be lazily initialized.
- The environment can accomodate other contexts as well. They can be added and removed dynamically. Examples of other potential contexts are web-request, web-session, web-application, business processDefinition, jobImpl, ...
An environment is typically installed like this
static EnvironmentFactory environmentFactory = new DefaultEnvironmentFactory(); ... Environment environment = environmentFactory.openEnvironment(); try { ... everything available in this block ... } finally { environment.close(); }
Purpose
The first purpose of the environment is to separate the application from the environment. Standard Java and Enterprise Java are quite different and an environment abstraction like this allows for the development of applications that can run in both Standard and Enterprise environments. Also test environments are easier to tweak this way.
A second purpose of the environment is to enable specific to global searching of resources. E.g. you could search for an 'adminEmailAddress' in the contexts 'execution', 'transaction' and 'process-engine' in the given order. That way, a global adminEmailAddress can be specified in the process-engine context and it can be refined in more specific contexts.
Search order
To find an object in the environment, a searchOrder can be specified. A search order is an sequence that specifies the order in which the contexts should be searched.
The default search order is the inverse sequence of how the contexts are added to the environment. This is because in general, we can assume that the more recent a context was added, the more specific it is.
Transaction, username and classloader
Three objects are used so frequently in an environment that they get special treatment:
- Transaction: an abstraction for marking a transaction with setRollbackOnly.
- Classloader: the current class loader.
- Username: the name of the currently authenticated user.
For these special properties, setters are also available. That is to support programmatic injection into the environment. Alternatively, they can be configured in one of the contexts.
@see EnvironmentFactory
@author Tom Baeyens
-
org.jclouds.chef.domain.Environment
An environment.
@author Ignasi Barrera
-
org.jemmy.env.Environment
@author shura, mrkam
-
org.kie.api.runtime.Environment
-
org.kie.runtime.Environment
-
org.lilian.experiment.Environment
-
org.mozilla.javascript.tools.shell.Environment
Environment, intended to be instantiated at global scope, provides a natural way to access System properties from JavaScript.
-
org.openstreetmap.josm.gui.mappaint.Environment
Environment is a data object to provide access to various "global" parameters. It is used during processing of MapCSS rules and for the generation of style elements.
-
org.opentripplanner.visibility.Environment
\brief environment represented by simple polygonal outer boundary with simple polygonal holes \remarks For methods to work correctly, the outer boundary vertices must be listed ccw and the hole vertices cw
-
org.pdfsam.guiclient.business.Environment
Environment logic
@author Andrea Vacondio
-
org.pdtextensions.core.launch.environment.Environment
Interface for the Environment in which a php script should be executed.
-
org.rascalmpl.interpreter.env.Environment
A simple environment for variables and functions and types. TODO: this class does not support shadowing of variables and functions yet, which is wrong.
-
org.renjin.sexp.Environment
The Environment data type.
Environments can be thought of as consisting of two things:
- A frame, consisting of a set of symbol-value pairs, and
- an enclosure, a pointer to an enclosing environment.
When R looks up the vbalue for a symbol the frame is examined and if a matching symbol is found its value will be returned. If not, the enclosing environment is then accessed and the process repeated. Environments form a tree structure in which the enclosures play the role of parents. The tree of environments is rooted in an empty environment, available through emptyenv(), which has no parent. It is the direct parent of the environment of the base package (available through the baseenv() function). Formerly baseenv() had the special value {@code NULL}, but as from version 2.4.0, the use of {@code NULL} as an environment is defunct.
-
org.springframework.core.env.Environment
Interface representing the environment in which the current application is running. Models two key aspects of the application environment:
profiles and
properties. Methods related to property access are exposed via the {@link PropertyResolver} superinterface.
A profile is a named, logical group of bean definitions to be registered with the container only if the given profile is active. Beans may be assigned to a profile whether defined in XML or via annotations; see the spring-beans 3.1 schema or the {@link org.springframework.context.annotation.Profile @Profile} annotation forsyntax details. The role of the {@code Environment} object with relation to profiles isin determining which profiles (if any) are currently {@linkplain #getActiveProfiles active}, and which profiles (if any) should be {@linkplain #getDefaultProfiles activeby default}.
Properties play an important role in almost all applications, and may originate from a variety of sources: properties files, JVM system properties, system environment variables, JNDI, servlet context parameters, ad-hoc Properties objects, Maps, and so on. The role of the environment object with relation to properties is to provide the user with a convenient service interface for configuring property sources and resolving properties from them.
Beans managed within an {@code ApplicationContext} may register to be {@link org.springframework.context.EnvironmentAware EnvironmentAware} or {@code @Inject} the{@code Environment} in order to query profile state or resolve properties directly.
In most cases, however, application-level beans should not need to interact with the {@code Environment} directly but instead may have to have ${...}
propertyvalues replaced by a property placeholder configurer such as {@link org.springframework.context.support.PropertySourcesPlaceholderConfigurer PropertySourcesPlaceholderConfigurer}, which itself is {@code EnvironmentAware} andas of Spring 3.1 is registered by default when using {@code }.
Configuration of the environment object must be done through the {@code ConfigurableEnvironment} interface, returned from all{@code AbstractApplicationContext} subclass {@code getEnvironment()} methods. See{@link ConfigurableEnvironment} Javadoc for usage examples demonstrating manipulationof property sources prior to application context {@code refresh()}.
@author Chris Beams
@since 3.1
@see PropertyResolver
@see EnvironmentCapable
@see ConfigurableEnvironment
@see AbstractEnvironment
@see StandardEnvironment
@see org.springframework.context.EnvironmentAware
@see org.springframework.context.ConfigurableApplicationContext#getEnvironment
@see org.springframework.context.ConfigurableApplicationContext#setEnvironment
@see org.springframework.context.support.AbstractApplicationContext#createEnvironment
-
org.sugarj.common.Environment
Shared execution environment.
@author Sebastian Erdweg
-
org.wsI.testing.x2003.x03.log.Environment
as.xmlsoap.org/ws/2003/03/addressing) element. This is a complex type.
-
org.zkybase.model.Environment
Environment entity.
@author Willie Wheeler (willie.wheeler@gmail.com)
-
reactor.core.Environment
@author Jon Brisbin
@author Stephane Maldini
@author Andy Wilkinson
-
rice.environment.Environment
-
ru.yandex.qatools.commons.model.Environment
-
smilehouse.opensyncro.system.Environment
Environment.java Created: Fri Feb 6 10:49:50 2004
-
tree.utils.Environment
List of declarations valid in the current scope with extended functionality to easier work with extending environment or restoring it's old state.
@author Savenko Maria
-
weblogic.jndi.Environment
-
weka.core.Environment
This class encapsulates a map of all environment and java system properties. There are methods for adding and removing variables as well as a method for replacing key names (enclosed by ${}) with their associated value in Strings.
@author Mark Hall (mhall{[at]}pentaho{[dot]}com)
@version $Revision: 5562 $
-
winterwell.utils.Environment
Store global (default) and background (thread-local) properties. A background property being one that would be clumsy to pass round as a method argument.
Environment also provides support for creating stacks of properties via {@link #push(Key,Object)} and {@link #pop(Key)}.
@author daniel
-
wyvern.tools.types.Environment