|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface PersistenceManager
PersistenceManager
is the primary interface for JDO-aware
application components. It is the factory for Query
and
Transaction
instances, and contains methods to manage the
life cycle of PersistenceCapable
instances.
A PersistenceManager
is obtained from the
PersistenceManagerFactory
(recommended) or by construction.
| Method Summary | ||
|---|---|---|
void |
addInstanceLifecycleListener(InstanceLifecycleListener listener,
java.lang.Class... classes)
Adds the listener instance to the list of lifecycle event listeners. |
|
void |
checkConsistency()
Validates the PersistenceManager cache with the
datastore. |
|
void |
close()
Close this PersistenceManager so that no further requests
may be made on it. |
|
Transaction |
currentTransaction()
Return the Transaction instance associated with a
PersistenceManager . |
|
void |
deletePersistent(java.lang.Object pc)
Delete the persistent instance from the data store. |
|
void |
deletePersistentAll(java.util.Collection pcs)
Delete a Collection of instances from the data store. |
|
void |
deletePersistentAll(java.lang.Object... pcs)
Delete an array of instances from the data store. |
|
|
detachCopy(T pc)
Detach the specified instance from the PersistenceManager . |
|
|
detachCopyAll(java.util.Collection<T> pcs)
Detach the specified instances from the PersistenceManager . |
|
|
detachCopyAll(T... pcs)
Detach the specified instances from the PersistenceManager . |
|
void |
evict(java.lang.Object pc)
Mark an instance as no longer needed in the cache. |
|
void |
evictAll()
Mark all persistent-nontransactional instances as no longer needed in the cache. |
|
void |
evictAll(boolean subclasses,
java.lang.Class pcClass)
Mark the parameter instances as no longer needed in the cache. |
|
void |
evictAll(java.util.Collection pcs)
Mark a Collection of instances as no longer needed in the
cache. |
|
void |
evictAll(java.lang.Object... pcs)
Mark an array of instances as no longer needed in the cache. |
|
void |
flush()
Flushes all dirty, new, and deleted instances to the data store. |
|
boolean |
getCopyOnAttach()
Gets the copyOnAttach setting. |
|
JDOConnection |
getDataStoreConnection()
If this method is called while a datastore transaction is active, the object returned will be enlisted in the current transaction. |
|
boolean |
getDetachAllOnCommit()
Gets the detachAllOnCommit setting. |
|
|
getExtent(java.lang.Class<T> persistenceCapableClass)
Equivalent to getExtent (persistenceCapableClass,
true) . |
|
|
getExtent(java.lang.Class<T> persistenceCapableClass,
boolean subclasses)
The PersistenceManager manages a collection of instances in
the data store based on the class of the instances. |
|
FetchGroup |
getFetchGroup(java.lang.Class cls,
java.lang.String name)
Get a modifiable FetchGroup for the Class and name. |
|
FetchPlan |
getFetchPlan()
Returns the FetchPlan used by this
PersistenceManager . |
|
boolean |
getIgnoreCache()
Get the ignoreCache setting for queries. |
|
java.util.Set |
getManagedObjects()
Get the objects managed by this persistence manager. |
|
java.util.Set |
getManagedObjects(java.lang.Class... classes)
Get the objects managed by this persistence manager being instances of the specified classes. |
|
java.util.Set |
getManagedObjects(java.util.EnumSet<ObjectState> states)
Get the objects managed by this persistence manager having the specified object states. |
|
java.util.Set |
getManagedObjects(java.util.EnumSet<ObjectState> states,
java.lang.Class... classes)
Get the objects managed by this persistence manager having the specified object states and being instances of the specified classes. |
|
boolean |
getMultithreaded()
Get the current Multithreaded flag for this PersistenceManager . |
|
|
getObjectById(java.lang.Class<T> cls,
java.lang.Object key)
Looks up the instance of the given type with the given key. |
|
java.lang.Object |
getObjectById(java.lang.Object oid)
Looks up the instance corresponding to the specified oid. |
|
java.lang.Object |
getObjectById(java.lang.Object oid,
boolean validate)
This method locates a persistent instance in the cache of instances managed by this PersistenceManager . |
|
java.lang.Object |
getObjectId(java.lang.Object pc)
The ObjectId returned by this method represents the JDO identity of the instance. |
|
java.lang.Class |
getObjectIdClass(java.lang.Class cls)
Return the Class that implements the JDO Identity for the
specified PersistenceCapable class. |
|
java.lang.Object[] |
getObjectsById(boolean validate,
java.lang.Object... oids)
Return the objects with the given oids. |
|
java.util.Collection |
getObjectsById(java.util.Collection oids)
Return the objects with the given oids. |
|
java.util.Collection |
getObjectsById(java.util.Collection oids,
boolean validate)
Return the objects with the given oids. |
|
java.lang.Object[] |
getObjectsById(java.lang.Object... oids)
Return the objects with the given oids. |
|
java.lang.Object[] |
getObjectsById(java.lang.Object[] oids,
boolean validate)
Deprecated. |
|
PersistenceManagerFactory |
getPersistenceManagerFactory()
This method returns the PersistenceManagerFactory used to
create this PersistenceManager . |
|
Sequence |
getSequence(java.lang.String name)
Returns the sequence identified by name . |
|
java.util.Date |
getServerDate()
Get the Date as seen by the server. |
|
java.lang.Object |
getTransactionalObjectId(java.lang.Object pc)
The ObjectId returned by this method represents the JDO identity of the instance. |
|
java.lang.Object |
getUserObject()
The application can manage the PersistenceManager instances
more easily by having an application object associated with each
PersistenceManager instance. |
|
java.lang.Object |
getUserObject(java.lang.Object key)
Get the value for the specified key from the map of user objects. |
|
boolean |
isClosed()
A PersistenceManager instance can be used until it is
closed. |
|
void |
makeNontransactional(java.lang.Object pc)
Make an instance non-transactional after commit. |
|
void |
makeNontransactionalAll(java.util.Collection pcs)
Make a Collection of instances non-transactional after
commit. |
|
void |
makeNontransactionalAll(java.lang.Object... pcs)
Make an array of instances non-transactional after commit. |
|
|
makePersistent(T pc)
Make the parameter instance persistent in this PersistenceManager . |
|
|
makePersistentAll(java.util.Collection<T> pcs)
Make a Collection of instances persistent. |
|
|
makePersistentAll(T... pcs)
Make an array of instances persistent. |
|
void |
makeTransactional(java.lang.Object pc)
Make an instance subject to transactional boundaries. |
|
void |
makeTransactionalAll(java.util.Collection pcs)
Make a Collection of instances subject to transactional
boundaries. |
|
void |
makeTransactionalAll(java.lang.Object... pcs)
Make an array of instances subject to transactional boundaries. |
|
void |
makeTransient(java.lang.Object pc)
Make an instance transient, removing it from management by this PersistenceManager . |
|
void |
makeTransient(java.lang.Object pc,
boolean useFetchPlan)
Make an instance transient, removing it from management by this PersistenceManager . |
|
void |
makeTransientAll(boolean useFetchPlan,
java.lang.Object... pcs)
Make instances transient, removing them from management by this PersistenceManager . |
|
void |
makeTransientAll(java.util.Collection pcs)
Make a Collection of instances transient, removing them
from management by this PersistenceManager . |
|
void |
makeTransientAll(java.util.Collection pcs,
boolean useFetchPlan)
Make instances transient, removing them from management by this PersistenceManager . |
|
void |
makeTransientAll(java.lang.Object... pcs)
Make an array of instances transient, removing them from management by this PersistenceManager . |
|
void |
makeTransientAll(java.lang.Object[] pcs,
boolean useFetchPlan)
Deprecated. |
|
|
newInstance(java.lang.Class<T> pcClass)
Creates an instance of a persistence-capable interface, or of a concrete or abstract class. |
|
Query |
newNamedQuery(java.lang.Class cls,
java.lang.String queryName)
Create a new Query with the given candidate class
from a named query. |
|
java.lang.Object |
newObjectIdInstance(java.lang.Class pcClass,
java.lang.Object key)
This method returns an object id instance corresponding to the pcClass and key arguments. |
|
Query |
newQuery()
Create a new Query with no elements. |
|
Query |
newQuery(java.lang.Class cls)
Create a new Query specifying the Class of the
candidate instances. |
|
Query |
newQuery(java.lang.Class cls,
java.util.Collection cln)
Create a new Query with the candidate Class
and Collection . |
|
Query |
newQuery(java.lang.Class cls,
java.util.Collection cln,
java.lang.String filter)
Create a new Query with the Class of the
candidate instances,
candidate Collection , and filter. |
|
Query |
newQuery(java.lang.Class cls,
java.lang.String filter)
Create a new Query with the Class of the
candidate instances and filter. |
|
Query |
newQuery(Extent cln)
Create a new Query with the Class of the
candidate instances and candidate Extent . |
|
Query |
newQuery(Extent cln,
java.lang.String filter)
Create a new Query with the
candidate Extent and filter; the class
is taken from the Extent . |
|
Query |
newQuery(java.lang.Object compiled)
Create a new Query using elements from another
Query . |
|
Query |
newQuery(java.lang.String query)
Create a Construct a new query instance using the specified String as the single-string representation of the query. |
|
Query |
newQuery(java.lang.String language,
java.lang.Object query)
Create a new Query using the specified language. |
|
java.lang.Object |
putUserObject(java.lang.Object key,
java.lang.Object val)
Put the specified key-value pair into the map of user objects. |
|
void |
refresh(java.lang.Object pc)
Refresh the state of the instance from the data store. |
|
void |
refreshAll()
Refresh the state of all applicable instances from the data store. |
|
void |
refreshAll(java.util.Collection pcs)
Refresh the state of a Collection of instances from the
data store. |
|
void |
refreshAll(JDOException jdoe)
Refreshes all instances in the exception that failed verification. |
|
void |
refreshAll(java.lang.Object... pcs)
Refresh the state of an array of instances from the data store. |
|
void |
removeInstanceLifecycleListener(InstanceLifecycleListener listener)
Removes the listener instance from the list of lifecycle event listeners. |
|
java.lang.Object |
removeUserObject(java.lang.Object key)
Remove the specified key and its value from the map of user objects. |
|
void |
retrieve(java.lang.Object pc)
Retrieve field values of an instance from the store. |
|
void |
retrieve(java.lang.Object pc,
boolean useFetchPlan)
Retrieve field values of an instance from the store. |
|
void |
retrieveAll(boolean useFetchPlan,
java.lang.Object... pcs)
Retrieve field values of instances from the store. |
|
void |
retrieveAll(java.util.Collection pcs)
Retrieve field values of instances from the store. |
|
void |
retrieveAll(java.util.Collection pcs,
boolean useFetchPlan)
Retrieve field values of instances from the store. |
|
void |
retrieveAll(java.lang.Object... pcs)
Retrieve field values of instances from the store. |
|
void |
retrieveAll(java.lang.Object[] pcs,
boolean useFetchPlan)
Deprecated. |
|
void |
setCopyOnAttach(boolean flag)
Sets the copyOnAttach setting. |
|
void |
setDetachAllOnCommit(boolean flag)
Sets the detachAllOnCommit setting. |
|
void |
setIgnoreCache(boolean flag)
Set the ignoreCache parameter for queries. |
|
void |
setMultithreaded(boolean flag)
Set the Multithreaded flag for this PersistenceManager . |
|
void |
setUserObject(java.lang.Object o)
The application can manage the PersistenceManager instances
more easily by having an application object associated with each
PersistenceManager instance. |
| Method Detail |
|---|
boolean isClosed()
PersistenceManager
instance can be used until it is
closed.
true
if this PersistenceManager
has
been closed.close()
void close()
PersistenceManager
so that no further requests
may be made on it. A PersistenceManager
instance can be
used only until it is closed.
Closing a PersistenceManager
might release it to the pool
of available PersistenceManager
s, or might be garbage
collected, at the option of the JDO implementation. Before being used
again to satisfy a getPersistenceManager()
request, the
default values for options will be restored to their values as specified
in the PersistenceManagerFactory
.
This method closes the PersistenceManager
.
Transaction currentTransaction()
Transaction
instance associated with a
PersistenceManager
. There is one Transaction
instance associated with each PersistenceManager
instance.
The Transaction
instance supports options as well as
transaction completion requests.
Transaction
associated with this
PersistenceManager
.void evict(java.lang.Object pc)
PersistenceManager
at transaction
completion. This method allows the application to explicitly provide a
hint to the PersistenceManager
that the instance is no
longer needed in the cache.
pc
- the instance to evict from the cache.void evictAll(java.lang.Object... pcs)
pcs
- the array of instances to evict from the cache.evict(Object pc)
void evictAll(java.util.Collection pcs)
Collection
of instances as no longer needed in the
cache.
pcs
- the Collection
of instances to evict from the
cache.evict(Object pc)
void evictAll(boolean subclasses, java.lang.Class pcClass)
pcClass
- the class of instances to evictsubclasses
- if true, mark instances of subclasses alsovoid evictAll()
evict(Object pc)
void refresh(java.lang.Object pc)
In an optimistic transaction, the state of instances in the cache might not match the state in the data store. This method is used to reload the state of the instance from the data store so that a subsequent commit is more likely to succeed.
Outside a transaction, this method will refresh nontransactional state.
pc
- the instance to refresh.void refreshAll(java.lang.Object... pcs)
pcs
- the array of instances to refresh.refresh(Object pc)
void refreshAll(java.util.Collection pcs)
Collection
of instances from the
data store.
pcs
- the Collection
of instances to refresh.refresh(Object pc)
void refreshAll()
If called with an active transaction, all transactional instances will be refreshed. If called outside an active transaction, all nontransactional instances will be refreshed.
refresh(Object pc)
void refreshAll(JDOException jdoe)
Query newQuery()
Query
with no elements.
Query
.Query newQuery(java.lang.Object compiled)
Query
using elements from another
Query
. The other Query
must have been created
by the same JDO implementation. It might be active in a different
PersistenceManager
or might have been serialized and
restored.
All of the settings of the other Query
are copied to this
Query
, except for the candidate Collection
or
Extent
.
compiled
- another Query
from the same JDO
implementation
Query
Query newQuery(java.lang.String query)
query
- the single-string query
Query
Query newQuery(java.lang.String language, java.lang.Object query)
Query
using the specified language.
language
- the language of the query parameterquery
- the query, which is of a form determined by the language
Query
Query newQuery(java.lang.Class cls)
Query
specifying the Class
of the
candidate instances.
cls
- the Class
of the candidate instances
Query
Query newQuery(Extent cln)
Query
with the Class
of the
candidate instances and candidate Extent
.
cln
- the Extent
of candidate instances
Query
Query newQuery(java.lang.Class cls, java.util.Collection cln)
Query
with the candidate Class
and Collection
.
cls
- the Class
of resultscln
- the Collection
of candidate instances
Query
Query newQuery(java.lang.Class cls, java.lang.String filter)
Query
with the Class
of the
candidate instances and filter.
cls
- the Class
of resultsfilter
- the filter for candidate instances
Query
Query newQuery(java.lang.Class cls, java.util.Collection cln, java.lang.String filter)
Query
with the Class
of the
candidate instances,
candidate Collection
, and filter.
cls
- the Class
of candidate instancescln
- the Collection
of candidate instancesfilter
- the filter for candidate instances
Query
Query newQuery(Extent cln, java.lang.String filter)
Query
with the
candidate Extent
and filter; the class
is taken from the Extent
.
cln
- the Extent
of candidate instancesfilter
- the filter for candidate instances
Query
Query newNamedQuery(java.lang.Class cls, java.lang.String queryName)
Query
with the given candidate class
from a named query. The query name given must be the name of a
query defined in metadata.
cls
- the Class
of candidate instancesqueryName
- the name of the query to look up in metadata
Query
<T> Extent<T> getExtent(java.lang.Class<T> persistenceCapableClass, boolean subclasses)
PersistenceManager
manages a collection of instances in
the data store based on the class of the instances. This method returns
an Extent
of instances in the data store that might be
iterated or given to a Query
. The Extent
itself might not reference any instances, but only hold the class name
and an indicator as to whether subclasses are included in the
Extent
.
Note that the Extent
might be very large.
persistenceCapableClass
- Class
of instancessubclasses
- whether to include instances of subclasses
Extent
of the specified Class
Query
<T> Extent<T> getExtent(java.lang.Class<T> persistenceCapableClass)
getExtent (persistenceCapableClass,
true)
.
getExtent(Class,boolean)
java.lang.Object getObjectById(java.lang.Object oid, boolean validate)
PersistenceManager
.
The getObjectById
method attempts
to find an instance in the cache with the specified JDO identity.
The oid
parameter object might have been returned by an
earlier call to getObjectId
or
getTransactionalObjectId
, or might have been constructed by
the application.
If the PersistenceManager
is unable to resolve the
oid
parameter to an ObjectId instance, then it throws a
JDOUserException
.
If the validate
flag is false
, and there is
already an instance in the cache with the same JDO identity as the
oid
parameter, then this method returns it. There is no
change made to the state of the returned instance.
If there is not an instance already in the cache with the same JDO
identity as the oid
parameter, then this method creates an
instance with the specified JDO identity and returns it. If there is no
transaction in progress, the returned instance will be hollow or
persistent-nontransactional, at the choice of the implementation.
If there is a transaction in progress, the returned instance will be hollow, persistent-nontransactional, or persistent-clean, at the choice of the implementation.
It is an implementation decision whether to access the data store,
if required to determine the exact class. This will be the case of
inheritance, where multiple PersistenceCapable
classes share
the same ObjectId class.
If the validate flag is false
, and the instance does not
exist in the data store, then this method might not fail. It is an
implementation choice whether to fail immediately with a
JDOObjectNotFoundException
. But a subsequent access
of the fields of the
instance will throw a JDOObjectNotFoundException
if the instance does not
exist at that time. Further, if a relationship is established to this
instance, then the transaction in which the association was made will
fail.
If the validate
flag is true
, and there is
already a transactional instance in the cache with the same JDO identity
as the oid
parameter, then this method returns it. There is
no change made to the state of the returned instance.
If there is an instance already in the cache with the same JDO
identity as the oid
parameter, but the instance is not
transactional, then it must be verified in the data store. If the
instance does not exist in the datastore, then a
JDOObjectNotFoundException
is thrown.
If there is not an instance already in the cache with the same JDO
identity as the oid
parameter, then this method creates an
instance with the specified JDO identity, verifies that it exists in the
data store, and returns it. If there is no transaction in progress, the
returned instance will be hollow or persistent-nontransactional,
at the choice of the implementation.
If there is a data store transaction in progress, the returned instance will be persistent-clean. If there is an optimistic transaction in progress, the returned instance will be persistent-nontransactional.
oid
- an ObjectIdvalidate
- if the existence of the instance is to be validated
PersistenceCapable
instance with the specified
ObjectIdgetObjectId(Object pc)
,
getTransactionalObjectId(Object pc)
<T> T getObjectById(java.lang.Class<T> cls, java.lang.Object key)
cls
- The type of object to loadkey
- either the string representation of the object id, or
an object representation of a single field identity key
java.lang.Object getObjectById(java.lang.Object oid)
getObjectById(oid, true);
- Parameters:
oid
- The object id of the object to load
- Returns:
- the corresponding persistent instance
java.lang.Object getObjectId(java.lang.Object pc)
The getObjectId
method returns an ObjectId instance that
represents the object identity of the specified JDO instance. The
identity is guaranteed to be unique only in the context of the JDO
PersistenceManager
that created the identity, and only for
two types of JDO Identity: those that are managed by the application, and
those that are managed by the data store.
If the object identity is being changed in the transaction, by the
application modifying one or more of the application key fields,
then this method returns the identity as of the beginning of the
transaction. The value returned by getObjectId
will be
different following afterCompletion
processing for
successful transactions.
Within a transaction, the ObjectId returned
will compare equal to the ObjectId returned by only one among all JDO
instances associated with the PersistenceManager
regardless
of the type of ObjectId.
The ObjectId does not necessarily contain any internal state of the instance, nor is it necessarily an instance of the class used to manage identity internally. Therefore, if the application makes a change to the ObjectId instance returned by this method, there is no effect on the instance from which the ObjectId was obtained.
The getObjectById
method can be used between instances of
PersistenceManager
of different JDO vendors only for
instances of persistence capable classes using application-managed
(primary key) JDO identity. If it is used for instances of classes using
datastore identity, the method might succeed, but there are no guarantees
that the parameter and return instances are related in any way.
pc
- the PersistenceCapable
instance
getTransactionalObjectId(Object pc)
,
getObjectById(Object oid, boolean validate)
java.lang.Object getTransactionalObjectId(java.lang.Object pc)
If the object identity is being changed in the transaction, by the application modifying one or more of the application key fields, then this method returns the current identity in the transaction.
If there is no transaction in progress, or if none of the key fields
is being modified, then this method will return the same value as
getObjectId
.
pc
- a PersistenceCapable
instance
getObjectId(Object pc)
,
getObjectById(Object oid, boolean validate)
java.lang.Object newObjectIdInstance(java.lang.Class pcClass, java.lang.Object key)
pcClass
- the Class
of the persistence-capable instancekey
- for single-field identity, the parameter for the
constructor; for non-single-field application identity, the result
of toString() on the object id instance.
java.util.Collection getObjectsById(java.util.Collection oids, boolean validate)
oids
- the oids of the objects to returnvalidate
- if true, the existance of the objects in
the datastore will be validated.
getObjectById(Object,boolean)
java.util.Collection getObjectsById(java.util.Collection oids)
getObjectsById(Collection, boolean)
with the validate flag true.
oids
- the oids of the objects to return
getObjectsById(Collection,boolean)
java.lang.Object[] getObjectsById(java.lang.Object[] oids, boolean validate)
oids
- the oids of the objects to returnvalidate
- if true, the existance of the objects in
the datastore will be validated.
getObjectById(Object,boolean)
,
getObjectsById(boolean,Object...)
java.lang.Object[] getObjectsById(boolean validate, java.lang.Object... oids)
oids
- the oids of the objects to returnvalidate
- if true, the existance of the objects in
the datastore will be validated.
getObjectById(Object,boolean)
java.lang.Object[] getObjectsById(java.lang.Object... oids)
getObjectsById(boolean,Object...)
with the validate flag true.
oids
- the oids of the objects to return
getObjectsById(boolean,Object...)
<T> T makePersistent(T pc)
PersistenceManager
.
This method makes transient instances persistent and applies detached
instance changes to the cache. It must be called in the context of
an active transaction, or a JDOUserException is thrown. For a transient
instance, it assigns an object identity to the instance and transitions
it to persistent-new. Any transient instances reachable from this
instance via persistent fields of this instance become provisionally
persistent, transitively. That is, they behave as persistent-new
instances (return true to isPersistent, isNew, and isDirty).
But at commit time, the reachability algorithm is run again,
and instances made provisionally persistent that are not then
reachable from persistent instances will revert to transient.
During makePersistent of transient instances, the create life cycle listener is called.
For detached instances, it locates or instantiates a persistent instance with the same JDO identity as the detached instance, and merges the persistent state of the detached instance into the persistent instance. Only the state of persistent fields is merged. If non-persistent state needs to be copied, the application should use the jdoPostAttach callback or the postAttach lifecycle event listener. Any references to the detached instances from instances in the closure of the parameter instances are modified to refer to the corresponding persistent instance instead of to the detached instance.
During attachment of detached instances, the attach callbacks and attach life cycle listeners are called.
During application of changes of the detached state, if the JDO implementation can determine that there were no changes made during detachment, then the implementation is not required to mark the corresponding instance dirty. If it cannot determine if changes were made, then it must mark the instance dirty. No consistency checking is done during makePersistent of detached instances. If consistency checking is required by the application, then flush or checkConsistency should be called after attaching the instances.
These methods have no effect on parameter persistent instances already managed by this PersistenceManager. They will throw a JDOUserException if the parameter instance is managed by a different PersistenceManager. If an instance is of a class whose identity type (application, datastore, or none) is not supported by the JDO implementation, then a JDOUserException will be thrown for that instance. The return value for parameter instances in the transient or persistent states is the same as the parameter value. The return value for parameter instances in the detached state is the persistent instance corresponding to the detached instance. The return values for makePersistentAll methods correspond by position to the parameter instances.
pc
- an instance of a Class
that is persistent
capable.
<T> T[] makePersistentAll(T... pcs)
pcs
- an array of instances
makePersistent(Object pc)
<T> java.util.Collection<T> makePersistentAll(java.util.Collection<T> pcs)
Collection
of instances persistent.
pcs
- a Collection
of instances
makePersistent(Object pc)
void deletePersistent(java.lang.Object pc)
makePersistent
, which makes the closure of the
instance persistent, the closure of the instance is not deleted from the
data store. This method has no effect if the instance is already deleted
in the current transaction.
This method throws JDOUserException
if the instance is
transient or is managed by another PersistenceManager
.
pc
- a persistent instancevoid deletePersistentAll(java.lang.Object... pcs)
pcs
- a Collection
of persistent instancesdeletePersistent(Object pc)
void deletePersistentAll(java.util.Collection pcs)
Collection
of instances from the data store.
pcs
- a Collection
of persistent instancesdeletePersistent(Object pc)
void makeTransient(java.lang.Object pc)
PersistenceManager
.
The instance loses its JDO identity and it is no longer associated
with any PersistenceManager
. The state of fields is
preserved unchanged.
pc
- the instance to make transient.void makeTransientAll(java.lang.Object... pcs)
PersistenceManager
.
The instances lose their JDO identity and they are no longer
associated with any PersistenceManager
. The state of fields
is preserved unchanged.
pcs
- the instances to make transient.void makeTransientAll(java.util.Collection pcs)
Collection
of instances transient, removing them
from management by this PersistenceManager
.
The instances lose their JDO identity and they are no longer
associated with any PersistenceManager
. The state of fields
is preserved unchanged.
pcs
- the instances to make transient.void makeTransient(java.lang.Object pc, boolean useFetchPlan)
PersistenceManager
. If the useFetchPlan parameter is
false, this method behaves exactly as makeTransient(Object pc).
The affected instance(s) lose their JDO identity and are no longer
associated with any PersistenceManager
. The state
of fields is unchanged.
If the useFetchPlan parameter is true, then the current FetchPlan is applied to the pc parameter, as if detachCopy(Object) had been called. After the graph of instances is loaded, the instances reachable via loaded fields is made transient. The state of fields in the affected instances is as specified by the FetchPlan.
Unlike detachCopy, the instances are not detached; there is no detachment information in the instances.
The instances to be made transient do not need to implement the javax.jdo.spi.Detachable interface.
pc
- the root instance to make transient.useFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to make transientvoid makeTransientAll(java.lang.Object[] pcs, boolean useFetchPlan)
PersistenceManager
. If the useFetchPlan parameter
is false, this method behaves exactly as makeTransientAll(Object[] pcs).
The affected instance(s) lose their JDO identity and are no longer
associated with any PersistenceManager
. The state
of fields is unchanged.
If the useFetchPlan parameter is true, then the current FetchPlan is applied to the pcs parameters and the entire graph of instances reachable via loaded fields is made transient. The state of fields in the affected instances is as specified by the FetchPlan.
Unlike detachCopy, the instances are not detached; there is no detachment information in the instances.
The instances to be made transient do not need to implement the javax.jdo.spi.Detachable interface.
pcs
- the root instances to make transient.useFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to make transientmakeTransientAll(boolean,Object...)
void makeTransientAll(boolean useFetchPlan, java.lang.Object... pcs)
PersistenceManager
. If the useFetchPlan parameter
is false, this method behaves exactly as makeTransientAll(Object[] pcs).
The affected instance(s) lose their JDO identity and are no longer
associated with any PersistenceManager
. The state
of fields is unchanged.
If the useFetchPlan parameter is true, then the current FetchPlan is applied to the pcs parameters and the entire graph of instances reachable via loaded fields is made transient. The state of fields in the affected instances is as specified by the FetchPlan.
Unlike detachCopy, the instances are not detached; there is no detachment information in the instances.
The instances to be made transient do not need to implement the javax.jdo.spi.Detachable interface.
pcs
- the root instances to make transient.useFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to make transientvoid makeTransientAll(java.util.Collection pcs, boolean useFetchPlan)
PersistenceManager
. If the useFetchPlan parameter
is false, this method behaves exactly as
makeTransientAll(Collection pcs).
The affected instance(s) lose their JDO identity and are no longer
associated with any PersistenceManager
. The state
of fields is unchanged.
If the useFetchPlan parameter is true, then the current FetchPlan is applied to the pcs parameters and the entire graph of instances reachable via loaded fields is made transient. The state of fields in the affected instances is as specified by the FetchPlan.
Unlike detachCopy, the instances are not detached; there is no detachment information in the instances.
The instances to be made transient do not need to implement the javax.jdo.spi.Detachable interface.
pcs
- the root instances to make transient.useFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to make transientvoid makeTransactional(java.lang.Object pc)
Transient instances normally do not observe transaction boundaries. This method makes transient instances sensitive to transaction completion. If an instance is modified in a transaction, and the transaction rolls back, the state of the instance is restored to the state before the first change in the transaction.
For persistent instances read in optimistic transactions, this method allows the application to make the state of the instance part of the transactional state. At transaction commit, the state of the instance in the cache is compared to the state of the instance in the data store. If they are not the same, then an exception is thrown.
pc
- the instance to make transactional.void makeTransactionalAll(java.lang.Object... pcs)
pcs
- the array of instances to make transactional.makeTransactional(Object pc)
void makeTransactionalAll(java.util.Collection pcs)
Collection
of instances subject to transactional
boundaries.
pcs
- the Collection
of instances to make
transactional.makeTransactional(Object pc)
void makeNontransactional(java.lang.Object pc)
Normally, at transaction completion, instances are evicted from the cache. This method allows an application to identify an instance as not being evicted from the cache at transaction completion. Instead, the instance remains in the cache with nontransactional state.
pc
- the instance to make nontransactional.void makeNontransactionalAll(java.lang.Object... pcs)
pcs
- the array of instances to make nontransactional.makeNontransactional(Object pc)
void makeNontransactionalAll(java.util.Collection pcs)
Collection
of instances non-transactional after
commit.
pcs
- the Collection
of instances to make
nontransactional.makeNontransactional(Object pc)
void retrieve(java.lang.Object pc)
PersistenceManager
that the application intends to use
the instance, and its field values must be retrieved.
The PersistenceManager
might use policy information about
the class to retrieve associated instances.
pc
- the instancevoid retrieve(java.lang.Object pc, boolean useFetchPlan)
PersistenceManager
that the application intends to use
the instance, and its field values must be retrieved.
If the useFetchPlan parameter is false, this method behaves exactly as the corresponding method without the useFetchPlan parameter. If the useFetchPlan parameter is true, and the fetch plan has not been modified from its default setting, all fields in the current fetch plan are fetched, and other fields might be fetched lazily by the implementation. If the useFetchPlan parameter is true, and the fetch plan has been changed from its default setting, then the fields specified by the fetch plan are loaded, along with related instances specified by the fetch plan.
pc
- the instanceuseFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to retrieve.void retrieveAll(java.util.Collection pcs)
PersistenceManager
that the application intends to use
the instances, and all field values must be retrieved.
The PersistenceManager
might use policy information about
the class to retrieve associated instances.
pcs
- the instancesvoid retrieveAll(java.util.Collection pcs, boolean useFetchPlan)
PersistenceManager
that the application intends to use
the instances, and their field values should be retrieved. The fields
in the current fetch group must be retrieved, and the implementation
might retrieve more fields than the current fetch group.
If the useFetchPlan parameter is false, this method behaves exactly as the corresponding method without the useFetchPlan parameter. If the useFetchPlan parameter is true, and the fetch plan has not been modified from its default setting, all fields in the current fetch plan are fetched, and other fields might be fetched lazily by the implementation. If the useFetchPlan parameter is true, and the fetch plan has been changed from its default setting, then the fields specified by the fetch plan are loaded, along with related instances specified by the fetch plan.
pcs
- the instancesuseFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to retrieve.void retrieveAll(java.lang.Object... pcs)
PersistenceManager
that the application intends to use
the instances, and all field values must be retrieved.
The PersistenceManager
might use policy information about
the class to retrieve associated instances.
pcs
- the instancesvoid retrieveAll(java.lang.Object[] pcs, boolean useFetchPlan)
PersistenceManager
that the application intends to use
the instances, and their field values should be retrieved. The fields
in the current fetch group must be retrieved, and the implementation
might retrieve more fields than the current fetch group.
If the useFetchPlan parameter is false, this method behaves exactly as the corresponding method without the useFetchPlan parameter. If the useFetchPlan parameter is true, and the fetch plan has not been modified from its default setting, all fields in the current fetch plan are fetched, and other fields might be fetched lazily by the implementation. If the useFetchPlan parameter is true, and the fetch plan has been changed from its default setting, then the fields specified by the fetch plan are loaded, along with related instances specified by the fetch plan.
pcs
- the instancesuseFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to retrieve.retrieveAll(boolean,Object...)
void retrieveAll(boolean useFetchPlan, java.lang.Object... pcs)
PersistenceManager
that the application intends to use
the instances, and their field values should be retrieved. The fields
in the current fetch group must be retrieved, and the implementation
might retrieve more fields than the current fetch group.
If the useFetchPlan parameter is false, this method behaves exactly as the corresponding method without the useFetchPlan parameter. If the useFetchPlan parameter is true, and the fetch plan has not been modified from its default setting, all fields in the current fetch plan are fetched, and other fields might be fetched lazily by the implementation. If the useFetchPlan parameter is true, and the fetch plan has been changed from its default setting, then the fields specified by the fetch plan are loaded, along with related instances specified by the fetch plan.
pcs
- the instancesuseFetchPlan
- whether to use the current fetch plan to determine
which fields to load and which instances to retrieve.void setUserObject(java.lang.Object o)
PersistenceManager
instances
more easily by having an application object associated with each
PersistenceManager
instance.
o
- the user instance to be remembered by the
PersistenceManager
getUserObject()
java.lang.Object getUserObject()
PersistenceManager
instances
more easily by having an application object associated with each
PersistenceManager
instance.
PersistenceManager
setUserObject(java.lang.Object)
PersistenceManagerFactory getPersistenceManagerFactory()
PersistenceManagerFactory
used to
create this PersistenceManager
.
PersistenceManagerFactory
that created
this PersistenceManager
java.lang.Class getObjectIdClass(java.lang.Class cls)
Class
that implements the JDO Identity for the
specified PersistenceCapable
class. The application can use
the returned Class
to construct a JDO Identity instance for
application identity PersistenceCapable
classes. This JDO
Identity instance can then be used to get an instance of the
PersistenceCapable
class for use in the application.
In order for the application to construct an instance of the ObjectId class it needs to know the class being used by the JDO implementation.
cls
- the PersistenceCapable Class
Class
of the ObjectId of the parametergetObjectById(java.lang.Object, boolean)
void setMultithreaded(boolean flag)
PersistenceManager
.
Applications that use multiple threads to invoke methods or access fields
from instances managed by this PersistenceManager
must set
this flag to true
.
Instances managed by this PersistenceManager
include
persistent or transactional instances of PersistenceCapable
classes, as well as helper instances such as Query
,
Transaction
, or Extent
.
flag
- the Multithreaded setting.boolean getMultithreaded()
PersistenceManager
.
setMultithreaded(boolean)
void setIgnoreCache(boolean flag)
IgnoreCache set to true
specifies that for all
Query
instances created by this
PersistenceManager
, the default is the cache should be
ignored for queries.
flag
- the ignoreCache setting.boolean getIgnoreCache()
IgnoreCache set to true
specifies that for all
Query
instances created by this
PersistenceManager
, the default is the cache should be
ignored for queries.
boolean getDetachAllOnCommit()
setDetachAllOnCommit(boolean)
void setDetachAllOnCommit(boolean flag)
DetachAllOnCommit set to false
specifies that the
state of persistent instances in the cache after commit is defined
by the retainValues
flag. With this flag set to true,
during beforeCompletion all cached instances are prepared for
detachment according to the fetch plan in effect at commit. Loading
fields and unloading fields required by the fetch plan is done after
calling the user's beforeCompletion
callback. During
afterCompletion
, before calling the user's
afterCompletion
callback, all detachable persistent
instances in the cache transition to detached; non-detachable
persistent instances transition to transient; and detachable
instances can be serialized as detached instances. Transient
transactional instances are unaffected by this flag.
getDetachAllOnCommit()
boolean getCopyOnAttach()
setCopyOnAttach(boolean)
void setCopyOnAttach(boolean flag)
CopyOnAttach set to true
specifies that during
makePersistent, copies are made of detached parameter instances.
With this flag set to false
, detached parameter
instances are attached directly and change their state from
detached-clean to persistent-clean or from detached-dirty to
persistent-dirty.
getCopyOnAttach()
<T> T detachCopy(T pc)
PersistenceManager
.
The flags for detachment (DETACH_LOAD_FIELDS and DETACH_UNLOAD_FIELDS)
and the active fetch groups determine the scope of fetching for the
graph of instances reachable from the pc parameter. The state of fields
in the affected instances is as specified by the FetchPlan.
pc
- the instance to detach
detachCopyAll(Object[])
<T> java.util.Collection<T> detachCopyAll(java.util.Collection<T> pcs)
PersistenceManager
.
The flags for detachment (DETACH_LOAD_FIELDS and DETACH_UNLOAD_FIELDS)
and the active fetch groups determine the scope of fetching for the
graph of instances reachable from the pcs parameter. The state of fields
in the affected instances is as specified by the FetchPlan.
pcs
- the instances to detach
detachCopyAll(Object[])
<T> T[] detachCopyAll(T... pcs)
PersistenceManager
.
The flags for detachment (DETACH_LOAD_FIELDS and DETACH_UNLOAD_FIELDS)
and the active fetch groups determine the scope of fetching for the
graph of instances reachable from the pcs parameter. The state of fields
in the affected instances is as specified by the FetchPlan.
The objects returned can be manipulated and re-attached with
makePersistentAll(Object[])
.
The detached instances will be
unmanaged copies of the specified parameters, and are suitable
for serialization and manipulation outside of a JDO
environment. When detaching instances, only fields in the
current FetchPlan
will be traversed. Thus, to detach a
graph of objects, relations to other persistent instances must
either be in the default-fetch-group
, or in the
current custom FetchPlan
.
pcs
- the instances to detach
JDOUserException
- if any of the instances to be detached do not
implement the javax.jdo.spi.Detachable interface.makePersistentAll(Object[])
,
getFetchPlan()
java.lang.Object putUserObject(java.lang.Object key, java.lang.Object val)
java.lang.Object getUserObject(java.lang.Object key)
key
- the key of the object to be returned
java.lang.Object removeUserObject(java.lang.Object key)
key
- the key of the object to be removedvoid flush()
If a datastore transaction is active, this method synchronizes the cache with the datastore and reports any exceptions.
If an optimistic transaction is active, this method obtains a datastore connection, synchronizes the cache with the datastore using this connection and reports any exceptions. The connection obtained by this method is held until the end of the transaction.
If exceptions occur during flush, the implementation will
set the current transaction's RollbackOnly
flag
(see Transaction.setRollbackOnly()
).
void checkConsistency()
PersistenceManager
cache with the
datastore. This method has no effect if a transaction is not
active.
If a datastore transaction is active, this method verifies
the consistency of instances in the cache against the
datastore. An implementation might flush instances as if
flush()
were called, but it is not required to do
so.
If an optimistic transaction is active, this method obtains
a datastore connection and verifies the consistency of the
instances in the cache against the datastore. If any
inconsistencies are detected, a JDOOptimisticVerificationException
is thrown. This exception
contains a nested JDOOptimisticVerificationException
for each object that failed the consistency check. No
datastore resources acquired during the execution of this
method are held beyond the scope of this method.
FetchPlan getFetchPlan()
FetchPlan
used by this
PersistenceManager
.
<T> T newInstance(java.lang.Class<T> pcClass)
pcClass
- Must be a persistence-capable interface,
or a concrete or abstract class that is declared in the metadata.
Sequence getSequence(java.lang.String name)
name
.
name
- the name of the Sequence
JDOConnection getDataStoreConnection()
void addInstanceLifecycleListener(InstanceLifecycleListener listener, java.lang.Class... classes)
classes
parameter identifies all
of the classes of interest. If the classes
parameter is specified as null
, events for all
persistent classes and interfaces will be sent to
listenerInstance
.
The listenerInstance will be called for each event for which it implements the corresponding listenerInstance interface.
listener
- the lifecycle listenerclasses
- the classes of interest to the listenervoid removeInstanceLifecycleListener(InstanceLifecycleListener listener)
listener
- the listener instance to be removedjava.util.Date getServerDate()
java.util.Set getManagedObjects()
java.util.Set getManagedObjects(java.util.EnumSet<ObjectState> states)
states
- The states of objects that we are interested in
java.util.Set getManagedObjects(java.lang.Class... classes)
classes
- The classes of objects that we are interested in
java.util.Set getManagedObjects(java.util.EnumSet<ObjectState> states, java.lang.Class... classes)
states
- The states of objects that we are interested inclasses
- The classes of objects that we are interested in
FetchGroup getFetchGroup(java.lang.Class cls, java.lang.String name)
FetchGroup
for the Class and name.
If a modifiable FetchGroup
already exists in the
PersistenceManager
scope, return it.
If not, create and populate a new FetchGroup
from the
existing definition in the PersistenceManager
or
PersistenceManagerFactory
. If the definition for the
FetchGroup
is not in scope in either the
PersistenceManager
or
PersistenceManagerFactory
, create it with no members.
The FetchGroup
immediately
becomes active and in scope of the PersistenceManager, and hides
the corresponding fetch group in the PersistenceManagerFactory.
cls
- the class or interface for the FetchGroup
name
- the name of the fetch group
JDOUserException
- if the class is not a persistence-capable
class or interface
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Before Change
if self._has_bug(mutant):
continue
desc = "A potential buffer overflow (accurate detection is" \
" hard...) was found at: %s" % mutant.found_at()
v = Vuln.from_mutant("Buffer overflow vulnerability", desc,
severity.MEDIUM, response.id,
self.get_name(), mutant)
After Change
desc = ("A potential buffer overflow (accurate detection is"
" hard) was found at: %s")
desc %= mutant.found_at()
v = Vuln.from_mutant("Buffer overflow vulnerability", desc,
severity.MEDIUM, response.id,
self.get_name(), mutant)


|
Adjusts two unpacked BCD digits (the least-significant digit in the AL register and the mostsignificant digit in the AH register) so that a division operation performed on the result will yield a correct unpacked BCD value. The AAD instruction is only useful when it precedes a DIV instruction that divides (binary division) the adjusted value in the AX register by an unpacked BCD value.
The AAD instruction sets the value in the AL register to (AL + (10 * AH)), and then clears the AH register to 00H. The value in the AX register is then equal to the binary equivalent of the original unpacked two-digit (base 10) number in registers AH and AL.
The generalized version of this instruction allows adjustment of two unpacked digits of any number base (see the "{operation}" section below), by setting the imm8 byte to the selected number base (for example, 08H for octal, 0AH for decimal, or 0CH for base 12 numbers). The AAD mnemonic is interpreted by all assemblers to mean adjust ASCII (base 10) values. To adjust values in another number base, the instruction must be hand coded in machine code (D5 imm8).
|


Create App
Creating an app
Before you can really get going with Clutch’s developer tools, you have to first create an app, which should roughly correspond to an iOS project in XCode.
Need more help? View the Docs.{% extends "base.html" %} {% block title %}Create a New App - {{ block.super }}{% endblock %} {% block body_id %}dashboard-create-app{% endblock %} {% block body_class %}secondary full{% endblock %} {% block content %}
Before you can really get going with Clutch’s developer tools, you have to first create an app, which should roughly correspond to an iOS project in XCode.
Need more help? View the Docs.


--- layout: post title: Same Old New custom_css: true custom_js: true date: 2018-02-11 23:59:59 -5000 ---
Those who have swords, and know how to use them, but keep them sheathed will inherit the earth.
Made some progress in the Appeals database this week. First, I was asked by my boss's boss to write up a proposal. I actually hadn't in the past and only really documented requirements. Luckily, my boss had at template he used before for other projects at previous jobs. I just filled out the sections the best I could with the track changes set on. I submitted that to my boss for review and waiting to hear what he would want to add.
I didn't let that stop me from making more changes to the database. I started to refactor the GORM code to separate files so I could separate the structure and the functionality. I also started a new file for the AVV import job. I found a library that extends the SSH Golang library and allows me to make SFTP connection to an Optum server. Optum manages the online Appeals for the connector. They store it in some database and then every night they extract the delta changes in the database and upload to their SFTP server for my scripts to go fetch and upload to the appeals database.
Since the new appeals will have to be uploaded to a SQL server I decided that I will rewrite the current process that uses WinSCP, batch script, and a VB script. Way too many moving parts. Also, the script doesn't support the case if the script failed to run one night and the next night there are two delta files to download and upload. I need this process to be all encompassing.
I have already transformed csv files before so that part won't be too difficult. I started to build out the module that would connect to the SFTP server and download the pipe delimited .dat files. First thing though was I was hard coding way too many passwords into the process and decided to see if there was an easy way to use a YAML Ain't Markup Language (YAML) file for configuration. That way if the password for the database or SFTP server ever change you can just modify the text file YAML and not have to recompile the code.
With the configuration set I passed the password to the SFTP module and was able to open a connection and traverse the folders and find all the files. Of course, I was doing it during the day and there were no files to grab so I could test. I will probably suspend the normal process so I can really test out grabbing files via Golang.
I think the project is moving slowly as we decide the features for the previous requirements.  Backend is really handling the database side of things. The frontend was split up into two groups. One group is tackling the client side of things and the other group will take on the admin portal.
I assumed that we had lab 4 and 5 due this week but my group members mentioned that only lab 3 was due. Next lab we need to break down the big features that might take longer than a week and create sub features or task. I guess it is a sort of calm before the storm.


Publications for The HistoryMakers Digital Archive
Publications for The HistoryMakers Digital Archive
The published work is primarily a result of collaboration between The HistoryMakers and the Carnegie Mellon digital video library research team.
See acknowledgments for a description of the early work that led to the HistoryMakers Digital Archive
and its building from Carnegie Mellon Informedia research and initial IMLS and NSF funding. These publications were done under those efforts.
The Digital Archive was in use as an Adobe Flash interface in supporting web browsers from 2008 through 2017, but publications ceased in 2012 with the end of the NSF funding.
New publications based on the updating of the Digital Archive through Andrew W. Mellon Foundation support are anticipated.
Please note: the following publication links will take you out of the Digital Archive. You will need to use your browser back button history to navigate back here.
The work was presented at the annual Oral History Association (OHA)
meeting in 2008, 2010, 2011, 2012, and 2018:
-
At the OHA 2018 meeting in Montreal on Oct. 12, reported work on the use of cloud services, specifically Microsoft Azure, for oral histories,
"Video Oral Histories via a Responsive Web Interface backed by Cloud Service", 4.7 MB PDF slide set of talk.
-
At the OHA 2012 meeting in Cleveland on Oct. 11, Mike Christel presented his and Bryan Maher's work on
IDVL processing for oral histories, "Technologies Improving Access to Oral Histories: Fully Searchable Stories Presented in a
Multimedia Web Portal", 6.1 MB PDF slide set of talk,
0.4 MB PDF paper detailing the talk.
-
Christel presented this work at OHA 2011 in Denver on October 13:
1.9 MB PDF slide set of screen shot walkthroughs accompanying talk,
1.6 MB PDF slide set for talk.
-
At the OHA 2010 Meeting,
Kathryn Stine presented "A Multi-Tiered Approach to Describing Video Oral Histories at The HistoryMakers" and
Mike Christel presented "Facilitating Access to Video Oral Histories through Informedia Technologies and a Multimedia Web Portal."
On the Carnegie Mellon path to a goal of openly sharing systems, software, and interfaces into digital video libraries,
we have beta-tested features with The HistoryMakers as well as other oral history collections. The following references discuss lessons learned along the way:
-
Christel, M., Stevens, S., Maher, B., and Richardson, J.
Enhanced Exploration of Oral History Archives through Processed Video and Synchronized Text Transcripts.
Proc. ACM Multimedia Conference (Florence, Italy, October 2010), pp. 1333-1342. DOI: 10.1145/1873951.1874215
-
Christel, M.G. Automated Metadata in Multimedia Information Systems: Creation, Refinement, Use in Surrogates, and Evaluation
(book link). San Rafael, CA: Morgan and Claypool Publishers, 2009.
DOI:10.2200/S00167ED1V01Y200812ICR002
-
(Conference Demonstration) Christel, M., Baron, R., Froh, G., Benson, D., and Richardson, J.
Accessing the Densho and HistoryMakers Oral History Collections via Informedia Technologies.
Proc. JCDL (Austin, TX, June 2009), p. 465.
-
Christel, M., and Frisch, M. Evaluating the Contributions of Video Representation for a Life Oral
History Collection. Proc. ACM/IEEE-CS Joint Conference on Digital Libraries (Pittsburgh, PA, June 2008), pp. 241-250. DOI: 10.1145/1378889.1378929
(1.7MB PowerPoint slide set shown at conference)
Back to FAQ/Help


About Me!
My name is Rishita Hariyani.I love music and dancing. I also enjoy traveling
Facts about Me
I have Bachelors in Computer Application.
I love creating new things.
I have 5 years teaching experience.


--- title: "Default" description:
The Versatile Table is an evolution UI element to populate table based on JSON. It includes draggable column & row, sorting, searching and user profile pop-up features.
author: Chenfeng Lai category: evolution type: Versatile Table order: 1 ---


Description:
Set of Interfaces including the Identification Concept.
It specifies the CAPE-OPEN common service on Identification concept.
No information on its content is given here, refer to the CAPE-OPEN Concepts Document.
Subclasses:
<<Interface>>ICapeNumericGATComponent The ICapeNumericGATComponent Interface.
This is the entrance object to the CO SMST Component.
First of all, the client must bind to this interface or get its reference by another way. Then, the client can access to the CO SMST Component.


| Package | Description |
|---|---|
| com.team7.cmput301.android.theirisproject.activity | |
| com.team7.cmput301.android.theirisproject.controller |
| Modifier and Type | Method and Description |
|---|---|
protected IrisController |
SplashActivity.createController(android.content.Intent intent) |
protected IrisController |
EditProblemActivity.createController(android.content.Intent intent) |
protected IrisController |
ViewProblemActivity.createController(android.content.Intent intent) |
protected abstract IrisController |
IrisActivity.createController(android.content.Intent intent)
Initialize IrisController with an Intent (same Intent used to get this IrisActivity
up and running).
|
protected IrisController |
ViewProfileActivity.createController(android.content.Intent intent) |
protected IrisController |
EditProfileActivity.createController(android.content.Intent intent) |
protected IrisController |
RegisterActivity.createController(android.content.Intent intent) |
| Modifier and Type | Class and Description |
|---|---|
class |
AddBodyPhotoController |
class |
AddPatientController
AddPatientController is responsible for executing AddPatientTask which will update the given
Care Provider and corresponding Patient to hold each other's IDs in the database
|
class |
AddProblemController
AddProblemController has methods to allow our AddProblemActivity
to interact with the database by POST requesting new problems to it
|
class |
AddRecordController
AddRecordController handles the models within the
AddRecordActivity form.
|
class |
BodyPhotoListController
BodyPhotoListController handles the modifications and queries
of body photos to be displayed on BodyPhotoListActivity
|
class |
DeleteProblemController
DeleteProblemController has methods to allow DeleteProblemActivity
to interact with the database to delete problems.
|
class |
EditProblemController
Controller that submits the edited problem to the database
Called from EditProblemActivity
|
class |
EditProfileController
EditProfileController is used by EditProfileActivity to update the User's profile into the DB
|
class |
EditRecordController
Controller for editing a Record
|
class |
GetAllGeoLocationsController
AllGeolocationsController collects all record's geolocations and record titles.
|
class |
LoginController
LoginController helps the activity interact with the database
by separating its concern of handling the asynchronous calls
to authenticate fields
|
class |
PatientListController
PatientListController is responsible for getting a Care Provider's list of Patients from the database
|
class |
ProblemController
Controller that gets the problem from the database
Called from ViewProblemActivity
|
class |
ProblemListController
ProblemListController allows the Activity/Model to interact with each other
without explicitly mutating each other.
|
class |
RecordController
RecordController allows communication between the Record Model and
the Record Activity
|
class |
RecordListController
Controller for RecordListActivity
|
class |
RecordPhotoListController
RecordPhotoListController's main purpose is to return a list of
all record photos associated with a problem
|
class |
RegisterController
Controller for making a new User
|


public interface RunGraphRequestOrBuilder
extends org.nd4j.shade.protobuf.MessageOrBuilder
| Modifier and Type | Method and Description |
|---|---|
boolean |
getCreateWorkerSessionCalled()
Set to true if `CreateWorkerSession` was called for `session_handle`.
|
ExecutorOpts |
getExecOpts()
Options for this step.
|
ExecutorOptsOrBuilder |
getExecOptsOrBuilder()
Options for this step.
|
String |
getGraphHandle()
REQUIRED: graph_handle must be returned by a RegisterGraph call
to the same WorkerService.
|
org.nd4j.shade.protobuf.ByteString |
getGraphHandleBytes()
REQUIRED: graph_handle must be returned by a RegisterGraph call
to the same WorkerService.
|
boolean |
getIsLastPartialRun()
True if this is the last partial run request in a sequence of requests.
|
boolean |
getIsPartial()
True if the RunGraphRequest is a partial run request.
|
String |
getRecvKey(int index)
repeated string recv_key = 4; |
org.nd4j.shade.protobuf.ByteString |
getRecvKeyBytes(int index)
repeated string recv_key = 4; |
int |
getRecvKeyCount()
repeated string recv_key = 4; |
List<String> |
getRecvKeyList()
repeated string recv_key = 4; |
NamedTensorProto |
getSend(int index)
Runs the graph.
|
int |
getSendCount()
Runs the graph.
|
List<NamedTensorProto> |
getSendList()
Runs the graph.
|
NamedTensorProtoOrBuilder |
getSendOrBuilder(int index)
Runs the graph.
|
List<? extends NamedTensorProtoOrBuilder> |
getSendOrBuilderList()
Runs the graph.
|
String |
getSessionHandle()
session_handle is the master-generated unique id for this session.
|
org.nd4j.shade.protobuf.ByteString |
getSessionHandleBytes()
session_handle is the master-generated unique id for this session.
|
long |
getStepId()
A unique ID to distinguish different runs of the same graph.
|
boolean |
getStoreErrorsInResponseBody()
If true then some errors, e.g., execution errors that have long
error messages, may return an OK RunGraphResponse with the actual
error saved in the status_code/status_error_message fields of the
response body.
|
boolean |
hasExecOpts()
Options for this step.
|
findInitializationErrors, getAllFields, getDefaultInstanceForType, getDescriptorForType, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof
String getSessionHandle()
session_handle is the master-generated unique id for this session. If session_handle is non-empty, it must be the same as used when registering the graph. If it is empty, a single global namespace is used to search for the graph_handle.
string session_handle = 8;
org.nd4j.shade.protobuf.ByteString getSessionHandleBytes()
session_handle is the master-generated unique id for this session. If session_handle is non-empty, it must be the same as used when registering the graph. If it is empty, a single global namespace is used to search for the graph_handle.
string session_handle = 8;
boolean getCreateWorkerSessionCalled()
Set to true if `CreateWorkerSession` was called for `session_handle`.
bool create_worker_session_called = 10;
String getGraphHandle()
REQUIRED: graph_handle must be returned by a RegisterGraph call to the same WorkerService.
string graph_handle = 1;
org.nd4j.shade.protobuf.ByteString getGraphHandleBytes()
REQUIRED: graph_handle must be returned by a RegisterGraph call to the same WorkerService.
string graph_handle = 1;
long getStepId()
A unique ID to distinguish different runs of the same graph. The master generates a global unique `step_id` to distinguish different runs of the graph computation. Subgraphs communicate (e.g., send/recv ops) with each other using `step_id` to distinguish tensors generated by different runs.
int64 step_id = 2;
boolean hasExecOpts()
Options for this step.
.tensorflow.ExecutorOpts exec_opts = 5;
ExecutorOpts getExecOpts()
Options for this step.
.tensorflow.ExecutorOpts exec_opts = 5;
ExecutorOptsOrBuilder getExecOptsOrBuilder()
Options for this step.
.tensorflow.ExecutorOpts exec_opts = 5;
List<NamedTensorProto> getSendList()
Runs the graph. Sends the tensors in "send" into the graph before the run and fetches the keys into `RunGraphResponse.recv` after the run.
repeated .tensorflow.NamedTensorProto send = 3;
NamedTensorProto getSend(int index)
Runs the graph. Sends the tensors in "send" into the graph before the run and fetches the keys into `RunGraphResponse.recv` after the run.
repeated .tensorflow.NamedTensorProto send = 3;
int getSendCount()
Runs the graph. Sends the tensors in "send" into the graph before the run and fetches the keys into `RunGraphResponse.recv` after the run.
repeated .tensorflow.NamedTensorProto send = 3;
List<? extends NamedTensorProtoOrBuilder> getSendOrBuilderList()
Runs the graph. Sends the tensors in "send" into the graph before the run and fetches the keys into `RunGraphResponse.recv` after the run.
repeated .tensorflow.NamedTensorProto send = 3;
NamedTensorProtoOrBuilder getSendOrBuilder(int index)
Runs the graph. Sends the tensors in "send" into the graph before the run and fetches the keys into `RunGraphResponse.recv` after the run.
repeated .tensorflow.NamedTensorProto send = 3;
int getRecvKeyCount()
repeated string recv_key = 4;
String getRecvKey(int index)
repeated string recv_key = 4;
org.nd4j.shade.protobuf.ByteString getRecvKeyBytes(int index)
repeated string recv_key = 4;
boolean getIsPartial()
True if the RunGraphRequest is a partial run request.
bool is_partial = 6;
boolean getIsLastPartialRun()
True if this is the last partial run request in a sequence of requests.
bool is_last_partial_run = 7;
boolean getStoreErrorsInResponseBody()
If true then some errors, e.g., execution errors that have long error messages, may return an OK RunGraphResponse with the actual error saved in the status_code/status_error_message fields of the response body. This is a workaround since the RPC subsystem may truncate long metadata messages.
bool store_errors_in_response_body = 9;
Copyright © 2020. All rights reserved.


- IActivationFunction - Interface in edu.packt.neuralnet.math
-
This interface represents the activation function applicable to the neural
network.
- IActivationFunction.ActivationFunctionENUM - Enum in edu.packt.neuralnet.math
-
This enumeration lists some of the common used activation functions.
- IdentityMatrix - Class in edu.packt.neuralnet.math
-
This class generates an identity matrix
- IdentityMatrix(int) - Constructor for class edu.packt.neuralnet.math.IdentityMatrix
-
IdentityMatrix constructor
- indexmax(double[]) - Static method in class edu.packt.neuralnet.math.ArrayOperations
-
Gets the maximum value index of an array of real numbers
- indexmin(double[]) - Static method in class edu.packt.neuralnet.math.ArrayOperations
-
Gets the minimum value index of an array of real numbers
- init(WeightInitialization) - Method in class edu.packt.neuralnet.InputLayer
-
init
This method initializes all neurons of this layer
- init() - Method in class edu.packt.neuralnet.InputNeuron
-
init
Method for initialization of the input neuron, it just adds the weights
with 1's values and a 0 at the bias
- init() - Method in class edu.packt.neuralnet.Neuron
-
init
This method initializes the neuron by setting randomly its weights
- init(WeightInitialization) - Method in class edu.packt.neuralnet.Neuron
-
- initialRadius - Variable in class edu.packt.neuralnet.som.CompetitiveLayer
-
- inputData - Variable in class edu.packt.neuralnet.data.NeuralDataSet
-
- InputLayer - Class in edu.packt.neuralnet
-
InputLayer
This class extends from NeuralLayer and represents the input layer of the
Neural Network
- InputLayer(NeuralNet, int) - Constructor for class edu.packt.neuralnet.InputLayer
-
InputLayer constructor
- inputNames - Variable in class edu.packt.neuralnet.data.NeuralDataSet
-
- InputNeuron - Class in edu.packt.neuralnet
-
InputNeuron
This class inherits from Neuron, since it is a special case for a Neuron,
which is at the Neural Network Input Layer
- InputNeuron() - Constructor for class edu.packt.neuralnet.InputNeuron
-
InputNeuron constructor
- inputNorm - Variable in class edu.packt.neuralnet.data.NeuralDataSet
-
- inverse() - Method in class edu.packt.neuralnet.math.Matrix
-
- inverse(Matrix) - Static method in class edu.packt.neuralnet.math.Matrix
-
- isBiasActive() - Method in class edu.packt.neuralnet.NeuralLayer
-
- isBiasActive() - Method in class edu.packt.neuralnet.NeuralNet
-
- isInIntArray(int[], int) - Static method in class edu.packt.neuralnet.math.ArrayOperations
-
Checks if value is contained into integer array


Const BuiltinColor
BuiltinColor: object
BLACK
BLACK: [number, number, number] = [0, 0, 0] as Color
BLUE
BLUE: [number, number, number] = [0x00, 0x00, 0x1f] as Color
CLEAR
CLEAR: [number, number, number] = [0x00, 0x00, 0x00] as Color
CYAN
CYAN: [number, number, number] = [0x00, 0x1f, 0x1f] as Color
GRAY
GRAY: [number, number, number] = [0x0f, 0x0f, 0x0f] as Color
GREEN
GREEN: [number, number, number] = [0x00, 0x0f, 0x00] as Color
MAGENTA
MAGENTA: [number, number, number] = [0x1f, 0x00, 0x1f] as Color
MAROON
MAROON: [number, number, number] = [0x0f, 0x00, 0x00] as Color
NAVY
NAVY: [number, number, number] = [0x00, 0x00, 0x0f] as Color
OLIVE
OLIVE: [number, number, number] = [0x0f, 0x0f, 0x00] as Color
PURPLE
PURPLE: [number, number, number] = [0x0f, 0x00, 0x0f] as Color
RED
RED: [number, number, number] = [0x1f, 0x00, 0x00] as Color
RIME
RIME: [number, number, number] = [0x00, 0x1f, 0x00] as Color
SILVER
SILVER: [number, number, number] = [0x17, 0x17, 0x17] as Color
TEAL
TEAL: [number, number, number] = [0x00, 0x0f, 0x0f] as Color
WHITE
WHITE: [number, number, number] = [0x1f, 0x1f, 0x1f] as Color
YELLOW
YELLOW: [number, number, number] = [0x1f, 0x1f, 0x00] as Color
Const CHARACTER_MAP
CHARACTER_MAP: object
: string = "00000:00000:00000:00000:00000:"
!
!: string = "09000:09000:09000:00000:09000:"
"
": string = "09090:09090:00000:00000:00000:"
#
#: string = "09090:99999:09090:99999:09090:"
$
$: string = "09990:99009:09990:90099:09990:"
%
%: string = "99009:90090:00900:09009:90099:"
&
&: string = "09900:90090:09900:90090:09909:"
'
': string = "09000:09000:00000:00000:00000:"
(
(: string = "00900:09000:09000:09000:00900:"
)
): string = "09000:00900:00900:00900:09000:"
*
*: string = "00000:09090:00900:09090:00000:"
+
+: string = "00000:00900:09990:00900:00000:"
,
,: string = "00000:00000:00000:00900:09000:"
-
-: string = "00000:00000:09990:00000:00000:"
.
.: string = "00000:00000:00000:09000:00000:"
/
/: string = "00009:00090:00900:09000:90000:"
0
0: string = "09900:90090:90090:90090:09900:"
1
1: string = "00900:09900:00900:00900:09990:"
2
2: string = "99900:00090:09900:90000:99990:"
3
3: string = "99990:00090:00900:90090:09900:"
4
4: string = "00990:09090:90090:99999:00090:"
5
5: string = "99999:90000:99990:00009:99990:"
6
6: string = "00090:00900:09990:90009:09990:"
7
7: string = "99999:00090:00900:09000:90000:"
8
8: string = "09990:90009:09990:90009:09990:"
9
9: string = "09990:90009:09990:00900:09000:"
:
:: string = "00000:09000:00000:09000:00000:"
;
;: string = "00000:00900:00000:00900:09000:"
<
<: string = "00090:00900:09000:00900:00090:"
=
=: string = "00000:09990:00000:09990:00000:"
>
>: string = "09000:00900:00090:00900:09000:"
?
?: string = "09990:90009:00990:00000:00900:"
@
@: string = "09990:90009:90909:90099:09900:"
A
A: string = "09900:90090:99990:90090:90090:"
B
B: string = "99900:90090:99900:90090:99900:"
C
C: string = "09990:90000:90000:90000:09990:"
D
D: string = "99900:90090:90090:90090:99900:"
E
E: string = "99990:90000:99900:90000:99990:"
F
F: string = "99990:90000:99900:90000:90000:"
G
G: string = "09990:90000:90099:90009:09990:"
H
H: string = "90090:90090:99990:90090:90090:"
I
I: string = "99900:09000:09000:09000:99900:"
J
J: string = "99999:00090:00090:90090:09900:"
K
K: string = "90090:90900:99000:90900:90090:"
L
L: string = "90000:90000:90000:90000:99990:"
M
M: string = "90009:99099:90909:90009:90009:"
N
N: string = "90009:99009:90909:90099:90009:"
O
O: string = "09900:90090:90090:90090:09900:"
P
P: string = "99900:90090:99900:90000:90000:"
Q
Q: string = "09900:90090:90090:09900:00990:"
R
R: string = "99900:90090:99900:90090:90009:"
S
S: string = "09990:90000:09900:00090:99900:"
T
T: string = "99999:00900:00900:00900:00900:"
U
U: string = "90090:90090:90090:90090:09900:"
V
V: string = "90009:90009:90009:09090:00900:"
W
W: string = "90009:90009:90909:99099:90009:"
X
X: string = "90090:90090:09900:90090:90090:"
Y
Y: string = "90009:09090:00900:00900:00900:"
Z
Z: string = "99990:00900:09000:90000:99990:"
[
[: string = "09990:09000:09000:09000:09990:"
\
\: string = "90000:09000:00900:00090:00009:"
]
]: string = "09990:00090:00090:00090:09990:"
^
^: string = "00900:09090:00000:00000:00000:"
_
_: string = "00000:00000:00000:00000:99999:"
`
`: string = "09000:00900:00000:00000:00000:"
a
a: string = "00000:09990:90090:90090:09999:"
b
b: string = "90000:90000:99900:90090:99900:"
c
c: string = "00000:09990:90000:90000:09990:"
d
d: string = "00090:00090:09990:90090:09990:"
e
e: string = "09900:90090:99900:90000:09990:"
f
f: string = "00990:09000:99900:09000:09000:"
g
g: string = "09990:90090:09990:00090:09900:"
h
h: string = "90000:90000:99900:90090:90090:"
i
i: string = "09000:00000:09000:09000:09000:"
j
j: string = "00090:00000:00090:00090:09900:"
k
k: string = "90000:90900:99000:90900:90090:"
l
l: string = "09000:09000:09000:09000:00990:"
m
m: string = "00000:99099:90909:90009:90009:"
n
n: string = "00000:99900:90090:90090:90090:"
o
o: string = "00000:09900:90090:90090:09900:"
p
p: string = "00000:99900:90090:99900:90000:"
q
q: string = "00000:09990:90090:09990:00090:"
r
r: string = "00000:09990:90000:90000:90000:"
s
s: string = "00000:00990:09000:00900:99000:"
t
t: string = "09000:09000:09990:09000:00999:"
u
u: string = "00000:90090:90090:90090:09999:"
v
v: string = "00000:90009:90009:09090:00900:"
w
w: string = "00000:90009:90009:90909:99099:"
x
x: string = "00000:90090:09900:09900:90090:"
y
y: string = "00000:90009:09090:00900:99000:"
z
z: string = "00000:99990:00900:09000:99990:"
{
{: string = "00990:00900:09900:00900:00990:"
|
|: string = "09000:09000:09000:09000:09000:"
}
}: string = "99000:09000:09900:09000:99000:"
~
~: string = "00000:00000:09900:00099:00000:"


The overview page
Watch a Movie
Play a Game
Stream your music where you want
Reboot the system
Still not a device connected here! Scan this code with your phone to get the control of the ship!


- NAME
- msgcat - Tcl message catalog
- SYNOPSIS
- package require Tcl 8.2
- package require msgcat 1.3.4
- ::msgcat::mc src-string ?arg arg ...?
- ::msgcat::mcmax ?src-string src-string ...?
- ::msgcat::mclocale ?newLocale?
- ::msgcat::mcpreferences
- ::msgcat::mcload dirname
- ::msgcat::mcset locale src-string ?translate-string?
- ::msgcat::mcmset locale src-trans-list
- ::msgcat::mcunknown locale src-string
- DESCRIPTION
- COMMANDS
- ::msgcat::mc src-string ?arg arg ...?
- ::msgcat::mcmax ?src-string src-string ...?
- ::msgcat::mclocale ?newLocale?
- ::msgcat::mcpreferences
- ::msgcat::mcload dirname
- ::msgcat::mcset locale src-string ?translate-string?
- ::msgcat::mcmset locale src-trans-list
- ::msgcat::mcunknown locale src-string
- LOCALE SPECIFICATION
- NAMESPACES AND MESSAGE CATALOGS
- LOCATION AND FORMAT OF MESSAGE FILES
- RECOMMENDED MESSAGE SETUP FOR PACKAGES
- POSITIONAL CODES FOR FORMAT AND SCAN COMMANDS
- CREDITS
- SEE ALSO
- KEYWORDS
msgcat - Tcl message catalog
package require Tcl 8.2
package require msgcat 1.3.4
::msgcat::mc src-string ?arg arg ...?
::msgcat::mcmax ?src-string src-string ...?
::msgcat::mclocale ?newLocale?
::msgcat::mcpreferences
::msgcat::mcload dirname
::msgcat::mcset locale src-string ?translate-string?
::msgcat::mcmset locale src-trans-list
::msgcat::mcunknown locale src-string
The msgcat package provides a set of functions
that can be used to manage multi-lingual user interfaces.
Text strings are defined in a ``message catalog'' which
is independent from the application, and
which can be edited or localized without modifying
the application source code. New languages
or locales are provided by adding a new file to
the message catalog.
Use of the message catalog is optional by any application
or package, but is encouraged if the application or package
wishes to be enabled for multi-lingual applications.
- ::msgcat::mc src-string ?arg arg ...?
-
Returns a translation of src-string according to the
user's current locale. If additional arguments past src-string
are given, the format command is used to substitute the
additional arguments in the translation of src-string.
::msgcat::mc will search the messages defined
in the current namespace for a translation of src-string; if
none is found, it will search in the parent of the current namespace,
and so on until it reaches the global namespace. If no translation
string exists, ::msgcat::mcunknown is called and the string
returned from ::msgcat::mcunknown is returned.
::msgcat::mc is the main function used to localize an
application. Instead of using an English string directly, an
application can pass the English string through ::msgcat::mc and
use the result. If an application is written for a single language in
this fashion, then it is easy to add support for additional languages
later simply by defining new message catalog entries.
- ::msgcat::mcmax ?src-string src-string ...?
-
Given several source strings, ::msgcat::mcmax returns the length
of the longest translated string. This is useful when designing
localized GUIs, which may require that all buttons, for example, be a
fixed width (which will be the width of the widest button).
- ::msgcat::mclocale ?newLocale?
-
This function sets the locale to newLocale. If newLocale
is omitted, the current locale is returned, otherwise the current locale
is set to newLocale. msgcat stores and compares the locale in a
case-insensitive manner, and returns locales in lowercase.
The initial locale is determined by the locale specified in
the user's environment. See LOCALE SPECIFICATION
below for a description of the locale string format.
- ::msgcat::mcpreferences
-
Returns an ordered list of the locales preferred by
the user, based on the user's language specification.
The list is ordered from most specific to least
preference. The list is derived from the current
locale set in msgcat by ::msgcat::mclocale, and
cannot be set independently. For example, if the
current locale is en_US_funky, then ::msgcat::mcpreferences
returns {en_US_funky en_US en}.
- ::msgcat::mcload dirname
-
Searches the specified directory for files that match
the language specifications returned by ::msgcat::mcpreferences
(note that these are all lowercase), extended by the file
extension ``.msg''. Each matching file is
read in order, assuming a UTF-8 encoding. The file contents are
then evaluated as a Tcl script. This means that Unicode characters
may be present in the message file either directly in their UTF-8
encoded form, or by use of the backslash-u quoting recognized by Tcl
evaluation. The number of message files which matched the specification
and were loaded is returned.
- ::msgcat::mcset locale src-string ?translate-string?
-
Sets the translation for src-string to translate-string
in the specified locale and the current namespace. If
translate-string is not specified, src-string is used
for both. The function returns translate-string.
- ::msgcat::mcmset locale src-trans-list
-
Sets the translation for multiple source strings in
src-trans-list in the specified locale and the current
namespace.
src-trans-list must have an even number of elements and is in
the form {src-string translate-string ?src-string
translate-string ...?} ::msgcat::mcmset can be significantly
faster than multiple invocations of ::msgcat::mcset. The function
returns the number of translations set.
- ::msgcat::mcunknown locale src-string
-
This routine is called by ::msgcat::mc in the case when
a translation for src-string is not defined in the
current locale. The default action is to return
src-string. This procedure can be redefined by the
application, for example to log error messages for each unknown
string. The ::msgcat::mcunknown procedure is invoked at the
same stack context as the call to ::msgcat::mc. The return value
of ::msgcat::mcunknown is used as the return value for the call
to ::msgcat::mc.
The locale is specified to msgcat by a locale string
passed to ::msgcat::mclocale.
The locale string consists of
a language code, an optional country code, and an optional
system-specific code, each separated by ``_''. The country and language
codes are specified in standards ISO-639 and ISO-3166.
For example, the locale ``en'' specifies English and ``en_US'' specifies
U.S. English.
When the msgcat package is first loaded, the locale is initialized
according to the user's environment. The variables env(LC_ALL),
env(LC_MESSAGES), and env(LANG) are examined in order.
The first of them to have a non-empty value is used to determine the
initial locale. The value is parsed according to the XPG4 pattern
language[_country][.codeset][@modifier]
to extract its parts. The initial locale is then set by calling
::msgcat::mclocale with the argument
language[_country][_modifier]
On Windows, if none of those environment variables is set, msgcat will
attempt to extract locale information from the
registry. If all these attempts to discover an initial locale
from the user's environment fail, msgcat defaults to an initial
locale of ``C''.
When a locale is specified by the user, a ``best match'' search is
performed during string translation. For example, if a user specifies
en_GB_Funky, the locales ``en_GB_Funky'', ``en_GB'', and ``en'' are
searched in order until a matching translation string is found. If no
translation string is available, then ::msgcat::mcunknown is
called.
Strings stored in the message catalog are stored relative
to the namespace from which they were added. This allows
multiple packages to use the same strings without fear
of collisions with other packages. It also allows the
source string to be shorter and less prone to typographical
error.
For example, executing the code
::msgcat::mcset en hello "hello from ::"
namespace eval foo {
::msgcat::mcset en hello "hello from ::foo"
}
puts [::msgcat::mc hello]
namespace eval foo {puts [::msgcat::mc hello]}
will print
hello from ::
hello from ::foo
When searching for a translation of a message, the
message catalog will search first the current namespace,
then the parent of the current namespace, and so on until
the global namespace is reached. This allows child namespaces
to "inherit" messages from their parent namespace.
For example, executing (in the ``en'' locale) the code
::msgcat::mcset en m1 ":: message1"
::msgcat::mcset en m2 ":: message2"
::msgcat::mcset en m3 ":: message3"
namespace eval ::foo {
::msgcat::mcset en m2 "::foo message2"
::msgcat::mcset en m3 "::foo message3"
}
namespace eval ::foo::bar {
::msgcat::mcset en m3 "::foo::bar message3"
}
namespace import ::msgcat::mc
puts "[mc m1]; [mc m2]; [mc m3]"
namespace eval ::foo {puts "[mc m1]; [mc m2]; [mc m3]"}
namespace eval ::foo::bar {puts "[mc m1]; [mc m2]; [mc m3]"}
will print
:: message1; :: message2; :: message3
:: message1; ::foo message2; ::foo message3
:: message1; ::foo message2; ::foo::bar message3
Message files can be located in any directory, subject
to the following conditions:
- [1]
-
All message files for a package are in the same directory.
- [2]
-
The message file name is a msgcat locale specifier (all lowercase)
followed by ``.msg''. For example:
es.msg -- spanish
en_gb.msg -- United Kingdom English
- [3]
-
The file contains a series of calls to mcset and
mcmset, setting the necessary translation strings
for the language, likely enclosed in a namespace eval
so that all source strings are tied to the namespace of
the package. For example, a short es.msg might contain:
namespace eval ::mypackage {
::msgcat::mcset es "Free Beer!" "Cerveza Gracias!"
}
If a package is installed into a subdirectory of the
tcl_pkgPath and loaded via package require, the
following procedure is recommended.
- [1]
-
During package installation, create a subdirectory
msgs under your package directory.
- [2]
-
Copy your *.msg files into that directory.
- [3]
-
Add the following command to your package
initialization script:
# load language files, stored in msgs subdirectory
::msgcat::mcload [file join [file dirname [info script]] msgs]
It is possible that a message string used as an argument
to format might have positionally dependent parameters that
might need to be repositioned. For example, it might be
syntactically desirable to rearrange the sentence structure
while translating.
format "We produced %d units in location %s" $num $city
format "In location %s we produced %d units" $city $num
This can be handled by using the positional
parameters:
format "We produced %1\$d units in location %2\$s" $num $city
format "In location %2\$s we produced %1\$d units" $num $city
Similarly, positional parameters can be used with scan to
extract values from internationalized strings.
The message catalog code was developed by Mark Harrison.
format, scan, namespace, package
internationalization, i18n, localization, l10n, message, text, translation
Copyright © 1998 Mark Harrison.
Copyright © 1995-1997 Roger E. Critchlow Jr.


Sylvia is a sophomore currently at University of California, San Diego. She is an Interdisciplinary Computing and the Arts major under Visual Arts and a Computer Science minor. Sylvia is very curious and interested in the relationship among modern technology, arts and science.
This is a featured art installation at Sun God festival at UC San Diego, 2014. Sylvia led the project to make human-size tetris blocks that can light up at night. The tetris blocks were made out of cardboard boxes, colored with spray paints and sealed with cellophane paper on the side. The blocks were also incorporated with LED light strips. This work was commissioned by Associated Student Concerts and Event.
This is a series of paintings depicting the Chinese culture that Sylvia has exposed to in her early childhood.
Sylvia has attended the Cornell Summer School of Architecture in 2012. These are some of her resulted work.


Kim Halskov Madsen and Peter H Aiken
They start with a design critique of a VHS and progress to the design of a test harness which explores experimenting with co-design of interfaces in real time.  Is this an example of people thinking that UI design is the same as software design. Did it actually record video!? If not, there may be many hidden aspects which weren't featured. How much does this matter? How can this be mitigated?
They use a 'grey shade' for hiding complexity, later thought of as 'greyed out' - possible link to flight instrument where various things can be disclosed and offered in different circumstances, and more information is not necessarily good (also mentioned by John Cross related to his Medical instruments - face to face at Manteigas event).
They explicitly discuss the link to 'Scandinavian' workplace democracy - the precursor of Participatory Design.
Storyboards,
Storyboard prototyping
"Both theoretical arguments and empirical evidence indicate a strong cause-and-effect relationship between development approaches permitting realistic conditions for prototype evaluation and successful interface development efforts."
"Storyboard prototyping can be defined as
' . . . a technique designed to generate consensus and closure via a
tangible, interactive systems concept. It permits users to participate in
the requirements validation process, and it provides an audit trail of
the requirements analysis process . . . . The presentation of the
interactive storyboard to users and managers is intended to evoke
comments and criticisms' [13, p. 39]"
"Delay associated with production of the next version of the storyboard is a source of frustration for storyboard developers. Too much time between user review sessions leads to loss of cognitive momentum and can introduce errors to and perpetuate omissions in the development process."
"[Cooperative Interactive Storyboard Prototyping] empowers users with
tools and techniques encouraging them to interactively contribute to
real-time, storyboard use, evalua-
tion and modification. Crucial here is the concept of the role of the
user changing from reviewer to codeveloper."
"CISP also provides situations in which users can evaluate the storyboard prototypes under realistic circumstances and modify them in real time."
"According to Bodker and Gronbaek, a major obstacle is the developer's limited ability to respond smoothly to user ideas or requests for prototype changes during design sessions [6]."


Review: ANYWHERE BUT HERE
Review by: Joy Wyse the SILVER Screen Critic
Starring: Susan Sarandon, Natalie Portman
Director: Wayne Wang
Anywhere But Here certainly qualifies as a chick flick. I doubt that guys can relate to the main characters. Susan Sarandon and Natalie Portman portray Adele and Ann August, mother and daughter living through a very difficult age, the three years from Ann's 14th. Birthday, until she heads for college at 17.  She sincerely wants what's best for Ann, although Ann doesn't want it…at the time.  It's difficult for a parent not to embarrass a child. Either you dress too drab or too flashy. You're too protective, or you don't care enough. That's the basic storyline of Anywhere But Here; mother and daughter learning to accept each other. Strangely, their most profound advisor is a traffic cop. Most of the other characters are little more than vignettes but each and every one is delivered with believability. I particularly liked the reference made to grunion hunting. Yes, there really is such a thing. We aren't talking about Snipe hunting or submarine races. Some of my fondest childhood memories are the nights that my family went grunion hunting. This is a sport limited to the beaches of Southern California. During the summer, when there's a full moon, the grunions spawn on the beaches. They come in on one wave, spin into the sand on their tails laying their eggs, and go out with the next wave. The trick is to catch them with your hands in between the two waves without being knocked down by the waves yourself. Warning! They are very slippery. If you ever have the chance, try it. As for the movie, you can try it, too. It's not bad, but it's not that special. Because of the acting, I give it a B. It wouldn't bother me to see it again, but if I don't…no big deal.
See you at the movies.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


所有类
-
所有类 接口概要 类概要 枚举概要 类 说明 Answer an answer is calculated by our system, which contains start/end station, total time and total distance of a ridingAnswerTest AvoidPlusStation policy: avoid plus station: like minimal walking distance but return station cannot be a “plus” stationAvoidPlusStationTest Bicycle abstract class Bicycle contains 2 concrete classes: Ebike and Mbike.BicycleTest BikeVisitable Bike visitable of visitor patternCard build Card to get different kinds of calculation for users.CardTest CardType three kinds of cardCardVisitor visitor pattern to calculate cost of each riding for different card and durationCLUI ClUI with basic useful orders.CLUITest CurrentDistribution this class hold station distribution in current time, in order that we can easily get station availabilityCurrentDistributionTest EBike electric bicycleEBikeTest FastPathToDestination policy: fast path to destination: the pickup station is chosen so that the combined walk+ride delay to the destination point d is minimal whereas the return station is chosen so that the walking distance to destination point d is minimalFastPathToDestinationTest GPS location for users and stationsMap A map regroups all the stations.MapTest MapTest2 MBike mechanic bikeMBikeTest MinWalDis policy: minimal walking distance:the pickup and return stations are chosen so that the /* total walking distance of the tripMinWalDisTest MostUsedComparator comparator: with it we can sort stations to list the most used station on the top.NoCardVisitor to calculate cost of a riding with no cardNoCardVisitorTest Observable observable for end stations' condition so that users can be notifiedObservableStation concrete observable station to implement concrete methodsObserver observer pattern to notify users of availability of endStationOngoingRide generate a "half riding" with only starting informationOngoingRideTest PlanningAlgo different policies to calculate and return answers of requestsPreferPlusStation Policy: prefer plus station: with this policy the return station should be a “plus” station (given a “plus” station no further away than 10% of the distance of the closest station to the destination location exists).PreferPlusStationTest PreservationOfUniformity with this policy the choice of the source and destination station is affected by the number of available bikes (at source station) and free slots (at destination).PreservationOfUniformityTest Record a record can be easily noted by systemRecordTest Request a request sent by a user with its location, bike type preference, policy preference and send time so that our system can respond to him an answerRequestTest Ride a ride is a whole order which can be easily collected and recorded by systemServer This class models the behavior of a real server, which is to handle the rent and the return(restore) of the bikes.ServerTest Slot slot in station, holding a bike or notSolution a solution is corresponding to a request with all necessary informationSolutionTest Station Station holds several slots where users can rend bikes.StationTest UseCase Rental of a bike 1. a user (card holder or not) rent a bike of a given type from a given station at a given moment in time 2. the user returns the bike to another station after a given duration (expressed in minutes). 3. the user get charged for the corresponding amount (possibly 0) and possibly receive a time-credit (possibly 0)UseCase1 simulate that a user apply for solutions with different policies, then accept this solution, and shut down the end station finally try to return back bike to this station.User a user can hold a card and rent bike.UserTest VlibreCard Vlibre Card, a kind of cardVlibreCardVisitor to calculate cost of a riding with vlibre cardVlibreCardVisitorTest VmaxCard Vmax Card, a kind of cardVmaxCardVisitor to calculate cost of a riding with Vmax cardVmaxCardVisitorTest