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

Quick Search    Search Deep

edu.berkeley.* (125)edu.emory.* (147)edu.iicm.* (61)edu.mit.* (1209)
edu.ou.* (146)edu.stanford.* (367)edu.ucsb.* (86)

Package Samples:

edu.emory.mathcs.util.natives: Utility classes developed and/or maintained by the Distributed Computing Laboratory , Emory University.  
edu.emory.mathcs.util.classloader: Utility classes developed and/or maintained by the Distributed Computing Laboratory , Emory University.  
edu.emory.mathcs.util.swing: Utility classes developed and/or maintained by the Distributed Computing Laboratory , Emory University.  
edu.emory.mathcs.util.allocator: Utility classes developed and/or maintained by the Distributed Computing Laboratory , Emory University.  
edu.emory.mathcs.util.classloader.jar: Set of classes supporting dynamic class and resource loading and simplifying development of custom class loaders.  
edu.emory.mathcs.util.remote.server.impl: Utilities extending several traditional APIs to work across the network using RMI.  
edu.ucsb.ccs.jcontractor.test: This is the main package of the jContractor system.  
edu.ucsb.ccs.jaqual.standard: This is the main package of the JaQuaL library.  
edu.emory.mathcs.util.io.test: Utility classes related to stream-based I/O.  
edu.emory.mathcs.util.net.inproc: Networking-related utility classes.  
edu.emory.mathcs.util.security.auth: Security-related utilities.  
edu.emory.mathcs.util.security.action: Security-related utilities.  
edu.emory.mathcs.util.security.io: Security-related utilities.  
edu.emory.mathcs.util.remote.io.server: I/O streams over RMI.  
edu.emory.mathcs.util.security.auth.spi.passwd: Experimental.  
edu.stanford.ejalbert
edu.ou.kmi.util
edu.ou.kmi.buddyspace.gui
edu.ou.kmi.buddyspace.xml
edu.ou.kmi.buddyspace.core

Classes:

PooledExecutor: A tunable, extensible thread pool class. The main supported public method is execute(Runnable command) , which can be called instead of directly creating threads to execute commands. Thread pools can be useful for several, usually intertwined reasons: To bound resource use. A limit can be placed on the maximum number of simultaneously executing threads. To manage concurrency levels. A targeted number of threads can be allowed to execute simultaneously. To manage a set of threads performing related tasks. To minimize overhead, by reusing previously constructed Thread objects rather than creating ...
CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes. A CountDownLatch is initialized with a given count . The await 55 methods block until the current count 55 reaches zero due to invocations of the countDown() 55 method, after which all waiting threads are released and any subsequent invocations of await 55 return immediately. This is a one-shot phenomenon -- the count cannot be reset. If you need a version that resets the count, consider using a CyclicBarrier . A CountDownLatch is a versatile synchronization tool and ...
HashIntMap: Hash table based implementation of the IntMap interface. This implementation provides all of the optional map operations, and permixts null values. This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time. This implementation provides constant-time performance for the basic operations ( get and put ), assuming the hash function disperses the elements properly among the buckets. Iteration over collection views requires time proportional to the "capacity" of the HashMap instance (the number of buckets) plus its size ...
ContractCheckTransformation: A transformation to insert a call to the contract method into a non-contract method. The details of inserting the check are left to descendents (whether to insert the check at the beginning or end of the method, for example). This class defines the buildContractCheck(MethodGen, MethodGen, InstructionList, String, String) method, that creates an instruction list that will call a contract method, and throw an exception if the method returns false. The Assertion Evaluation Rule states that when a function is called while evaluating a contract, the contracts of that function should not be evaluated. ...
VolatileHashMap: A hashtable-based Map implementation with weak values . An entry in a VolatileHashMap will automatically be removed when its value is no longer in ordinary use. More precisely, the presence of a mapping to a given value will not prevent the value from being discarded by the garbage collector, that is, made finalizable, finalized, and then reclaimed. When a value has been discarded, all entries referring to it are effectively removed from the map. This class is a companion to java.util.WeakHashMap . Null values and the null key are supported. This class has performance characteristics similar to ...
Queue: A Collection designed for holding elements prior to processing. Besides basic java.util.Collection operations, queues provide additional insertion, extraction, and inspection operations. 0 * Queues typically, but do not necessarily, order elements in a FIFO (first-in-first-out) manner. Among the exceptions are priority queues, which order elements according to a supplied comparator, or the elements' natural ordering. Every Queue implementation must specify its ordering guarantees. The #offer(E) method adds an element if possible, otherwise returning false . This differs from the Collections#add(Object) ...
BlockingQueue: A java.util.Queue that additionally supports operations that wait for elements to exist when retrieving them, and wait for space to exist when putting them. BlockingQueues do not accept null elements. Implementations throw IllegalArgumentException on attempts to add , put or offer a null . A null is used as a sentinel value to indicate failure of poll operations. BlockingQueues may be capacity bounded. At any given time they may have a remainingCapacity beyond which no additional elements can be put without blocking. BlockingQueues without any intrinsic capacity constraints always report a remaining ...
jContractorRuntime: This class is used internally by jContractor, and should never be used by others. This class is used to maintain state information while contracts are checked. In particular, it keeps track of which threads are evaluating contracts so that the assertion evaluation rule can be implemented. It also provides a mechanism for storing cloned objects to check OLD references. One final implementation note: jContractorRuntime is a "magic" class in the jContractor system. Because contract checking code calls the methods of this class, this class cannot have contracts of its own. If it did, then they would ...
BrowserLauncher: BrowserLauncher is a class that provides one static method, openURL, which opens the default web browser for the current user of the system to the given URL. It may support other protocols depending on the system -- mailto, ftp, etc. -- but that has not been rigorously tested and is not guaranteed to work. Yes, this is platform-specific code, and yes, it may rely on classes on certain platforms that are not part of the standard JDK. What we're trying to do, though, is to take something that's frequently desirable but inherently platform-specific -- opening a default browser -- and allow programmers ...
jInstrument: Utility to read in class files and instrument class methods to enforce jContractor contracts. Instrumented class files are written to a destination directory which defaults to the current working directory. The program may be run from the command line by passing the names of files to instrument as arguments, or by invoking the instrumentClassFile(String) method. If specified, the instrumentation file controls the instrumentation level of each class in the system. The available instrumentation levels are: None - No contracts checked. Pre - Preconditions checked. Post - Preconditions and postconditions ...
PropertyUtils: Property and string manipulation and macro expansion utilities. Particularly useful in processing configuration files. Macros enable configuration files to refer to system properties, context-dependent information, etc. Macro expansion routine takes a string and resolves macro occurrences within that string against specified macro templates. Macro references have the following form: $macro_name{parameter}. Upon finding a macro reference, resolver finds macro template for macro_name and uses it to resolve parameter into a value string. For instance, empty macro name is associated by default with ...
ResourceLoader: This class aids in accessing remote resources referred by URLs. The URLs are resolved into resource handles which can be used to access the resources directly and uniformly, regardless of the URL type. The resource loader is particularly useful when dealing with resources fetched from JAR files. It maintains the cache of opened JAR files (so that so that subsequent requests for resources coming from the same base Jar file can be handled efficiently). It fully supports JAR class-path (references from a JAR file to other JAR files) and JAR index (JAR containing information about content of other ...
Executor: An object that executes submitted tasks. This interface provides a way of decoupling task submission from the mechanics of how each task will be run, including details of thread use, scheduling, etc. In the simplest case, an executor can run the submitted task immediately in the caller's thread: class DirectExecutor implements Executor { public void execute(Runnable r) { r.run(); } } However, tasks are typically executed in a different thread than the caller's thread. The executor below spawns a new thread for each task. class ThreadPerTaskExecutor implements Executor { public void execute(Runnable ...
jInstrumentTask: Ant task definition for jInstrument. Parameters: Attribute Description Required --------- ----------- -------- none A package that is not to be no instrumented. (Nested element.) pre A package to be instrumented with no precondition checks. (Nested element.) post A package to be instrumented with no pre and postcondition checks. (Nested element.) all A package to be instrumented with no all checks (pre, post, invariant). (Nested element.) srcdir A directory containing Java class yes files to instrument. All classes in this directory and all subdirectories will be processed. destdir The directory ...
jContractor: Main entry point into the jContractor system. This class can be run stand alone to run another program with contract checking enabled. jContractor will substitute its own class loader for the default class loader, and modify the bytecode of loaded classes to enforce contracts at runtime. The runInstrumented(String, String []) method may be used to programatically run a class with contracts enabled. If specified, the instrumentation file controls the instrumentation level of each class in the system. The available instrumentation levels are: None - No contracts checked. Pre - Preconditions checked. ...
PriorityQueue: An unbounded priority queue based on a priority heap. This queue orders elements according to an order specified at construction time, which is specified in the same manner as java.util.TreeSet and java.util.TreeMap : elements are ordered either according to their natural order (see java.lang.Comparable ), or according to a java.util.Comparator , depending on which constructor is used. The peek() 55 , poll() 55 , and remove(java.lang.Object) 55 methods return the minimal element with respect to the specified ordering. If multiple elements are tied for least value, no guarantees are made as to which ...
jContractorTask: Ant task definition for jContractor. This task accepts all the options that the Java task does. (Note, however, that jContractor has never been tested with a Jar, and probably wouldn't work in this case.) Parameters: Attribute Description Required --------- ----------- -------- none A package that is not to be no instrumented. (Nested element.) pre A package to be instrumented with no precondition checks. (Nested element.) post A package to be instrumented with no pre and postcondition checks. (Nested element.) all A package to be instrumented with no all checks (pre, post, invariant). (Nested ...
ThreadContext: Represents an immutable snapshot of a thread state. The state consists of delegatable thread locals, context class loader, and a priority. After the snapshot has been taken, it is later possible to execute tasks within that previously stored context using one of perform 55 methods. The thread executing the task need not be the same as the one for which the snapshot was originally taken; i.e. the state can be recovered (for the duration of the task) in any thread invoking "perform". This class is particularly useful in developing thread pools and asynchronous invocation frameworks, where it is common ...
TimeUnit: A TimeUnit represents time durations at a given unit of granularity and provides utility methods to convert across units, and to perform timing and delay operations in these units. TimeUnit is a "featherweight" class. It does not maintain time information, but only helps organize and use time representations that may be maintained separately across various contexts. The TimeUnit class cannot be directly instantiated. Use the SECONDS 55 , MILLISECONDS 55 , MICROSECONDS 55 , and NANOSECONDS 55 static instances that provide predefined units of precision. If you use these frequently, consider ...
AgentImpl: Base class for Hive agent implementations. An agent has a life cycle. Once in its lifetime, the agent is constructed by the no argument constructor. The agent arrives on a server; its doLocalSetup() method is called. This happens whenever it first comes to a server, whether created by Cell.createNewAgent(Class) or when it moves to the server. The agent's doBehavior() method is called. This method is the agent's main loop, where it's behavior is implemented. The agent is free to do what it wants, but should respect timeToStop . The agent sould never exit this method, a convienience method waitUntilDeath ...
URIClassLoader: Equivalent of java.net.URLClassloader but without bugs related to ill-formed URLs and with customizable JAR caching policy. The standard URLClassLoader accepts URLs containing spaces and other characters which are forbidden in the URI syntax, according to the RFC 2396. As a workaround to this problem, Java escapes and un-escapes URLs in various arbitrary places; however, this is inconsistent and leads to numerous problems with URLs referring to local files with spaces in the path. SUN acknowledges the problem, see but refuses to modify the behavior for compatibility reasons; see Java Bug Parade ...
PlainThreadFactory: Thread factory implementation that attempts to ensure that created threads are equivalent regardless of threads that request creation. Precisely, created threads belong to the same thread group, and they inherit a "parent thread context" (access control context, DelegatableThreadLocal s, etc.) from the factory creator rather than from the invoker of newThread(java.lang.Runnable) 55 . This thread factory is used as a default for PooledExecutor , as it guarantees deterministic behavior and minimal security properties. Nevertheless, stronger semantics are often neccessary in security-sensitive applications. ...
ConnectionPool: Manages a pool of socket connections to a single network endpoint. Pooling enables reusing connections for multiple, unrelated data transfers, and it can be used to implement certain connection-based protocols like HTTP 1.1. Additionally, pooling can aid in controlling network load - limiting the maximum pool size causes excessive connection requests to be enqueued at the client side. The endpoint is represented by a host name and a port number, as well as by an optional client socket factory, specified at the construction time. Client requests connections, use them, then return them to the pool. ...
CellAddress: This immutable class represents the URL of a Hive Cell. The protocol portion of the url is defined to be "hive", and will not allow the construction of urls with a different protocol. CellAddress follows the CISS (Common Internet Scheme Standard) Spec, although currently the file and ref portions of the URL are not used by the Hive system. WARNING: Java deviates from it's spec (at least on windows) in the DNS lookup behavior. Doing a InetAdderss.getByName(host).getHostName() does NOT return the fully qualified hostname as it should. Rather, some wierd caching behavior is causing the original argument ...
PreconditionMethodTransformation: A transformation to prepare precondition methods. For each non-contract method in a class, the transformation searches for a precondition method. The precondition method is modified to call the superclass precondition method before evaluation, and inlined versions of preconditions inherited from interfaces, and the external precondition defined in a contract class are added. The superclass precondition is logical or-ed with the interface conditions, and the subclass precondition. The subclass precondition is constructed by and-ing the in-class precondition with the external precondition. If no ...

Home | Contact Us | Privacy Policy | Terms of Service