Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

com.sun.facelets.* (178)com.sun.jdi.* (112)com.sun.jimi.* (7)
com.sun.syndication.* (145)com.sun.xacml.* (163)com.sunwheeltech.examples.* (1)
com.sunwheeltech.sirius.* (9)

Package Samples:

com.sunwheeltech.sirius.filebrowser: Top-level package for javabean components derived from the Sirius GUI toolkit, a lightweight AWT-based widget set designed for Uncle Unc that is not dependent upon swing, although it can interoperate with it.  
com.sun.xacml.finder.impl: The finder package supports all of the pieces of the XACML specification that require custom implementation.  
com.sun.xacml.cond: This is the root package, which contains the PDP class where most people will want to start.  
com.sun.xacml.attr.proxy: Contains many of the classes related to attributes and attribute retrieval.  
com.sun.facelets.tag.jsf: Tags and other objects that define Facelet implementations.  
com.sun.xacml.cond.cluster: Support for Conditions is in this package.  
com.sun.facelets.impl: Public Facelet API.  
com.sun.jimi.core.decoder.ico
com.sunwheeltech.sirius.support
com.sunwheeltech.sirius.objbrowser
com.sunwheeltech.sirius
com.sunwheeltech.examples.boidbox
com.sun.jdi.request
com.sun.jdi.event
com.sun.jdi.connect.spi
com.sun.jdi.connect
com.sun.jdi
com.sun.xacml.attr
com.sun.xacml
com.sun.xacml.combine

Classes:

ResourceFinder: This class is used by the PDP to handle resource scopes other than Immediate. In the case of a scope of Children or Descendants, the PDP needs a list of Resource Ids to evaluate, each of which will get its own Result. Like the PolicyFinder, this is not tied in any way to the rest of the PDP code, and could be provided as a stand-alone resource. This class basically is a coordinator that asks each module in turn if it can handle the given identifier. Evaluation proceeds in order through the given modules, and once a module returns a non-empty response (whether or not it contains any errors or only ...
PolicyFinder: This class is used by the PDP to find all policies used in evaluation. A PDP is given a pre-configured PolicyFinder on construction. The PolicyFinder provides the functionality both to find policies based on a request (ie, retrieve policies and match against the target) and based on an idReference (as can be included in a PolicySet). While this class is typically used by the PDP, it is intentionally designed to support stand-alone use, so it could be the base for a distributed service, or for some application that needs just this functionality. There is nothing in the PolicyFinder Note that it ...
StateWriter: A class for handling state insertion. Content is written directly to "out" until an attempt to write state; at that point, it's redirected into a buffer that can be picked through in theory, this buffer should be very small, since it only needs to be enough to contain all the content after the close of the first (and, hopefully, only) form. Potential optimizations: If we created a new FastWriter at each call to writingState(), and stored a List of them, then we'd know that state tokens could only possibly be near the start of each buffer (and might not be there at all). (There might be a close-element ...
SelectorModule: This module implements the basic behavior of the AttributeSelectorType, looking for attribute values in the physical request document using the given XPath expression. This is implemented as a separate module (instead of being implemented directly in AttributeSelector so that programmers can remove this functionality if they want (it's optional in the spec), so they can replace this code with more efficient, specific code as needed, and so they can easily swap in different XPath libraries. Note that if no matches are found, this module will return an empty bag (unless some error occurred). The ...
XmlReader: Character stream that handles (or at least attemtps to) all the necessary Voodo to figure out the charset encoding of the XML document within the stream. IMPORTANT: This class is not related in any way to the org.xml.sax.XMLReader. This one IS a character stream. All this has to be done without consuming characters from the stream, if not the XML parser will not recognized the document as a valid XML. This is not 100% true, but it's close enough (UTF-8 BOM is not handled by all parsers right now, XmlReader handles it and things work in all parsers). The XmlReader class handles the charset encoding ...
ConfigurationStore: This class supports run-time loading of configuration data. It loads the configurations from an XML file that conforms to the configuration schema. By design this class does not get used automatically, nor does it change the state of the system directly. A programmer must choose to support this mechanism in their program, and then must explicitly use loaded elements. This way, the programmer still has full control over their security model, but also has the convenience of re-using a common configuration mechanism. See http://sunxacml.sourceforge.net/schema/config-0.3.xsd for the valid schema. Note ...
BaseFunctionFactory: This is a basic implementation of FunctionFactory . It implements the insertion and retrieval methods, but it doesn't actually setup the factory with any functions. It also assumes a certain model with regard to the different kinds of functions (Target, Condition, and General). For this reason, you may want to re-use this class, or you may want to extend FunctionFactory directly, if you're writing a new factory implementation. Note that while this class is thread-safe on all creation methods, it is not safe to add support for a new function while creating an instance of a function. This follows ...
StandardFunctionFactory: This factory supports the standard set of functions specified in XACML 1.0 and 1.1. It is the default factory used by the system, and imposes a singleton pattern insuring that there is only ever one instance of this class. Note that because this supports only the standard functions, this factory does not allow the addition of any other functions. If you call addFunction on an instance of this class, an exception will be thrown. If you need a standard factory that is modifiable, you can either create a new BaseFunctionFactory (or some other implementation of FunctionFactory ) populated with the ...
AttributeFinder: This class is used by the PDP to find attribute values that weren't originally supplied in the request. It can be called with the data supplied in AttributeDesignator s or AttributeSelector s. Because the modules in this finder may themselves need attribute data to search for attribute data, it's possible that the modules will look for values in the EvaluationCtx , which may in turn result in the invocation of this finder again, so module writers need to be careful about how they build their modules. Note that unlike the PolicyFinder, this class doesn't always need to use every module it has to ...
StandardCombiningAlgFactory: This factory supports the standard set of algorithms specified in XACML 1.0 and 1.1. It is the default factory used by the system, and imposes a singleton pattern insuring that there is only ever one instance of this class. Note that because this supports only the standard algorithms, this factory does not allow the addition of any other algorithms. If you call addAlgorithm on an instance of this class, an exception will be thrown. If you need a standard factory that is modifiable, you should create a new BaseCombiningAlgFactory (or some other CombiningAlgFactory ) and configure it with the standard ...
StandardAttributeFactory: This factory supports the standard set of datatypes specified in XACML 1.0 and 1.1. It is the default factory used by the system, and imposes a singleton pattern insuring that there is only ever one instance of this class. Note that because this supports only the standard datatypes, this factory does not allow the addition of any other datatypes. If you call addDatatype on an instance of this class, an exception will be thrown. If you need a standard factory that is modifiable, you should create a new BaseAttributeFactory (or some other AttributeFactory ) and configure it with the standard datatypes ...
PolicyReference: This class is used as a placeholder for the PolicyIdReference and PolicySetIdReference fields in a PolicySetType. When a reference is used in a policy set, it is telling the PDP to use an external policy in the current policy. Each time the PDP needs to evaluate that policy reference, it asks the policy finder for the policy. Typically the policy finder will have cached the referenced policy, so this isn't too slow. NOTE: all of the accessor methods, the match method, and the evaluate method require this class to ask its PolicyFinder for the referenced policy, which can be a slow operation. Care ...
EvaluationCtx: Manages the context of a single policy evaluation. Typically, an instance is instantiated whenever the PDP gets a request and needs to perform an evaluation as a result. Note that this class does some optional caching for current date, time, and dateTime values (defined by a boolean flag to the constructors). The XACML specification requires that these values always be available, but it does not specify whether or not they must remain constant over the course of an evaluation if the values are being generated by the PDP (if the values are provided in the Request, then obviously they will remain ...
BoidBox: A simple example application using the Uncle Unc framework to expose the methods and properties of a java application. The application being used here is a bird-flock simulation that I wrote a few years ago. Bird flocking algorithms are a cute technique for creating organic-looking movement in particles, and was commonly used in the days of java applets to make pretty pictures on a web page. Something about our hunter-getherer origins makes them appealing to watch. The bird-flock was not designed with Uncle Unc in mind, and the object browser has been fitted onto it retroactively. This choice was ...
ObjectBean: Convenience class providing clone(), toString(), equals() and hashCode() functionality for Java Beans. It works on all read/write properties, recursively. It uses the CloneableBean, EqualsBean and ToStringBean classes in a delegation pattern. ObjectBean programming conventions All ObjectBean subclasses having properties that return collections they should never return null if the property has been set to null or if a collection has not been set. They should create and return an empty collection, this empty collection instance should also be set to the corresponding property. All ObjectBean subclasses ...
NOfFunction: A class that implements the n-of function. It requires at least one argument. The first argument must be an integer and the rest of the arguments must be booleans. If the number of boolean arguments that evaluate to true is at least the value of the first argument, the function returns true. Otherwise, it returns false (or indeterminate, as described in the next paragraph. This function evaluates the arguments one at a time, starting with the first one. As soon as the result of the function can be determined, evaluation stops and that result is returned. During this process, if any argument evaluates ...
BaseCombiningAlgFactory: This is a basic implementation of CombiningAlgFactory . It implements the insertion and retrieval methods, but doesn't actually setup the factory with any algorithms. Note that while this class is thread-safe on all creation methods, it is not safe to add support for a new algorithm while creating an instance of an algorithm. This follows from the assumption that most people will initialize these factories up-front, and then start processing without ever modifying the factories. If you need these mutual operations to be thread-safe, then you should write a wrapper class that implements the right ...
BaseAttributeFactory: This is a basic implementation of AttributeFactory . It implements the insertion and retrieval methods, but doesn't actually setup the factory with any datatypes. Note that while this class is thread-safe on all creation methods, it is not safe to add support for a new datatype while creating an instance of a value. This follows from the assumption that most people will initialize these factories up-front, and then start processing without ever modifying the factories. If you need these mutual operations to be thread-safe, then you should write a wrapper class that implements the right synchronization ...
PolicyCombiningAlgorithm: The base type for all Policy combining algorithms. Unlike in Rule Combining Algorithms, each policy must be matched before they're evaluated to make sure they apply. Also, in combining policies, obligations must be handled correctly. Specifically, no obligation may be included in the Result that doesn't match the effect being returned. So, if INDETERMINATE or NOT_APPLICABLE is the returned effect, no obligations may be included in the result. If the effect of the combining algorithm is PERMIT or DENY, then obligations with a matching fulfillOn effect are also included in the result.
PropertiesLoader: Properties loader that aggregates a master properties file and several extra properties files, all from the current classpath. The master properties file has to be in a distinct location than the extra properties files. First the master properties file is loaded, then all the extra properties files in their order of appearance in the classpath. Current use cases (plugin manager for parsers/converters/generators for feeds and modules and date formats) assume properties are list of tokens, that why the only method to get property values is the getTokenizedProperty().
CurrentEnvModule: Supports the current date, time, and dateTime values. The XACML specification states that these three values must always be available to a PDP. They may be included in the request, but if they're not, a PDP must be able to recognize the attribute and generate the correct value. The module provides support for this feature by generating real-time values as known at the host where this module is running. This class uses the caching functions of EvaluationCtx to make sure that values are constant within an evaluation, if that is the desired behavior.
FunctionFactory: Factory used to create all functions. There are three kinds of factories: general, condition, and target. These provide functions that can be used anywhere, only in a condition's root and only in a target (respectively). Note that all functions, except for abstract functions, are singletons, so any instance that is added to a factory will be the same one returned from the create methods. This is done because most functions don't have state, so there is no need to have more than one, or to spend the time creating multiple instances that all do the same thing.
SyndCategoryListFacade: List implementation for SyndCategoryImpl elements. To be directly used by the SyndFeedImpl and SyndEntryImpl classes only. It acts as a facade on top of the DCSubjectImpl elements of the underlying list and remains in synch with it. It is possible to work on either list, the categories one or the subjects one and they remain in synch. This is necessary because the SyndFeedImpl categories are just a convenience to access the DublinCore subjects. All this mess to avoid making DCSubjectImpl implement SyndCategory (which it would be odd).
StringAttribute: Representation of an xs:string value. This class supports parsing xs:string values. All objects of this class are immutable and all methods of the class are thread-safe. Note that there is currently some confusion in the XACML specification about whether this datatype should be able to handle XML elements (ie, whether <AttributeValue DataType="...string"><foo/> </AttributeValue> is valid). Until that is clarified the strict definition of the string datatype is used in this code, which means that elements are not valid.
BagAttribute: Represents a bag used in the XACML spec as return values from functions and designators/selectors that provide more than one value. All values in the bag are of the same type, and the bag may be empty. The bag is immutable, although its contents may not be. NOTE: This is the one standard attribute type that can't be created from the factory, since you can't have this in an XML block (it is used only in return values & dynamic inputs). I think this is right, but we may need to add some functionality to let this go into the factory.

Home | Contact Us | Privacy Policy | Terms of Service