- All Known Subinterfaces:
SpiServer
Registration with the DB singleton
When a Database instance is created it can be registered with the DB
singleton (see DatabaseConfig.setRegister(boolean)
). The DB
singleton is essentially a map of Database's that have been registered
with it.
The Database can then be retrieved later via DB.byName(String)
.
The 'default' Database
One Database can be designated as the 'default' or 'primary' Database
(see DatabaseConfig.setDefaultServer(boolean)
.
Constructing a Database
Database's are constructed by the DatabaseFactory. They can be created
programmatically via DatabaseFactory.create(DatabaseConfig)
or they
can be automatically constructed on demand using configuration information in
the application.properties file.
Example: Get a Database
// Get access to the Human Resources Database
Database hrDatabase = DB.byName("hr");
// fetch contact 3 from the HR database
Contact contact = hrDatabase.find(Contact.class, new Integer(3));
contact.setStatus("INACTIVE"); ...
// save the contact back to the HR database
hrDatabase.save(contact);
Database vs DB API
Database provides additional API compared with DB. For example it provides more control over the use of Transactions that is not available in the DB API.
External Transactions: If you wanted to use transactions created externally to Ebean then Database provides additional methods where you can explicitly pass a transaction (that can be created externally).
Bypass ThreadLocal Mechanism: If you want to bypass the built in ThreadLocal transaction management you can use the createTransaction() method. Example: a single thread requires more than one transaction.
- See Also:
-
Method Summary
Modifier and TypeMethodDescriptionautoTune()
Return AutoTune which is used to control the AutoTune service at runtime.Return the BackgroundExecutor service for asynchronous processing of queries.Return the value of the Id property for a given bean.Set the Id value onto the bean converting the type of the id value if necessary.Return the BeanState for a given entity bean.Start a transaction with 'REQUIRED' semantics.beginTransaction
(io.ebean.annotation.TxIsolation isolation) Start a transaction additionally specifying the isolation level.beginTransaction
(TxScope scope) Start a transaction typically specifying REQUIRES_NEW or REQUIRED semantics.Return the manager of the server cache ("L2" cache).checkUniqueness
(Object bean) This method checks the uniqueness of a bean.checkUniqueness
(Object bean, Transaction transaction) Same ascheckUniqueness(Object)
.void
Commit the current transaction.createCallableSql
(String callableSql) Create a CallableSql to execute a given stored procedure.<T> CsvReader<T>
createCsvReader
(Class<T> beanType) Create a CsvReader for a given beanType.<T> T
createEntityBean
(Class<T> type) Create a new instance of T that is an EntityBean.<T> DtoQuery<T>
createNamedDtoQuery
(Class<T> dtoType, String namedQuery) Create a named Query for DTO beans.<T> Query<T>
createNamedQuery
(Class<T> beanType, String namedQuery) Create a named query.<T> Query<T>
createQuery
(Class<T> beanType) Create a query for an entity bean and synonym forfind(Class)
.<T> Query<T>
createQuery
(Class<T> beanType, String ormQuery) Parse the Ebean query language statement returning the query which can then be modified (add expressions, change order by clause, change maxRows, change fetch and select paths etc).Create a new transaction that is not held in TransactionThreadLocal.createTransaction
(io.ebean.annotation.TxIsolation isolation) Create a new transaction additionally specifying the isolation level.<T> Update<T>
createUpdate
(Class<T> beanType, String ormUpdate) Create a orm update where you will supply the insert/update or delete statement (rather than using a named one that is already defined using the @NamedUpdates annotation).Returns the current transaction or null if there is no current transaction in scope.Return the associated DataSource for this Database instance.int
Delete the bean given its type and id.int
delete
(Class<?> beanType, Object id, Transaction transaction) Delete the bean given its type and id with an explicit transaction.boolean
Delete the bean.boolean
delete
(Object bean, Transaction transaction) Delete the bean with an explicit transaction.int
deleteAll
(Class<?> beanType, Collection<?> ids) Delete several beans given their type and id values.int
deleteAll
(Class<?> beanType, Collection<?> ids, Transaction transaction) Delete several beans given their type and id values with an explicit transaction.int
deleteAll
(Collection<?> beans) Delete all the beans in the collection.int
deleteAll
(Collection<?> beans, Transaction transaction) Delete all the beans in the collection using an explicit transaction.int
deleteAllPermanent
(Class<?> beanType, Collection<?> ids) Delete permanent for several beans given their type and id values.int
deleteAllPermanent
(Class<?> beanType, Collection<?> ids, Transaction transaction) Delete permanent for several beans given their type and id values with an explicit transaction.int
deleteAllPermanent
(Collection<?> beans) Delete all the beans in the collection permanently without soft delete.int
deleteAllPermanent
(Collection<?> beans, Transaction transaction) Delete all the beans in the collection permanently without soft delete using an explicit transaction.int
deletePermanent
(Class<?> beanType, Object id) Delete permanent given the bean type and id.int
deletePermanent
(Class<?> beanType, Object id, Transaction transaction) Delete permanent given the bean type and id with an explicit transaction.boolean
deletePermanent
(Object bean) Delete a bean permanently without soft delete.boolean
deletePermanent
(Object bean, Transaction transaction) Delete a bean permanently without soft delete using an explicit transaction.Return a map of the differences between two objects of the same type.docStore()
Return the Document store.<T> List<T>
draftRestore
(Query<T> query) Restore the draft beans matching the query back to the live state.<T> List<T>
draftRestore
(Query<T> query, Transaction transaction) Restore the draft beans matching the query back to the live state.<T> T
draftRestore
(Class<T> beanType, Object id) Restore the draft bean back to the live state.<T> T
draftRestore
(Class<T> beanType, Object id, Transaction transaction) Restore the draft bean back to the live state.void
If the current transaction has already been committed do nothing otherwise rollback the transaction.int
execute
(CallableSql callableSql) For making calls to stored procedures.int
execute
(CallableSql callableSql, Transaction transaction) Execute explicitly passing a transaction.int
Execute a Sql Update Delete or Insert statement.int
execute
(SqlUpdate updSql, Transaction transaction) Execute explicitly passing a transaction.void
Execute a Runnable in a Transaction with an explicit scope.int
Execute a ORM insert update or delete statement using the current transaction.int
execute
(Update<?> update, Transaction transaction) Execute a ORM insert update or delete statement with an explicit transaction.void
Execute a Runnable in a Transaction with the default scope.<T> T
executeCall
(TxScope scope, Callable<T> callable) Execute a TxCallable in a Transaction with an explicit scope.<T> T
executeCall
(Callable<T> callable) Execute a TxCallable in a Transaction with the default scope.Return the ExpressionFactory for this database.extended()
Return the extended API for Database.void
externalModification
(String tableName, boolean inserted, boolean updated, boolean deleted) Inform Ebean that tables have been modified externally.<T> Filter<T>
Create a filter for sorting and filtering lists of entities locally without going back to the database.<T> Query<T>
Create a query for a type of entity bean.<T> T
Find a bean using its unique id.<T> T
find
(Class<T> beanType, Object id, Transaction transaction) Find a entity bean with an explicit transaction.<T> DtoQuery<T>
Create a Query for DTO beans.<T> Query<T>
findNative
(Class<T> beanType, String nativeSql) Create a query using native SQL.void
flush()
Flush the JDBC batch on the current transaction.void
Insert the bean.void
insert
(Object bean, Transaction transaction) Insert the bean with a transaction.void
insertAll
(Collection<?> beans) Insert a collection of beans.void
insertAll
(Collection<?> beans, Transaction transaction) Insert a collection of beans with an explicit transaction.json()
Return the JsonContext for reading/writing JSON.void
Load and lock the bean usingselect for update
.void
markAsDirty
(Object bean) Marks the entity bean as dirty.void
Merge the bean using the default merge options (no paths specified, default delete).void
merge
(Object bean, MergeOptions options) Merge the bean using the given merge options.void
merge
(Object bean, MergeOptions options, Transaction transaction) Merge the bean using the given merge options and a transaction.metaInfo()
Return the MetaInfoManager which is used to get meta data from the Database such as query execution statistics.name()
Return the name.Return the next unique identity value for a given bean type.io.ebean.annotation.Platform
platform()
Return the platform used for this database instance.Return the extended API intended for use by plugins.<T> List<T>
Publish the beans that match the query returning the resulting published beans.<T> List<T>
publish
(Query<T> query, Transaction transaction) Publish the beans that match the query returning the resulting published beans.<T> T
Publish a single bean given its type and id returning the resulting live bean.<T> T
publish
(Class<T> beanType, Object id, Transaction transaction) Publish a single bean given its type and id returning the resulting live bean.Return the associated read only DataSource for this Database instance (can be null).<T> T
Get a reference object.void
Refresh the values of a bean.void
refreshMany
(Object bean, String propertyName) Refresh a many property of an entity bean.void
register
(TransactionCallback transactionCallback) Register a TransactionCallback on the currently active transaction.void
Rollback the current transaction.void
Either Insert or Update the bean depending on its state.void
save
(Object bean, Transaction transaction) Insert or update a bean with an explicit transaction.int
Save all the beans.int
saveAll
(Collection<?> beans) Save all the beans in the collection.int
saveAll
(Collection<?> beans, Transaction transaction) Save all the beans in the collection with an explicit transaction.script()
Return a ScriptRunner for running SQL or DDL scripts.void
shutdown()
Shutdown the Database instance.void
shutdown
(boolean shutdownDataSource, boolean deregisterDriver) Shutdown the Database instance programmatically.<T> void
Sort the list in memory using the sortByClause which can contain a comma delimited list of property names and keywords asc, desc, nullsHigh and nullsLow.Look to execute a native sql query that does not return beans but instead returns SqlRow or direct access to ResultSet.Look to execute a native sql insert update or delete statement.void
Truncate the base tables for the given bean types.void
Truncate all the given tables.<T> UpdateQuery<T>
Create an Update query to perform a bulk update.void
Saves the bean using an update.void
update
(Object bean, Transaction transaction) Update a bean additionally specifying a transaction.void
updateAll
(Collection<?> beans) Update a collection of beans.void
updateAll
(Collection<?> beans, Transaction transaction) Update a collection of beans with an explicit transaction.validateQuery
(Query<T> query) Returns the set of properties/paths that are unknown (do not map to known properties or paths).
-
Method Details
-
shutdown
void shutdown()Shutdown the Database instance. -
shutdown
void shutdown(boolean shutdownDataSource, boolean deregisterDriver) Shutdown the Database instance programmatically.This method is not normally required. Ebean registers a shutdown hook and shuts down cleanly.
If the under underlying DataSource is the Ebean implementation then you also have the option of shutting down the DataSource and deregistering the JDBC driver.
- Parameters:
shutdownDataSource
- if true then shutdown the underlying DataSource if it is the Ebean DataSource implementation.deregisterDriver
- if true then deregister the JDBC driver if it is the Ebean DataSource implementation.
-
autoTune
AutoTune autoTune()Return AutoTune which is used to control the AutoTune service at runtime. -
dataSource
DataSource dataSource()Return the associated DataSource for this Database instance. -
readOnlyDataSource
DataSource readOnlyDataSource()Return the associated read only DataSource for this Database instance (can be null). -
name
String name()Return the name. This is used withDB.byName(String)
to get a Database that was registered with the DB singleton. -
expressionFactory
ExpressionFactory expressionFactory()Return the ExpressionFactory for this database. -
metaInfo
MetaInfoManager metaInfo()Return the MetaInfoManager which is used to get meta data from the Database such as query execution statistics. -
platform
io.ebean.annotation.Platform platform()Return the platform used for this database instance.Note many platforms have multiple specific platform types so often we want to get the base platform via
Platform.base()
.Platform platform = database.getPlatform().base(); if (platform == Platform.MYSQL) { // do MySql specific function }
- Returns:
- platform for this database instance
-
pluginApi
SpiServer pluginApi()Return the extended API intended for use by plugins. -
beanState
Return the BeanState for a given entity bean.This will return null if the bean is not an enhanced entity bean.
-
beanId
Return the value of the Id property for a given bean. -
beanId
Set the Id value onto the bean converting the type of the id value if necessary.For example, if the id value passed in is a String but ought to be a Long or UUID etc then it will automatically be converted.
- Parameters:
bean
- The entity bean to set the id value on.id
- The id value to set.
-
diff
Return a map of the differences between two objects of the same type.When null is passed in for b, then the 'OldValues' of a is used for the difference comparison.
-
createEntityBean
Create a new instance of T that is an EntityBean.Useful if you use BeanPostConstructListeners or @PostConstruct Annotations. In this case you should not use "new Bean...()". Making all bean constructors protected could be a good idea here.
-
createCsvReader
Create a CsvReader for a given beanType. -
update
Create an Update query to perform a bulk update.int rows = database .update(Customer.class) .set("status", Customer.Status.ACTIVE) .set("updtime", new Timestamp(System.currentTimeMillis())) .where() .gt("id", 1000) .update();
- Type Parameters:
T
- The type of entity bean- Parameters:
beanType
- The type of entity bean to update- Returns:
- The update query to use
-
createNamedQuery
Create a named query.For RawSql the named query is expected to be in ebean.xml.
- Type Parameters:
T
- The type of entity bean- Parameters:
beanType
- The type of entity beannamedQuery
- The name of the query- Returns:
- The query
-
createQuery
Create a query for an entity bean and synonym forfind(Class)
.- See Also:
-
createQuery
Parse the Ebean query language statement returning the query which can then be modified (add expressions, change order by clause, change maxRows, change fetch and select paths etc).Example
// Find order additionally fetching the customer, details and details.product name. String ormQuery = "fetch customer fetch details fetch details.product (name) where id = :orderId "; Query<Order> query = DB.createQuery(Order.class, ormQuery); query.setParameter("orderId", 2); Order order = query.findOne(); // This is the same as: Order order = DB.find(Order.class) .fetch("customer") .fetch("details") .fetch("detail.product", "name") .setId(2) .findOne();
- Type Parameters:
T
- The type of the entity bean- Parameters:
beanType
- The type of bean to fetchormQuery
- The Ebean ORM query- Returns:
- The query with expressions defined as per the parsed query statement
-
find
Create a query for a type of entity bean.You can use the methods on the Query object to specify fetch paths, predicates, order by, limits etc.
You then use findList(), findSet(), findMap() and findOne() to execute the query and return the collection or bean.
Note that a query executed by
Query.findList()
Query.findSet()
etc will execute against the same Database from which is was created.// Find order 2 specifying explicitly the parts of the object graph to // eagerly fetch. In this case eagerly fetch the associated customer, // details and details.product.name Order order = database.find(Order.class) .fetch("customer") .fetch("details") .fetch("detail.product", "name") .setId(2) .findOne(); // find some new orders ... with firstRow/maxRows List<Order> orders = database.find(Order.class) .where().eq("status", Order.Status.NEW) .setFirstRow(20) .setMaxRows(10) .findList();
-
findNative
Create a query using native SQL.The native SQL can contain named parameters or positioned parameters.
String sql = "select c.id, c.name from customer c where c.name like ? order by c.name"; Query<Customer> query = database.findNative(Customer.class, sql); query.setParameter(1, "Rob%"); List<Customer> customers = query.findList();
- Parameters:
beanType
- The type of entity bean to fetchnativeSql
- The SQL that can contain named or positioned parameters- Returns:
- The query to set parameters and execute
-
nextId
Return the next unique identity value for a given bean type.This will only work when a IdGenerator is on the bean such as for beans that use a DB sequence or UUID.
For DB's supporting getGeneratedKeys and sequences such as Oracle10 you do not need to use this method generally. It is made available for more complex cases where it is useful to get an ID prior to some processing.
-
filter
Create a filter for sorting and filtering lists of entities locally without going back to the database.This produces and returns a new list with the sort and filters applied.
Refer to
Filter
for an example of its use. -
sort
Sort the list in memory using the sortByClause which can contain a comma delimited list of property names and keywords asc, desc, nullsHigh and nullsLow.- asc - ascending order (which is the default)
- desc - Descending order
- nullsHigh - Treat null values as high/large values (which is the default)
- nullsLow- Treat null values as low/very small values
If you leave off any keywords the defaults are ascending order and treating nulls as high values.
Note that the sorting uses a Comparator and Collections.sort(); and does not invoke a DB query.
// find orders and their customers List<Order> list = database.find(Order.class) .fetch("customer") .order("id") .findList(); // sort by customer name ascending, then by order shipDate // ... then by the order status descending database.sort(list, "customer.name, shipDate, status desc"); // sort by customer name descending (with nulls low) // ... then by the order id database.sort(list, "customer.name desc nullsLow, id");
- Parameters:
list
- the list of entity beanssortByClause
- the properties to sort the list by
-
createUpdate
Create a orm update where you will supply the insert/update or delete statement (rather than using a named one that is already defined using the @NamedUpdates annotation).The orm update differs from the sql update in that it you can use the bean name and bean property names rather than table and column names.
An example:
// The bean name and properties - "topic","postCount" and "id" // will be converted into their associated table and column names String updStatement = "update topic set postCount = :pc where id = :id"; Update<Topic> update = database.createUpdate(Topic.class, updStatement); update.set("pc", 9); update.set("id", 3); int rows = update.execute(); System.out.println("rows updated:" + rows);
-
findDto
Create a Query for DTO beans.DTO beans are just normal bean like classes with public constructor(s) and setters. They do not need to be registered with DB before use.
- Type Parameters:
T
- The type of the DTO bean.- Parameters:
dtoType
- The type of the DTO bean the rows will be mapped into.sql
- The SQL query to execute.
-
createNamedDtoQuery
Create a named Query for DTO beans.DTO beans are just normal bean like classes with public constructor(s) and setters. They do not need to be registered with DB before use.
- Type Parameters:
T
- The type of the DTO bean.- Parameters:
dtoType
- The type of the DTO bean the rows will be mapped into.namedQuery
- The name of the query
-
sqlQuery
Look to execute a native sql query that does not return beans but instead returns SqlRow or direct access to ResultSet.Refer to
DtoQuery
for native sql queries returning DTO beans.Refer to
findNative(Class, String)
for native sql queries returning entity beans. -
sqlUpdate
Look to execute a native sql insert update or delete statement.Use this to execute a Insert Update or Delete statement. The statement will be native to the database and contain database table and column names.
See
SqlUpdate
for example usage.- Returns:
- The SqlUpdate instance to set parameters and execute
-
createCallableSql
Create a CallableSql to execute a given stored procedure. -
register
void register(TransactionCallback transactionCallback) throws javax.persistence.PersistenceException Register a TransactionCallback on the currently active transaction. If there is no currently active transaction then a PersistenceException is thrown.- Parameters:
transactionCallback
- The transaction callback to be registered with the current transaction.- Throws:
javax.persistence.PersistenceException
- If there is no currently active transaction
-
createTransaction
Transaction createTransaction()Create a new transaction that is not held in TransactionThreadLocal.You will want to do this if you want multiple Transactions in a single thread or generally use transactions outside of the TransactionThreadLocal management.
-
createTransaction
Create a new transaction additionally specifying the isolation level.Note that this transaction is NOT stored in a thread local.
-
beginTransaction
Transaction beginTransaction()Start a transaction with 'REQUIRED' semantics.With REQUIRED semantics if an active transaction already exists that transaction will be used.
The transaction is stored in a ThreadLocal variable and typically you only need to use the returned Transaction IF you wish to do things like use batch mode, change the transaction isolation level, use savepoints or log comments to the transaction log.
Example of using a transaction to span multiple calls to find(), save() etc.
Using try with resources
// start a transaction (stored in a ThreadLocal) try (Transaction txn = database.beginTransaction()) { Order order = database.find(Order.class, 10); ... database.save(order); txn.commit(); }
Using try finally block
// start a transaction (stored in a ThreadLocal) Transaction txn = database.beginTransaction(); try { Order order = database.find(Order.class,10); database.save(order); txn.commit(); } finally { txn.end(); }
Transaction options
try (Transaction txn = database.beginTransaction()) { // explicitly turn on/off JDBC batch use txn.setBatchMode(true); txn.setBatchSize(50); // control flushing when mixing save and queries txn.setBatchFlushOnQuery(false); // turn off persist cascade if needed txn.setPersistCascade(false); // for large batch insert processing when we do not // ... need the generatedKeys, don't get them txn.setBatchGetGeneratedKeys(false); // explicitly flush the JDBC batch buffer txn.flush(); ... txn.commit(); }
If you want to externalise the transaction management then you use createTransaction() and pass the transaction around to the various methods on Database yourself.
-
beginTransaction
Start a transaction additionally specifying the isolation level. -
beginTransaction
Start a transaction typically specifying REQUIRES_NEW or REQUIRED semantics.Note that this provides an try finally alternative to using
executeCall(TxScope, Callable)
orexecute(TxScope, Runnable)
.REQUIRES_NEW example:
// Start a new transaction. If there is a current transaction // suspend it until this transaction ends try (Transaction txn = database.beginTransaction(TxScope.requiresNew())) { ... // commit the transaction txn.commit(); // At end this transaction will: // A) will rollback transaction if it has not been committed // B) will restore a previously suspended transaction }
REQUIRED example:
// start a new transaction if there is not a current transaction try (Transaction txn = database.beginTransaction(TxScope.required())) { ... // commit the transaction if it was created or // do nothing if there was already a current transaction txn.commit(); }
-
currentTransaction
Transaction currentTransaction()Returns the current transaction or null if there is no current transaction in scope. -
flush
void flush()Flush the JDBC batch on the current transaction.This only is useful when JDBC batch is used. Flush occurs automatically when the transaction commits or batch size is reached. This manually flushes the JDBC batch buffer.
This is the same as
currentTransaction().flush()
. -
commitTransaction
void commitTransaction()Commit the current transaction. -
rollbackTransaction
void rollbackTransaction()Rollback the current transaction. -
endTransaction
void endTransaction()If the current transaction has already been committed do nothing otherwise rollback the transaction.Useful to put in a finally block to ensure the transaction is ended, rather than a rollbackTransaction() in each catch block.
Code example:
database.beginTransaction(); try { // do some fetching and or persisting ... // commit at the end database.commitTransaction(); } finally { // if commit didn't occur then rollback the transaction database.endTransaction(); }
-
refresh
Refresh the values of a bean.Note that this resets OneToMany and ManyToMany properties so that if they are accessed a lazy load will refresh the many property.
-
refreshMany
Refresh a many property of an entity bean.- Parameters:
bean
- the entity bean containing the 'many' propertypropertyName
- the 'many' property to be refreshed
-
find
Find a bean using its unique id.// Fetch order 1 Order order = database.find(Order.class, 1);
If you want more control over the query then you can use createQuery() and Query.findOne();
// ... additionally fetching customer, customer shipping address, // order details, and the product associated with each order detail. // note: only product id and name is fetch (its a "partial object"). // note: all other objects use "*" and have all their properties fetched. Query<Order> query = database.find(Order.class) .setId(1) .fetch("customer") .fetch("customer.shippingAddress") .fetch("details") .query(); // fetch associated products but only fetch their product id and name query.fetch("details.product", "name"); Order order = query.findOne(); // traverse the object graph... Customer customer = order.getCustomer(); Address shippingAddress = customer.getShippingAddress(); List<OrderDetail> details = order.getDetails(); OrderDetail detail0 = details.get(0); Product product = detail0.getProduct(); String productName = product.getName();
- Parameters:
beanType
- the type of entity bean to fetchid
- the id value
-
reference
Get a reference object.This will not perform a query against the database unless some property other that the id property is accessed.
It is most commonly used to set a 'foreign key' on another bean like:
Product product = database.getReference(Product.class, 1); OrderDetail orderDetail = new OrderDetail(); // set the product 'foreign key' orderDetail.setProduct(product); orderDetail.setQuantity(42); ... database.save(orderDetail);
Lazy loading characteristics
Product product = database.getReference(Product.class, 1); // You can get the id without causing a fetch/lazy load Long productId = product.getId(); // If you try to get any other property a fetch/lazy loading will occur // This will cause a query to execute... String name = product.getName();
- Parameters:
beanType
- the type of entity beanid
- the id value
-
extended
ExtendedServer extended()Return the extended API for Database.The extended API has the options for executing queries that take an explicit transaction as an argument.
Typically we only need to use the extended API when we do NOT want to use the usual ThreadLocal based mechanism to obtain the current transaction but instead supply the transaction explicitly.
-
save
Either Insert or Update the bean depending on its state.If there is no current transaction one will be created and committed for you automatically.
Save can cascade along relationships. For this to happen you need to specify a cascade of CascadeType.ALL or CascadeType.PERSIST on the OneToMany, OneToOne or ManyToMany annotation.
In this example below the details property has a CascadeType.ALL set so saving an order will also save all its details.
public class Order { ... @OneToMany(cascade=CascadeType.ALL, mappedBy="order") List<OrderDetail> details; ... }
When a save cascades via a OneToMany or ManyToMany Ebean will automatically set the 'parent' object to the 'detail' object. In the example below in saving the order and cascade saving the order details the 'parent' order will be set against each order detail when it is saved.
- Throws:
javax.persistence.OptimisticLockException
-
saveAll
Save all the beans in the collection.- Throws:
javax.persistence.OptimisticLockException
-
saveAll
Save all the beans.- Throws:
javax.persistence.OptimisticLockException
-
delete
Delete the bean.This will return true if the bean was deleted successfully or JDBC batch is being used.
If there is no current transaction one will be created and committed for you automatically.
If the Bean does not have a version property (or loaded version property) and the bean does not exist then this returns false indicating that nothing was deleted. Note that, if JDBC batch mode is used then this always returns true.
- Throws:
javax.persistence.OptimisticLockException
-
delete
boolean delete(Object bean, Transaction transaction) throws javax.persistence.OptimisticLockException Delete the bean with an explicit transaction.This will return true if the bean was deleted successfully or JDBC batch is being used.
If the Bean does not have a version property (or loaded version property) and the bean does not exist then this returns false indicating that nothing was deleted. However, if JDBC batch mode is used then this always returns true.
- Throws:
javax.persistence.OptimisticLockException
-
deletePermanent
Delete a bean permanently without soft delete.- Throws:
javax.persistence.OptimisticLockException
-
deletePermanent
boolean deletePermanent(Object bean, Transaction transaction) throws javax.persistence.OptimisticLockException Delete a bean permanently without soft delete using an explicit transaction.- Throws:
javax.persistence.OptimisticLockException
-
deleteAllPermanent
Delete all the beans in the collection permanently without soft delete.- Throws:
javax.persistence.OptimisticLockException
-
deleteAllPermanent
int deleteAllPermanent(Collection<?> beans, Transaction transaction) throws javax.persistence.OptimisticLockException Delete all the beans in the collection permanently without soft delete using an explicit transaction.- Throws:
javax.persistence.OptimisticLockException
-
delete
Delete the bean given its type and id. -
delete
Delete the bean given its type and id with an explicit transaction. -
deletePermanent
Delete permanent given the bean type and id. -
deletePermanent
Delete permanent given the bean type and id with an explicit transaction. -
deleteAll
Delete all the beans in the collection.- Throws:
javax.persistence.OptimisticLockException
-
deleteAll
int deleteAll(Collection<?> beans, Transaction transaction) throws javax.persistence.OptimisticLockException Delete all the beans in the collection using an explicit transaction.- Throws:
javax.persistence.OptimisticLockException
-
deleteAll
Delete several beans given their type and id values. -
deleteAll
Delete several beans given their type and id values with an explicit transaction. -
deleteAllPermanent
Delete permanent for several beans given their type and id values. -
deleteAllPermanent
Delete permanent for several beans given their type and id values with an explicit transaction. -
execute
Execute a Sql Update Delete or Insert statement. This returns the number of rows that where updated, deleted or inserted. If is executed in batch then this returns -1. You can get the actual rowCount after commit() from updateSql.getRowCount().If you wish to execute a Sql Select natively then you should use the SqlQuery object or DtoQuery.
Note that the table modification information is automatically deduced and you do not need to call the DB.externalModification() method when you use this method.
Example:
// example that uses 'named' parameters String s = "UPDATE f_topic set post_count = :count where id = :id" SqlUpdate update = database.createSqlUpdate(s); update.setParameter("id", 1); update.setParameter("count", 50); int modifiedCount = database.execute(update); String msg = "There where " + modifiedCount + "rows updated";
- Parameters:
sqlUpdate
- the update sql potentially with bind values- Returns:
- the number of rows updated or deleted. -1 if executed in batch.
- See Also:
-
execute
Execute a ORM insert update or delete statement using the current transaction.This returns the number of rows that where inserted, updated or deleted.
-
execute
Execute a ORM insert update or delete statement with an explicit transaction. -
execute
For making calls to stored procedures.Example:
String sql = "{call sp_order_modify(?,?,?)}"; CallableSql cs = database.createCallableSql(sql); cs.setParameter(1, 27); cs.setParameter(2, "SHIPPED"); cs.registerOut(3, Types.INTEGER); cs.execute(); // read the out parameter Integer returnValue = (Integer) cs.getObject(3);
-
externalModification
Inform Ebean that tables have been modified externally. These could be the result of from calling a stored procedure, other JDBC calls or external programs including other frameworks.If you use database.execute(UpdateSql) then the table modification information is automatically deduced and you do not need to call this method yourself.
This information is used to invalidate objects out of the cache and potentially text indexes. This information is also automatically broadcast across the cluster.
If there is a transaction then this information is placed into the current transactions event information. When the transaction is committed this information is registered (with the transaction manager). If this transaction is rolled back then none of the transaction event information registers including the information you put in via this method.
If there is NO current transaction when you call this method then this information is registered immediately (with the transaction manager).
- Parameters:
tableName
- the name of the table that was modifiedinserted
- true if rows where inserted into the tableupdated
- true if rows on the table where updateddeleted
- true if rows on the table where deleted
-
find
Find a entity bean with an explicit transaction.- Type Parameters:
T
- the type of entity bean to find- Parameters:
beanType
- the type of entity bean to findid
- the bean id valuetransaction
- the transaction to use (can be null)
-
save
Insert or update a bean with an explicit transaction.- Throws:
javax.persistence.OptimisticLockException
-
saveAll
int saveAll(Collection<?> beans, Transaction transaction) throws javax.persistence.OptimisticLockException Save all the beans in the collection with an explicit transaction.- Throws:
javax.persistence.OptimisticLockException
-
checkUniqueness
This method checks the uniqueness of a bean. I.e. if the save will work. It will return the properties that violates an unique / primary key. This may be done in an UI save action to validate if the user has entered correct values.Note: This method queries the DB for uniqueness of all indices, so do not use it in a batch update.
Note: This checks only the root bean!
// there is a unique constraint on title Document doc = new Document(); doc.setTitle("One flew over the cuckoo's nest"); doc.setBody("clashes with doc1"); Set<Property> properties = DB.checkUniqueness(doc); if (properties.isEmpty()) { // it is unique ... carry on } else { // build a user friendly message // to return message back to user String uniqueProperties = properties.toString(); StringBuilder msg = new StringBuilder(); properties.forEach((it)-> { Object propertyValue = it.getVal(doc); String propertyName = it.getName(); msg.append(" property["+propertyName+"] value["+propertyValue+"]"); }); // uniqueProperties > [title] // custom msg > property[title] value[One flew over the cuckoo's nest] }
- Parameters:
bean
- The entity bean to check uniqueness on- Returns:
- a set of Properties if constraint validation was detected or empty list.
-
checkUniqueness
Same ascheckUniqueness(Object)
. but with given transaction. -
markAsDirty
Marks the entity bean as dirty.This is used so that when a bean that is otherwise unmodified is updated the version property is updated.
An unmodified bean that is saved or updated is normally skipped and this marks the bean as dirty so that it is not skipped.
Customer customer = database.find(Customer, id); // mark the bean as dirty so that a save() or update() will // increment the version property database.markAsDirty(customer); database.save(customer);
-
update
Saves the bean using an update. If you know you are updating a bean then it is preferable to use this update() method rather than save().Stateless updates: Note that the bean does not have to be previously fetched to call update().You can create a new instance and set some of its properties programmatically for via JSON/XML marshalling etc. This is described as a 'stateless update'.
Optimistic Locking: Note that if the version property is not set when update() is called then no optimistic locking is performed (internally ConcurrencyMode.NONE is used).
// A 'stateless update' example Customer customer = new Customer(); customer.setId(7); customer.setName("ModifiedNameNoOCC"); database.update(customer);
- Throws:
javax.persistence.OptimisticLockException
-
update
Update a bean additionally specifying a transaction.- Throws:
javax.persistence.OptimisticLockException
-
updateAll
Update a collection of beans. If there is no current transaction one is created and used to update all the beans in the collection.- Throws:
javax.persistence.OptimisticLockException
-
updateAll
void updateAll(Collection<?> beans, Transaction transaction) throws javax.persistence.OptimisticLockException Update a collection of beans with an explicit transaction.- Throws:
javax.persistence.OptimisticLockException
-
merge
Merge the bean using the default merge options (no paths specified, default delete).- Parameters:
bean
- The bean to merge
-
merge
Merge the bean using the given merge options.- Parameters:
bean
- The bean to mergeoptions
- The options to control the merge
-
merge
Merge the bean using the given merge options and a transaction.- Parameters:
bean
- The bean to mergeoptions
- The options to control the merge
-
insert
Insert the bean.Compared to save() this forces bean to perform an insert rather than trying to decide based on the bean state. As such this is useful when you fetch beans from one database and want to insert them into another database (and you want to explicitly insert them).
-
insert
Insert the bean with a transaction. -
insertAll
Insert a collection of beans. If there is no current transaction one is created and used to insert all the beans in the collection. -
insertAll
Insert a collection of beans with an explicit transaction. -
execute
Execute explicitly passing a transaction. -
execute
Execute explicitly passing a transaction. -
execute
Execute a Runnable in a Transaction with an explicit scope.The scope can control the transaction type, isolation and rollback semantics.
// set specific transactional scope settings TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE); database.execute(scope, new Runnable() { public void run() { User u1 = database.find(User.class, 1); ... } });
-
execute
Execute a Runnable in a Transaction with the default scope.The default scope runs with REQUIRED and by default will rollback on any exception (checked or runtime).
database.execute(() -> { User u1 = database.find(User.class, 1); User u2 = database.find(User.class, 2); u1.setName("u1 mod"); u2.setName("u2 mod"); u1.save(); u2.save(); });
-
executeCall
Execute a TxCallable in a Transaction with an explicit scope.The scope can control the transaction type, isolation and rollback semantics.
// set specific transactional scope settings TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE); database.executeCall(scope, new Callable<String>() { public String call() { User u1 = database.find(User.class, 1); ... return u1.getEmail(); } });
-
executeCall
Execute a TxCallable in a Transaction with the default scope.The default scope runs with REQUIRED and by default will rollback on any exception (checked or runtime).
database.executeCall(new Callable<String>() { public String call() { User u1 = database.find(User.class, 1); User u2 = database.find(User.class, 2); u1.setName("u1 mod"); u2.setName("u2 mod"); database.save(u1); database.save(u2); return u1.getEmail(); } });
-
cacheManager
ServerCacheManager cacheManager()Return the manager of the server cache ("L2" cache). -
backgroundExecutor
BackgroundExecutor backgroundExecutor()Return the BackgroundExecutor service for asynchronous processing of queries. -
json
JsonContext json()Return the JsonContext for reading/writing JSON.This instance is safe to be used concurrently by multiple threads and this method is cheap to call.
Simple example:
JsonContext json = database.json(); String jsonOutput = json.toJson(list); System.out.println(jsonOutput);
Using PathProperties:
// specify just the properties we want PathProperties paths = PathProperties.parse("name, status, anniversary"); List<Customer> customers = database.find(Customer.class) // apply those paths to the query (only fetch what we need) .apply(paths) .where().ilike("name", "rob%") .findList(); // ... get the json JsonContext jsonContext = database.json(); String json = jsonContext.toJson(customers, paths);
- See Also:
-
script
ScriptRunner script()Return a ScriptRunner for running SQL or DDL scripts. Intended to use mostly in testing to run seed SQL scripts or truncate table scripts etc. -
docStore
DocumentStore docStore()Return the Document store. -
publish
Publish a single bean given its type and id returning the resulting live bean.The values are published from the draft to the live bean.
- Type Parameters:
T
- the type of the entity bean- Parameters:
beanType
- the type of the entity beanid
- the id of the entity beantransaction
- the transaction the publish process should use (can be null)
-
publish
Publish a single bean given its type and id returning the resulting live bean. This will use the current transaction or create one if required.The values are published from the draft to the live bean.
- Type Parameters:
T
- the type of the entity bean- Parameters:
beanType
- the type of the entity beanid
- the id of the entity bean
-
publish
Publish the beans that match the query returning the resulting published beans.The values are published from the draft beans to the live beans.
- Type Parameters:
T
- the type of the entity bean- Parameters:
query
- the query used to select the draft beans to publishtransaction
- the transaction the publish process should use (can be null)
-
publish
Publish the beans that match the query returning the resulting published beans. This will use the current transaction or create one if required.The values are published from the draft beans to the live beans.
- Type Parameters:
T
- the type of the entity bean- Parameters:
query
- the query used to select the draft beans to publish
-
draftRestore
Restore the draft bean back to the live state.The values from the live beans are set back to the draft bean and the
@DraftDirty
and@DraftReset
properties are reset.- Type Parameters:
T
- the type of the entity bean- Parameters:
beanType
- the type of the entity beanid
- the id of the entity bean to restoretransaction
- the transaction the restore process should use (can be null)
-
draftRestore
Restore the draft bean back to the live state.The values from the live beans are set back to the draft bean and the
@DraftDirty
and@DraftReset
properties are reset.- Type Parameters:
T
- the type of the entity bean- Parameters:
beanType
- the type of the entity beanid
- the id of the entity bean to restore
-
draftRestore
Restore the draft beans matching the query back to the live state.The values from the live beans are set back to the draft bean and the
@DraftDirty
and@DraftReset
properties are reset.- Type Parameters:
T
- the type of the entity bean- Parameters:
query
- the query used to select the draft beans to restoretransaction
- the transaction the restore process should use (can be null)
-
draftRestore
Restore the draft beans matching the query back to the live state.The values from the live beans are set back to the draft bean and the
@DraftDirty
and@DraftReset
properties are reset.- Type Parameters:
T
- the type of the entity bean- Parameters:
query
- the query used to select the draft beans to restore
-
validateQuery
Returns the set of properties/paths that are unknown (do not map to known properties or paths).Validate the query checking the where and orderBy expression paths to confirm if they represent valid properties/path for the given bean type.
-
lock
Load and lock the bean usingselect for update
.This should be executed inside a transaction and results in the bean being loaded or refreshed from the database and a database row lock held via
select for update
.The bean needs to have an ID property set and can be a reference bean (only has ID) or partially or fully populated bean. This will load all the properties of the bean from the database using
select for update
obtaining a database row lock (using WAIT).- Parameters:
bean
- The entity bean that we wish to obtain a database lock on.
-
truncate
Truncate all the given tables. -
truncate
Truncate the base tables for the given bean types.
-


Documentation
jsCookie-1.4:
is a simple, fast JavaScript class that will help you handle cookies the easy way!
jsCookie is designed to change the way you handle JavaScript Cookies.
Table of Contents:
1) Add jsCookie:
You will need to copy the "jsCookie-1.4.min.js" file(from the zip file you downloaded)
into your server.
(Remember where you uploaded it to, i.e. the path on the server)
2) Include jsCookie into your html file:
Just copy this code into your html file and paste it before the </head>
tag or the </body> tag.
Like so:
3) Call jsCookie
In the script tag where you want to use jsCookie, add the following lines:
(before using the jsCookie functions, otherwise it will not have time to load)
4) Start coding!
Now you can start using jsCookie in your project!
Scroll down to see all the jsCookie functions you can use...
I know that jsCookie is good for anything regarding cookies.
Yet,
I highly recommend on using a browser extension when working with cookies.
It will accelerate your development time.
I suggest the following addons for chrome & firefox:
-Chrome:Edit This Cookie
-FireFox(& ie):Cookie Manager
Functions:
.enabled()
The enabled function is used for checking the availability of cookies on the client's
browser.
The function returns true if cookies are enabled, and false when cookies are
not enabled.
* This function can run offline.
* OnSuccess: true, OnFailure: false
Example:
.create()
The create function creates a cookie.
In case of failure the function will return false.
* @param {string/int} value - name of cookie, ***Required***
* @param {array/int}[Days, Hours, Minutes, Seconds] expire - time for cookie to expire
* @param {string} path - location of cookie on the server to be active
* @param {string} domain - domain connected to cookie
* @param {string/bool} secure - send the cookie over SSL connections only
*
* OnSuccess: none, OnFailure: false
Example:
This example creates a cookie in the current directory which it was called from. It expires after 1 hour.
This example will create an updatable(.update) cookie:
Creating a cookie with a path can be ignored,
if the path of the cookie is created on - is not included in the path parameter.
.set()
This quickly creates a session cookie which exists only while the browser window remains open.
(No other options, only name and value)
In case of failure the function will return false.
* @param {string} value - value of cookie on the server, ***Required***
* OnSuccess: none, OnFailure: none
Example:
.read()
The read function returns the value of the specified cookie.
It will return false if no cookie was found.
* OnSuccess: {string}value of cookie, OnFailure: false
Example:
.readByValue()
The readByValue function returns the name of the cookie's value that was specified.
It will return false if no cookie was found.
* OnSuccess: {string}name of cookie, OnFailure: false
Example:
.remove()
The remove function deletes a cookie by its name.
* @param {string} path - location of cookie on the server
* @param {string} domain - location of cookie on the server
* OnSuccess: none, OnFailure: false
Example:
.removeByValue()
The removeByValue function deletes a cookie by its value.
* @param {string} path - location of cookie on the server
* @param {string} domain - location of cookie on the server
* OnSuccess: none, OnFailure: false
Example:
.removeAll()
The removeAll function deletes all the cookies (only those in the current path).
* OnSuccess: returns array, OnFailure/No records: false
Example:
.count()
Returns the number of cookies on the page.
* OnSuccess: returns int (number of cookies), OnFailure/No records: none
Example:
.getNames()
The getNames function returns all the cookies' names in the current page.
* OnSuccess: returns array, OnFailure/No records: false
Example:
.getValues()
The getValues function returns all the cookie values in the current page.
* OnSuccess: returns array, OnFailure/No records: false
Example:
.getAsArray()
The getAsArray function returns cookies and their data as an array (string) or as an array(object literal).
(in the current page).
* OnSuccess: returns array, OnFailure: false
Or: (object literal) -
.update()
Update a cookie while keeping its initial values (expire, path, domain, secure).
Date parameter can be changed.
Update method will only work with cookies that have the "updatable" flag (as true).
Cookie name is presistant.
* @param {string} newValue - new value for the cookie, ***Required***
* @param {string} newDate - update cookie with a new date of expiration, ***Required***
OR:
* @param {string} keepDate - keep the current expiration date, ***Required***
* OnSuccess: none, OnFailure: false
Example:
Or:
.appendValue()
Appends a value to already existing cookie.
* @param {string} addValue - appended value, ***Required***
* @param {string} updatable - keep cookie settings (updatable cookie) ***Required***
Or:
* @param {array/int} expire - optional - set expire date, if the cookie isn't updatable ***Required***
* OnSuccess: none, OnFailure: false
Example:
.getSettings()
Get an updatable cookie's settings.
* Return values: array of strings - [0 = expire, 1 = path, 2 = domain, 3 = secure]
* OnSuccess: {string/arr}, OnFailure: false
Example:
.getNamesByValue()
Get names array of cookies by their common value
* Return values: array of strings (names)
* OnSuccess: {string/arr}, OnFailure: false
Example:
Questions:
1) How do I update / change a value or expire time of a cookie?Answer (1):
Just insert the name of a cookie that was already created,
and jsCookie will update that cookie with what you entered.
(Version 1.3) - Use the update() function:
(Remember the last bool parameter - the updatable flag)
Update function:
2) What can I do with the ".getAsArray()" function?
Answer (2):
It's simple.
If you want to manipulate the cookie objects in an array manner,
this is the tool for you.
If you want, for example, to do something with all the cookies and you need them separated,
use this function.(change all the cookies value's)
3) I want to hash my cookie so it will be protected, how can I do so?
Answer (3):
As you know jsCookie runs within, JavaScript,
JavaScript is a client-side programming language.
This means that all the code that you write is easily viewed in the client's browser.
Thus, if I would have written a hash algorithm to secure your cookies they would
actually not be that secure,
for the obvious reason that users could read and understand my code and probably
break it and "hack" your cookies.
To work something out I would recommend using a server-side solution by
creating your cookies in a server-side programming language.
In this way you could create and hash your cookies in a more secure way.
4) I want to add my own function to jsCookie, how can I do so?
Answer (4):
You can do so by writing something like this into jsCookie-1.4.js:
I would also recommend using an online solution for minifying the code.
(DO NOT RESELL EVEN IF THE CODE WAS CHANGED) - Unless you bought the Extended Licence
5) If I don't specify the expire time in the .create() function, when will it expire?
Answer (5):
The cookie will expire just like the cookie created with the set function (session cookie),
they will expire when the client exits the browser.
6) I have a suggestion/bug report I want to inform you about,
where can I contact you?
Answer (6):
It's super easy to contact me,
send me an email to:agam.more at gmail.com
Or click on the blue sign on the left corner of
the page, it will take you to my codecanyon page.
7) I have x cookies on a page but the .count() function
retuns y cookies insted, why?
Answer (7):
This happens because those cookies that were not counted (or read etc...), they were possibly created by the server-side(php,asp.net...),
Or have a different path/domain (than the code execution one's).
Therefore jsCookie cannot read them.
8) When I use the .remove or .removeAll function, it does not delete all of my cookies, why?
Answer (8):
This happens because those cookies that were not deleted were created with the spesification of a domain or path.
Therefore the remove function cannot remove them.
A quick solution for that is:
Replace the capital words to the cookie's properies.
9) Problems or lack of understanding of .create() function properties:
Answer (9):
I will explain how to use them correctly:
To activate the cookie only at a particular path:
Cookie will work in a particular domain:
Cookie will be activated over SSL connections only:
For Example, show a popup only for the first time:
Answer (10):
One client has already asked this question.
So I decided to attach the file to jsCookie-1.4.js
Take a look in:
jsCookie-folder/Dev/popupExample.html
Notes:
1) In the create function do not enter the semi colon(";") symbol,
the function will return false if inserted.
2) You can only manipulate cookies created by JavaScript - if a cookie was created by the server-side,
then you couldn't manipulate it through JavaScript (an http cookie).
3) For for detail about cookies please visit this web page:
The unofficial cookie FAQ(by David Whalen)
4)jsCookie code will not run offline IN GOOGLE CHROME, because cookies need a server to be created.
5) If you are using the updatable flag, don't or use the following as a value/name: "_jscUpt_".


H.O.T. Planet: Humanitarian Crisis + Contextual Mapping with CartoDB
Target Audience:
college students, humanitarian aid workers, activists
Objectives:
- Haiti and CrisisMapping course at Yale
- Review CartoDB features, utility
- Go over use case: Vital Signs/NGO aid mapping
- Go over sensor data visualizations
- Upcoming features for students
View Slides Here


| Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday | Monday-Friday, January 16-20 To Be or Not to Be (1942) 7:30 Casablanca (1942) 5:35, 9:20 | Saturday January 21 The Student Prince in Old Heidelberg (1927) 7:30 Silent film with Dennis James at the organ | Sunday January 22 3:00 Silent film with Dennis James at the organ | Monday-Thursday, January 23-26
closed | Friday-Sunday, January 27-29 The Wicked Lady (1945) 7:30 (plus 3:50 Sat/Sun) The Lady Vanishes (1938) 5:45, 9:25 | Monday-Friday, January 30-February 3
closed | Saturday February 4 7:30 Silent film with Dennis James at the organ | Sunday February 5 Lady Windermere's Fan (1925) 16mm 3:00 Silent film with Dennis James at the organ
Print restored by UCLA, with original soundtrack 5:15 | Monday-Wednesday, February 6-8
closed | Thursday-Friday, February 9-10 Love Story (1944) 7:30 I'll Be Your Sweetheart (1945) 5:35, 9:30 | Saturday-Sunday, February 11-12 The Love Parade (1929) 3:50, 7:30 Monte Carlo (1930) 5:50, 9:30 | Monday-Wednesday, February 13-15
closed | Thursday-Friday, February 16-17 The Smiling Lieutenant (1931) 7:30 Broken Lullaby (1932) 6:00, 9:15 | Saturday-Sunday, February 18-19 The Innocents (1961) 3:40, 7:30 The Chalk Garden (1964) 5:30, 9:20 | Monday-Wednesday, February 20-22
closed | Thursday-Friday, February 23-24 Trouble in Paradise (1932) 7:30 One Hour With You (1932) 6:00, 9:05 | Saturday-Sunday, February 25-26 Murder She Said (1961) 4:10, 7:30 The Belles of St. Trinian's (1954) 5:50, 9:10 | Monday-Wednesday, February 27-March 1
closed | Thursday-Friday, March 2-3 They Met in the Dark (1943) 7:30 Take My Life (1947) 6:00, 9:15 | Saturday-Sunday, March 4-5 Design for Living (1933) 4:00, 7:30 The Merry Widow (1934) 5:40, 9:10 | Monday-Wednesday, March 6-8
closed | Thursday-Friday, March 9-10 Angel (1937) 7:30 Bluebeard's Eighth Wife (1938) 5:55, 9:15 | Saturday-Sunday, March 11-12 A Night to Remember (1958) 3:35, 7:30 The Clouded Yellow (1950) 5:50, 9:45 | Monday-Wednesday, March 13-15
closed | Thursday-Friday, March 16-17 Lost, aka Tears for Simon (1956) 5:50, 9:15 | Saturday-Sunday, March 18-19 Ninotchka (1939) 3:40, 7:30 (plus The Shop Around the Corner (1940) 5:40, 9:30 | Monday-Wednesday, March 20-22
closed | Thursday-Friday, March 23-24 The Brothers (1947) 7:30 Madonna of the Seven Moons (1945) 5:30, 9:10 | Saturday-Sunday, March 25-26 Heaven Can Wait (1943) 3:35, 7:30 Cluny Brown (1946) 5:40, 9:35 |


Walmart removes sweater depicting Santa Claus doing blow
by Jason WeisbergerThere is no room for amateurs in the drug culture.
CNN:
"These sweaters, sold by a third-party seller on Walmart.ca, do not represent Walmart's values and have no place on our website," Walmart said in a statement on Saturday. "We have removed these products from our marketplace. We apologize for any unintended offence this may have caused."


Thank you for submitting your information to the Community Safety Unit. If you provided your name and contact information, you may be contacted by the Community Safety Unit for additional information.


Justice Minister calls for 'siege to be lifted in Achill'
JUSTICE Minister Charlie Flanagan has called for the silent vigil outside a proposed emergency accommodation centre in Achill to be stood down.
He made his request for 'the seige to be lifted' to RTÈ News in light of ongoing protests at the site of the Achill Head Hotel in Keel which had been selected as a location to provide emergency temporary accommodation for asylum seekers.
Yesterday, the Department of Justice and Equality put off plans to house 13 women in the hotel due to ongoing protests at the site.
Minister Flanagan urged demonstrators to engage in dialogue with his department to help protect "vulnerable people".


Your Cart
|
Code : Title : Choices
|
|
|
Quantity |
X |
Cost |
+ |
GST |
Total |
|
|
|
|
|
|
X |
|
+ |
|
|
|
Total |
|
|
|
|
|
|
|
We are unable to calculate the postage cost as we need your Post Code, once you fill in the details to the rightbelow, and activate your account we will be able to estimate the postage cost's.
Changing Quantities will refresh the page to recalculate.
To remove items change it's Quantity to '0'
Prices are in Australian Dollars (AUD)


Can I Make My Characters Dance?
New Background
OK
New Character
Delete the cat (press and hold)
Position the characters by dragging them from the center of the screen


compute_propensity_score
(X
, treatment
, p_model
=None
, X_pred
=None
, treatment_pred
=None
, calibrate_p
=True
)
Generate propensity score if user didn't provide
Args:
X (np.matrix): features for training
treatment (np.array or pd.Series): a treatment vector for training
p_model (propensity model object, optional):
ElasticNetPropensityModel (default) / GradientBoostedPropensityModel
X_pred (np.matrix, optional): features for prediction
treatment_pred (np.array or pd.Series, optional): a treatment vector for prediciton
calibrate_p (bool, optional): whether calibrate the propensity score
Returns:
(tuple)
- p (numpy.ndarray): propensity score
- p_model (PropensityModel): a trained PropensityModel object


Use the Discovery Tab on Build preference panel to define global scanner discovery options.
In the Discovery tab you can see a list of Language Settings Providers. Language Settings Providers supply Language Settings such as include paths and preprocessor macros for the indexer and other components of CDT.
A user can define some properties for global (or "shared") providers on this preference. Note that providers can be either shared or defined per configuration. Properties for non-shared providers can be defined in Project properties: Preprocessor Include Paths, Macros, etc.
| Group | Description |
|---|---|
| Language Settings Providers | Lists the available language settings providers. |
| Clear Entries | Click to clear all entries of the selected provider.
This operation takes effect after pressing "Apply" or "OK".
Normally this will trigger a rerun if the provider supplies built-in compiler settings.
Build output parsers will regain language settings after build while parsing new build output.
This operation might be unavailable if the provider does not have any language settings. Some providers may not have the capability to clear. |
| Reset | Click to reset options of the selected provider to default values. This operation also clears the provider entries. The button can be enabled if some options in "Language Settings Provider Options" panel were changed. |
| Provider | Description |
|---|---|
| Build Output Parser Provider | Build Output Parser Provider parses output of build
looking for include paths and macros passed to the compiler via compiler options.
Include files, macro files passed the the compiler and some other compiler options are normally also recognized.
For gcc, include paths commonly passed with "-I" option and macros with "-D" option. The language settings found by BOP are available after the build is finished. |
| Builtin Compiler Settings Provider | Builtin Compiler Settings Provider launches the compiler with special options that instruct the compiler to print built-in settings such as include paths to internal system headers and the list of internally predefined macros. This provider is usually shared between projects in workspace and runs in background once. When it is finished the language settings are available to all the projects between which it is shared. |
| Managed Build Language Settings Provider | MBS Provider supplies language settings provided by Managed Build System. |
| User Language Settings Provider | A user has an opportunity to enter language settings manually using this provider. User Language Settings Provider should be normally the first in the list so these settings override settings supplied by other providers. |
| Contributed PathEntry Containers | This provider is here for backward compatibility support of PathEntry Containers from older versions of CDT. Using this method is not recommended. |
| Contributed ScannerInfo Entries | This provider is here for backward compatibility support of ScannerInfo Entries from older versions of CDT. Using this method is not recommended. |
Language settings providers can have options that affect the behavior of a provider. These options are presented in "Language Settings Provider Options" panel.
| Provider | Options |
|---|---|
| Compiler command pattern | The pattern which is used to recognize compiler command in build output.
Note that the pattern is Java regular expression pattern, it is NOT globbing pattern used to expand file name in command line. |
| Container to keep discovered entries | The discovered entries can be associated with the project, enclosing folder or the file itself. |
| Use heuristics to resolve paths | The provider will try to find the best match for the discovered path in the project or workspace trying several heuristics. If disabled, the discovered paths will stay as they appear in build output. |
| Provider | Options |
|---|---|
| Command to get compiler specs | The command to make the compiler print built-in settings.
Following variables are recognized:
|
| Browse | Use this button to locate the compiler on the file system. The result is put into "Command to get compiler specs" input field. |
| Allocate console in the Console View | Enable to troubleshoot problems running the command. When enabled, output of each run of the provider will be directed to a special console in the Console View. See also Scanner Discovery - Console View. |
To see the entries a provider discovered, go to project properties (or the properties of the resource of interest), see Project properties: Preprocessor Include Paths, Macros, etc.
A hint: After compiler upgrade re-discover changed settings with "Clear Entries" of the appropriate provider.
Scanner Discovery
C/C++ Indexer
Setting up include paths and macros for C/C++ indexer
C/C++ Project properties: Preprocessor Include Paths, Macros, etc.


If you have an optional pressure sensor, you must enable it by selecting calibration 33. If it is disabled, the display says "Press again to enable", so press 33 a second time. When it is enabled, this calibration functions like the {Velocity_calibration}, connecting the {_parameter_control} to the \+10 pressure calibration for the last key played. If you don't have a pressure sensor, leave this disabled, so that the Chroma won't scan the nonexistent sensors and generate random pressure values.
You can disable the pressure sensor by selecting calibration 34. If it is enabled, the display says "Press again to disable and reset", so press 34 again. If you need to reset all the calibrations to zero, disable the sensor, and then press 33 twice to re-enable it.


Kanye West Announces Sunday Service Opera 'Nebuchadnezzar'
by Yohance Kyles (@HUEYmixwitRILEY)Will Ye's tale about the biblical figure be similar to Robert Townsend's 'Carmen: A Hip Hopera'?
(AllHipHop News) With his Jesus Is King album slipping another four spots on the Billboard 200 chart this week, Kanye West seems ready to move his artistic energy in another direction. His next endeavor will apparently be an opera.
Ye made the announcement on Twitter. On Sunday evening, he posted a photo of a golden invitation for the Vanessa Beecroft-directed Nebuchadnezzar. According to the tweet, the production will include music with Sunday Service, Peter Colins, and Infinities Song.
Nebuchadnezzar is scheduled for November 24 at the Hollywood Bowl in Los Angeles. The invite artwork was designed by Nick Knight.
Previously, West released a Jesus Is King IMAX movie in connection to his new music project of the same name. He has also been the creative force behind the Runaway and Cruel Summer short films.


Use this checklist to make sure you have everything you need for your first year at college. These are just suggestions; you should adapt this list to suit your own situation.
To save packing or shipping, it might make sense to buy some of these items after you arrive. It might also make sense to pack for one season at a time and switch items when you go home during breaks.
Printable Version


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface ConstructableServicePoint
"Private" interface used by a ServiceModel
s to access non-
information about a ServicePoint
, such as its instance
builder and interceptors.
| Method Summary | |
|---|---|
void |
addRegistryShutdownListener(RegistryShutdownListener listener)
Adds a shutdown listener; HiveMind uses two coordinators; the first is the hivemind.ShutdownCoordinator service, which is the coordinator used for service implementations. |
void |
clearConstructorInformation()
Invoked by the ServiceModel when constuction information (the builder and interceptors) is no longer needed. |
java.util.List |
getOrderedInterceptorContributions()
Returns a list of ServiceInterceptorContribution s,
ordered according to their dependencies. |
ServiceImplementationConstructor |
getServiceConstructor()
Returns the constructor that can create the core service implementation. |
| Methods inherited from interface org.apache.hivemind.internal.ServicePoint |
|---|
forceServiceInstantiation, getDeclaredInterface, getParametersCount, getParametersSchema, getService, getServiceInterface, getServiceInterfaceClassName |
| Methods inherited from interface org.apache.hivemind.internal.ExtensionPoint |
|---|
getErrorLog, getExtensionPointId, getLog, getModule, visibleToModule |
| Methods inherited from interface org.apache.hivemind.Locatable |
|---|
getLocation |
| Method Detail |
|---|
ServiceImplementationConstructor getServiceConstructor()
java.util.List getOrderedInterceptorContributions()
ServiceInterceptorContribution
s,
ordered according to their dependencies. May return null or an empty list.
Note that the order is tricky! To keep any error messages while ordering the interceptors understandable, they are ordered according into runtime execution order. Example: If we want a logging interceptor to operate before a security-check interceptor, we'll write the following in the descriptor:
<interceptor service-id="hivemind.LoggingInterceptor" before="*"/> <interceptor service-id="somepackage.SecurityInterceptor"/>The
before
value for the first interceptor contribution will be assigned to
the contribution's
followingInterceptorIds
property, because all other interceptors (including the security interceptor) should have
their behavior follow the logging interceptor.
To get this behavior, the logging interceptor will delegate to the security interceptor, and the security interceptor will delegate to the core service implementation.
The trick is that interceptors are applied in reverse order: we start with core service implementation, wrap it with the security interceptor, then wrap that with the logging interceptor ... but that's an issue that applies when building the interceptor stack around the core service implementation.
void clearConstructorInformation()
void addRegistryShutdownListener(RegistryShutdownListener listener)
listener
- the listener to be added to the infrastructure's shutdown coordinator
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


October 25-26 at TPAC 2018
We'll be meeting at TPAC 2018.
We define standards for interoperability between tracing tools.
The Chair of the Working Group is Alois Reitbauer. The W3C Team Contact for the Distributed Tracing Working Group is Philippe Le Hégaret.
Alois wrote an explainer of the work.
We'll be meeting at TPAC 2018.


If you edit values you will see changes in the content. Click the "Design" button to change the form layout.
Source codeLet's say you have the following plain JavaScript object obtained from a database: var object = { name: "Tom", surname: "Young", zipcode: "103844", city: "Kanzas", address: "Mountain drive, 754", phone: "2-300-765-11-22", data: { first_name: "Bob", last_name: "Sallivan", email<EMAIL_ADDRESS>} } You can pass this object, the DOM element and the update callback function to the Form.show() method: var model = FormBuilder.Form.show(object, null, document.getElementById("form-builder-container"), function(object, json) { document.getElementById("form-builder-model-container").value = json; }, function(layout) { document.getElementById("form-builder-layout-container").value = JSON.stringify(layout, null, 4); } ); It builds the form and shows the given HTML element. You will get the object changes notifications in the callback function. |
Editing object contentHere you can see the changes in the content object: |
Auto-generated form layout JSONHere you can see the current form layout JSON: |


---
layout: post
title: And then there were 10
date: '2011-01-14T14:47:00.000-06:00'
author: Jabell
tags:
- Fun
- Culture
modified_time: '2011-01-14T14:47:01.327-06:00'
blogger_id: tag:blogger.com,1999:blog-19739956.post-6725204340482083323
blogger_orig_url: http://theabellsix.blogspot.com/2011/01/and-then-there-were-10.html
---
Since I am not on Twitter or Facebook, I will write a purposeless “what am I up to now statement” in this outdated mode of social media, a.k.a. blog.
I am down to 10 emails in my inbox. My inbox hasn’t been this low since June 2010.


An inspiration hub built with creative thinkers in mind. Create groups and privately or publicly share photos of things that inspire you.
An open idea repository, where ideas can grow into reality. Plant a seed idea and watch as other innovators "Branch" off of your idea to make it eaven better. Turn the idea of a cookie into an oreo baked in a brownie dipped in chocolate.
I am an outdoors entusiast. Any time I can get away from my responsibilities I will most likely either be heading for the mountains or the water. I will be hiking, skiing, or swimming depending on the time of year. My wife Sam and I transitioned to working fully remote in 2020, since then we have moved up to the Heber Valley near Park City in Utah. That puts us in prime position for all the outdoor activites we love. World class Hiking, Skiing, and Paddlesports are all within a 15 minute drive from our house.
This is Sam and I at the amazing Coacoa Beach in 2015. When we had time, we hung out at the beach during my Software Engineering internship at Lockheed Martin in Orlando, FL.


I was always worried about my knees and I wanted to run with same pace as I used to do few years ago, but the phobia of surgeries and operations kept me away from the cure. However my life changed when I visited Plus Healthcare for the first time when my grandson insisted. And, I got rid of my phobia as well as from my knee pain, Thanks a lot PLUS HEALTHCARE
I request everyone who is suffering from same issue as mine to visit PLUS HEALTHCARE once.
Now I can again wear the dresses which I used to wear a few years ago. Obesity can not be cured very easily and dieting is just damn hard. I was not able to follow the diet chart and I could not resist myself from junk food. One day I was recommended an operation to cut my fat and I reached PLUS HEALTHCARE for that. But Dr Nalini Sharma helped a lot, she came to me with a flexible diet chart and with in a month I dropped 3 kg weight!! Yes, its true. Thanks to PLUS HEALTHCARE!


Supply Chain
Logistics
Warehouse Anywhere connects ground-breaking technology with Life Storage's storage asset management platform to provide a warehousing and distribution solution never seen before in the industry.
The goal of this project is to develop a website for customers who wants to buy goods from an electronics warehouse. This website should help the owners to manage, organize their product availability, and for the customers to navigate and purchase electronic goods as per their needs
Warehouse Anywhere connects ground-breaking technology with Life Storage's storage asset management platform to provide a warehousing and distribution solution never seen before in the industry.
The value of well-run and executed warehouse companie and supply chain solutions is that your product or service is optimized for maximum customer value with a competitive advantage.
Logistics Planner is the premier supply chain and logistics resource, a 400-plus-page guide to the market leaders – 3PLs, warehousing companies, technology providers, transportation providers, economic development companies, and more – that can help cut transportation and logistics costs, boost efficiency, and improve supply chain operations.


--- layout: post esbma_id: 1607 title: Thirteen Guitars date: 2006-06-21 14:20:08 ---
The connotation of the term "Web 2.0" is that the Web is a piece of software in its second major version. The term implies that there was a version 1.0 and that there will probably be a version 3.0.
So I find myself wanting to ask the kind of questions I normally ask when I see a software product at version 2.0:
I could certainly respond to these questions by writing about some of the very positive things I see on the Web today. The Web is incredible! Remember back when the "What's New" page at NCSA was a listing of basically every site on the Web? We've come a long way. There are some amazing things happening in this version of the Web.
But right now I'm in a "glass half empty" sort of mood. When I look at the state of the Web today, one big thing jumps out at me: The defining characteristic of this version of the Web is the people who are ruining it.
This past weekend I was bidding on a guitar on eBay. Shortly before the auction ended, I received email from the seller offering to end the auction early. Believing that the seller was trying to do something unethical, I stopped bidding and somebody else won. Only later did I realize that the email was actually sent by someone impersonating the seller. The auction was apparently legit.
Shortly after the auction ended, I received a "Second Chance" offer from the seller. This time I was more discerning of the fraud. Like the first one, this email was not really from the seller.
And then I received two more of these Second Chance offers.
And then in morning I got three more.
At last count, I have received email from 13 different people offering to sell me the guitar I did not win. The laughable part of this story is that the manufacturer only made 12 of this particular model. There are exactly 12 of these guitars on the planet and I've got 13 people offering to sell me one! :-)
I didn't actually give money to any of the 13 crooks who tried to cheat me. I'm not really upset about losing the auction. What distresses me here is that these 13 people won, and the rest of us lost:
I know I'm not the first one to be shocked and frustrated about the presence of evil in the world. Maybe I'm just shouting at the rain, but sometimes a little shouting feels good, especially when this is just the tip of the iceberg. There are many examples of fraud or vandalism on the Web today. Here are just a few other obvious examples:
I could go on with more examples, but you get the idea. The Web today is enormous. It is used by hundreds of millions of people, perhaps billions. A small percentage of those people are causing a lot of damage.
I feel sad.
It seems like the current version of the Web has a flaw. In the real world, it is always easier to destroy than to build, but this disparity seems to be magnified on the Web. People who are actively working to make the Web a better place are climbing uphill pulling a heavy trailer. Meanwhile, the spammers and fraudsters are coasting in their convertible with the top down. I hope the next version of the Web has some improvements in this area.
However, I don't have any solutions to offer right now. I'm just having one of those moments where a realization is hitting me hard: These "evildoers" are becoming the primary influencers of my experience on the Web today. [footnote 5]
[1] Yes, the auction was partly my fault. If I were more experienced with eBay, I would have been less gullible and would have continued bidding. Next time, I will know better, but that's still a workaround for the real bug.
[2] I've read so many stories about click fraud lately that I don't know which one to link. More and more, I hear people saying that they no longer run their AdWords on the content network. We don't. The content clicks were a major fraction of our AdWords spending, and we were getting no measurable value from them.
[3] Yes, viruses pre-date the Web, but the Web has given them a more effective delivery vehicle. BTW, three weeks ago I had to repave my machine because of a virus. The Windows Malicious Software Removal Tool (MSRT) offered to remove the virus, and I said yes. Unfortunately, its concept of removing the virus is simply to remove all the files which are infected. The MSRT could have saved me a lot of time by simply popping up a dialog box that said, "Your system is irretrievably fouled up. Get some coffee, back up your files, and reformat the hard disk."
[4] The guy who administers our network at SourceGear told me recently that less than five percent of the mail we receive is legitimate. BTW, I think we need to stop saying that the spammers only continue because they make money doing it. Virus writers don't make money. They write viruses simply for the joy of causing harm to others. I don't see much reason to believe that spam would stop if the financial incentive were magically removed somehow.
[5] And who are these evildoers anyway? Considering the enormous impact they have on the Web today, it seems wrong for them to be so invisible. Why aren't they blogging?


Before Change
np.random.seed(seed)
np.random.shuffle(y)
nb_batch = int(math.ceil(float(X.shape[0])/batch_size))
for b in range(nb_batch):
batch_end = (b+1)*batch_size
if batch_end > X.shape[0]:
nb_samples = X.shape[0] - b*batch_size
After Change
np.random.shuffle(y)
b = 0
while 1:
current_index = (b * batch_size) % X.shape[0]
if X.shape[0] >= current_index + batch_size:
current_batch_size = batch_size
else:
current_batch_size = X.shape[0] - current_index
bX = np.zeros(tuple([current_batch_size] + list(X.shape)[1:]))
for i in range(current_batch_size):
x = X[current_index + i]
x = self.random_transform(x.astype("float32"))
x = self.standardize(x)
bX[i] = x
if save_to_dir:
for i in range(current_batch_size):
img = array_to_img(bX[i], scale=True)
img.save(save_to_dir + "/" + save_prefix + "_" + str(i) + "." + save_format)
if current_batch_size == batch_size:
b += 1
else:
b = 0
yield bX, y[current_index: current_index + batch_size]
def standardize(self, x):
if self.featurewise_center:
x -= self.mean
if self.featurewise_std_normalization:


Tic Tac Toe
The world's quickest, smallest, and possibly ugliest Tic-Tac-Toe!
Tic tac toe is fun
0
1
2
3
4
5
6
7
8


the and that for with virus The was viral from this AVS Australia) were are host presented their Professor University viruses which {background our novel can these RNA has have (University Australian antiviral new Queensland, cell infection margin research cells immune {border-style Research This influenza not Australia; Melbourne, New between described first into px;} replication virus, #ffffff;} Brisbane, Dr. HBV University, data identified responses both during virology work DENV These Virology []. its may who Award School Sydney, but dengue proteins vaccine Institute Institute, against flavivirus interactions one protein role Medical all gene her presentation session (AVS DNA also capsid could early essential genes human showed Peter Using associated career demonstrated development different disease found high how meeting structural such used (Figure Alice Centre Figure Indigenous been control group impact including innate model present production provide studies they using viruses. Australasian HIV- Infectious Molecular analysis approach being clinical currently diversity findings important introduced lab most potential px; support team through two use viruses, {font-family (The Australia, Doherty HTLV-c Infection Presentation RHDV Research, She committee font-size hepatitis highly his infection. infections international invited lipid multiple plant post-doc researchers sequencing she significant speaker speakers time where while wild-type will Australia Australia. CRISPR/Cas Chemistry Clayton, Drummer Furthermore, HIV Heidi PhD President Society Viral ability after antibodies available cells, chimeric circulating discovered double; following increased inhibitors involved keynote made mechanism members molecular panel particles patients providing proviral range recent receptor recombinant replication. response responses. results revealed rotavirus shown some study suppression target those three transmission vertebrate well & (AVS) AaINLV Ashley BinJV Centre, Colmant DIPs Diseases Gilda HCMV IAV Invited John Kuhn Meeting Michelle Monash National Our Purcell RNAi Sciences, South Table Tachedjian Wales, Western Zika able activation antibody assembly border-color border-width burden cells. chimera discussed each enhanced flaviviruses funding had held highlighted homologous infected insect-specific interaction interferon known led limited linked management meeting, meeting. miRNA more neutralization neutralizing observed only opportunity organising other over pathogenic prevalence proteins. provided rabbit reduce sequences several showing small solid; speaker, strong structure successful targeting therapeutic three-minute understanding vaccines variants very {font-style {font-weight â€" (Burnet (Monash (QIMR Adelaide, Agathe Ana Bamaga Berghofer Biosciences, Brown Canberra, Career FernÃ¡ndez-Sesma Fraser Health Hibma Immunity Importantly, Interactions Merilyn Microbiology Nguyen Paul Ruth STAT Travel Trobe Webster Wilson Zealand Zealand) Zealand. acid activity aim antigen authors bold broad cane chikungunya chronic close complex courier; cryo-electron demonstrating development. distinct droplet due effective either em; evolution expression, factors final future gender genome however, icosahedral identify immunity implications importance induced infection, infections. inflammatory inhibiting insect interfering investigate lead left mRNA machinery mammalian mechanisms memory miRNAs mice mouse mutant mutants nanopore native natural newly number obesity oral out platform possible presentation, previously produced protection pt;} received replicate report required residue resulting sample samples scientific screened sessions sfRNA short should signatures significantly site strain strategies. structures students suggesting thank then throughout treatment understand unique utility virus. virusâ€"host vitro within would years you â€œSuccessfully


--- title: Frequently Asked Questions (FAQ) h1: FAQ ---
Please see the Credits page! You can see the actual source code at GitHub.
Please Contact me!


Realtek High Definition Audio Driver Free Download Softlay
Download Realtek High Definition Audio Driver For Pc Windows Xp 7 8 8 1 All Pc Download
Realtek Hd Audio Driver Windows 10 64 Bit Free Download We Have Uploaded From Its Official Website Realtek H Device Driver Windows 10 Operating System Audio
Realtek Hd Audio Driver R2 74 Free Download
Realtek High Definition Audio Driver 2 82 Free Download For Windows 10 8 And 7 Filecroco Com
Realtek High Definition Audio Drivers For Xp Free Download
Realtek High Definition Audio Driver Free Download
Free Download Realtek High Definition Audio Driver 32 Bit 64 Bit
Download Realtek High Definition Audio Codec Driver For 2000 Xp 2003 V2 74


ngIf Demo
Condition met
Condition not met
ngFor Demo
People
Monsters
-
{{ i }} - {{ monster.name }}: {{ monster.location }}
GODZILLA!
Not Godzilla
ngSwitch Demo
Is it day or night?
It's night time!
It's day time!
I don't know what time it is, there aren't any windows in this room.


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--java.awt.Component | +--java.awt.Container | +--javax.swing.JComponent | +--javax.swing.JTree | +--cb.util.PetalTree
Display petal file in JTree. The tooltip text displays the property name, if the currently selected node is a child of a PetalObject.
| Inner classes inherited from class javax.swing.JTree |
javax.swing.JTree.AccessibleJTree,
javax.swing.JTree.DynamicUtilTreeNode,
javax.swing.JTree.EmptySelectionModel,
javax.swing.JTree.TreeModelHandler,
javax.swing.JTree.TreeSelectionRedirector |
| Inner classes inherited from class javax.swing.JComponent |
javax.swing.JComponent.AccessibleJComponent |
| Field Summary | |
protected static javax.swing.ImageIcon |
CLOSED_ICON
|
protected static javax.swing.ImageIcon |
LEAF_ICON
|
protected static javax.swing.ImageIcon |
MINUS_ICON
|
protected static javax.swing.ImageIcon |
OPENED_ICON
|
protected static javax.swing.ImageIcon |
PLUS_ICON
|
| Fields inherited from class javax.swing.JTree |
CELL_EDITOR_PROPERTY,
CELL_RENDERER_PROPERTY,
cellEditor,
cellRenderer,
editable,
EDITABLE_PROPERTY,
INVOKES_STOP_CELL_EDITING_PROPERTY,
invokesStopCellEditing,
LARGE_MODEL_PROPERTY,
largeModel,
ROOT_VISIBLE_PROPERTY,
rootVisible,
ROW_HEIGHT_PROPERTY,
rowHeight,
SCROLLS_ON_EXPAND_PROPERTY,
scrollsOnExpand,
SELECTION_MODEL_PROPERTY,
selectionModel,
selectionRedirector,
SHOWS_ROOT_HANDLES_PROPERTY,
showsRootHandles,
toggleClickCount,
TREE_MODEL_PROPERTY,
treeModel,
treeModelListener,
VISIBLE_ROW_COUNT_PROPERTY,
visibleRowCount |
| Fields inherited from class javax.swing.JComponent |
accessibleContext,
listenerList,
TOOL_TIP_TEXT_KEY,
ui,
UNDEFINED_CONDITION,
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
WHEN_FOCUSED,
WHEN_IN_FOCUSED_WINDOW |
| Fields inherited from class java.awt.Component |
BOTTOM_ALIGNMENT,
CENTER_ALIGNMENT,
LEFT_ALIGNMENT,
RIGHT_ALIGNMENT,
TOP_ALIGNMENT |
| Constructor Summary | |
PetalTree(PetalFile tree)
|
| Method Summary | |
java.lang.String |
getToolTipText(java.awt.event.MouseEvent e)
|
| Methods inherited from class javax.swing.JTree |
addSelectionInterval,
addSelectionPath,
addSelectionPaths,
addSelectionRow,
addSelectionRows,
addTreeExpansionListener,
addTreeSelectionListener,
addTreeWillExpandListener,
cancelEditing,
clearSelection,
clearToggledPaths,
collapsePath,
collapseRow,
convertValueToText,
createTreeModel,
createTreeModelListener,
expandPath,
expandRow,
fireTreeCollapsed,
fireTreeExpanded,
fireTreeWillCollapse,
fireTreeWillExpand,
fireValueChanged,
getAccessibleContext,
getCellEditor,
getCellRenderer,
getClosestPathForLocation,
getClosestRowForLocation,
getDefaultTreeModel,
getDescendantToggledPaths,
getEditingPath,
getExpandedDescendants,
getInvokesStopCellEditing,
getLastSelectedPathComponent,
getLeadSelectionPath,
getLeadSelectionRow,
getMaxSelectionRow,
getMinSelectionRow,
getModel,
getPathBetweenRows,
getPathBounds,
getPathForLocation,
getPathForRow,
getPreferredScrollableViewportSize,
getRowBounds,
getRowCount,
getRowForLocation,
getRowForPath,
getRowHeight,
getScrollableBlockIncrement,
getScrollableTracksViewportHeight,
getScrollableTracksViewportWidth,
getScrollableUnitIncrement,
getScrollsOnExpand,
getSelectionCount,
getSelectionModel,
getSelectionPath,
getSelectionPaths,
getSelectionRows,
getShowsRootHandles,
getUI,
getUIClassID,
getVisibleRowCount,
hasBeenExpanded,
isCollapsed,
isCollapsed,
isEditable,
isEditing,
isExpanded,
isExpanded,
isFixedRowHeight,
isLargeModel,
isPathEditable,
isPathSelected,
isRootVisible,
isRowSelected,
isSelectionEmpty,
isVisible,
makeVisible,
paramString,
removeDescendantToggledPaths,
removeSelectionInterval,
removeSelectionPath,
removeSelectionPaths,
removeSelectionRow,
removeSelectionRows,
removeTreeExpansionListener,
removeTreeSelectionListener,
removeTreeWillExpandListener,
scrollPathToVisible,
scrollRowToVisible,
setCellEditor,
setCellRenderer,
setEditable,
setExpandedState,
setInvokesStopCellEditing,
setLargeModel,
setModel,
setRootVisible,
setRowHeight,
setScrollsOnExpand,
setSelectionInterval,
setSelectionModel,
setSelectionPath,
setSelectionPaths,
setSelectionRow,
setSelectionRows,
setShowsRootHandles,
setUI,
setVisibleRowCount,
startEditingAtPath,
stopEditing,
treeDidChange,
updateUI |
| Methods inherited from class javax.swing.JComponent |
addAncestorListener,
addNotify,
addPropertyChangeListener,
addPropertyChangeListener,
addVetoableChangeListener,
computeVisibleRect,
contains,
createToolTip,
firePropertyChange,
firePropertyChange,
firePropertyChange,
firePropertyChange,
firePropertyChange,
firePropertyChange,
firePropertyChange,
firePropertyChange,
firePropertyChange,
fireVetoableChange,
getActionForKeyStroke,
getAlignmentX,
getAlignmentY,
getAutoscrolls,
getBorder,
getBounds,
getClientProperty,
getComponentGraphics,
getConditionForKeyStroke,
getDebugGraphicsOptions,
getGraphics,
getHeight,
getInsets,
getInsets,
getLocation,
getMaximumSize,
getMinimumSize,
getNextFocusableComponent,
getPreferredSize,
getRegisteredKeyStrokes,
getRootPane,
getSize,
getToolTipLocation,
getToolTipText,
getTopLevelAncestor,
getVisibleRect,
getWidth,
getX,
getY,
grabFocus,
hasFocus,
isDoubleBuffered,
isFocusCycleRoot,
isFocusTraversable,
isLightweightComponent,
isManagingFocus,
isOpaque,
isOptimizedDrawingEnabled,
isPaintingTile,
isRequestFocusEnabled,
isValidateRoot,
paint,
paintBorder,
paintChildren,
paintComponent,
paintImmediately,
paintImmediately,
print,
printAll,
processComponentKeyEvent,
processFocusEvent,
processKeyEvent,
processMouseMotionEvent,
putClientProperty,
registerKeyboardAction,
registerKeyboardAction,
removeAncestorListener,
removeNotify,
removePropertyChangeListener,
removePropertyChangeListener,
removeVetoableChangeListener,
repaint,
repaint,
requestDefaultFocus,
requestFocus,
resetKeyboardActions,
reshape,
revalidate,
scrollRectToVisible,
setAlignmentX,
setAlignmentY,
setAutoscrolls,
setBackground,
setBorder,
setDebugGraphicsOptions,
setDoubleBuffered,
setEnabled,
setFont,
setForeground,
setMaximumSize,
setMinimumSize,
setNextFocusableComponent,
setOpaque,
setPreferredSize,
setRequestFocusEnabled,
setToolTipText,
setUI,
setVisible,
unregisterKeyboardAction,
update |
| Methods inherited from class java.awt.Container |
add,
add,
add,
add,
add,
addContainerListener,
addImpl,
countComponents,
deliverEvent,
doLayout,
findComponentAt,
findComponentAt,
getComponent,
getComponentAt,
getComponentAt,
getComponentCount,
getComponents,
getLayout,
insets,
invalidate,
isAncestorOf,
layout,
list,
list,
locate,
minimumSize,
paintComponents,
preferredSize,
printComponents,
processContainerEvent,
processEvent,
remove,
remove,
removeAll,
removeContainerListener,
setCursor,
setLayout,
validate,
validateTree |
| Methods inherited from class java.awt.Component |
action,
add,
addComponentListener,
addFocusListener,
addInputMethodListener,
addKeyListener,
addMouseListener,
addMouseMotionListener,
bounds,
checkImage,
checkImage,
coalesceEvents,
contains,
createImage,
createImage,
disable,
disableEvents,
dispatchEvent,
enable,
enable,
enableEvents,
enableInputMethods,
getBackground,
getBounds,
getColorModel,
getComponentOrientation,
getCursor,
getDropTarget,
getFont,
getFontMetrics,
getForeground,
getInputContext,
getInputMethodRequests,
getLocale,
getLocation,
getLocationOnScreen,
getName,
getParent,
getPeer,
getSize,
getToolkit,
getTreeLock,
gotFocus,
handleEvent,
hide,
imageUpdate,
inside,
isDisplayable,
isEnabled,
isLightweight,
isShowing,
isValid,
isVisible,
keyDown,
keyUp,
list,
list,
list,
location,
lostFocus,
mouseDown,
mouseDrag,
mouseEnter,
mouseExit,
mouseMove,
mouseUp,
move,
nextFocus,
paintAll,
postEvent,
prepareImage,
prepareImage,
processComponentEvent,
processInputMethodEvent,
processMouseEvent,
remove,
removeComponentListener,
removeFocusListener,
removeInputMethodListener,
removeKeyListener,
removeMouseListener,
removeMouseMotionListener,
repaint,
repaint,
repaint,
resize,
resize,
setBounds,
setBounds,
setComponentOrientation,
setDropTarget,
setLocale,
setLocation,
setLocation,
setName,
setSize,
setSize,
show,
show,
size,
toString,
transferFocus |
| Methods inherited from class java.lang.Object |
clone,
equals,
finalize,
getClass,
hashCode,
notify,
notifyAll,
wait,
wait,
wait |
| Field Detail |
protected static final javax.swing.ImageIcon PLUS_ICON
protected static final javax.swing.ImageIcon MINUS_ICON
protected static final javax.swing.ImageIcon OPENED_ICON
protected static final javax.swing.ImageIcon CLOSED_ICON
protected static final javax.swing.ImageIcon LEAF_ICON
| Constructor Detail |
public PetalTree(PetalFile tree)
| Method Detail |
public java.lang.String getToolTipText(java.awt.event.MouseEvent e)
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Review and explore the elements deeper.
Hover over the grid to highlight groupings.
Click on individual cells to go to MDN's reference pages.
SYST10049 Web Development
@2021-2022 Sheridan College
SYST10049 Web Development
@2021-2022 Sheridan College
SYST10049 Web Development
@2021-2022 Sheridan College
SYST10949 Web Development
@2021 Sheridan College
SYST10949 Web Development
@2021 Sheridan College