Milan defeated Lazio 5-4 in a sudden death penalty shoot-out to progress through to the Coppa Italia Final against Juventus.
Gianluigi Donnarumma (8): Didn't have his best game for Milan, but made up for it in the penalty shoot-out saving two penalties in fantastic fashion from Sergej Milinković-Savić and Lucas Leiva.
Ricardo Rodríguez (6): A bad night for the Swiss International who looked off the pace, and missed his penalty in the shoot-out as well.
Alessio Romagnoli (8.5): Milan's best player on the night with another word-class performance. He was first to everything and made a last second sliding tackle on Milinković-Savić to ensure the score remained at 0-0. Cooly scored his penalty to send Milan into the final to top off his performance.
Leonardo Bonucci (7.5): Had a good battle with the in-form Immobile and didn't allow him to score. Solid again and produced some good passes. Slotted in his penalty in the shoot-out.
Davide Calabria (8): Dealt well with the threat of Lulić and Luis Alberto and put in a great shift at right back, and made some very important challenges for Milan during the 120 minutes played.
Giacomo Bonaventura (6): A standard performance from Bonaventura, but he will be disappointed that he wasn't able to have enough influence on the game. Scored his penalty in the shoot-out.
Lucas Biglia (5.5.): Not his finest performance and the former Lazio player looked off the pace and gave the ball away on numerous occasions. Lazio's high press caused problems for him and he was unable to pass the ball around as much as he would have hoped.
Franck Kessié (5.5): Couldn't dominate the midfield like he normally does. Picked up an unnecessary booking when he threw the ball in frustration.
Hakan Çalhanoglu (6): Was the busiest out of the Milan front three but he didn't produce anything of note. Scored a good penalty in the shoot-out though.
Patrick Cutrone (5): Didn't receive enough service to cause the Lazio defence a lot of trouble and his first touch was poor.
Suso (5.5): Had a great chance early in the first half when he glided past two Lazio players and forced Strakosha into a good save, besides this he was kept quiet.
Nikola Kalinić (4): Replaced Cutrone as Milan were lacking any threat in attack, but the Croatian International was shambolic when he came on. Lacked a first touch and missed the easiest chance he's had all season to score the winner for the Rossoneri 118 minutes into the game but blasted his shot over the bar.
Riccardo Montolivo (4): Replaced Kessié in extra-time and had no impact on the game. Missed his penalty in the shoot-out.
Fabio Borini (6): Came on for Suso during extra-time and was involved in the move that should have resulted in Kalinić scoring the winner, nevertheless Borini stepped up and scored an impressive penalty in the shoot-out.


text:
Salary of Quantum Computing Engineer
Salary of a Quantum Computing Engineer in India (INR)
Salary of a Quantum Computing Engineer in Singapore (SGD)
Salary of a Quantum Computing Engineer in the USA (USD)
Salary of a Quantum Computing Engineer in Britain (GBP)
Salary of a Quantum Computing Engineer in Europe (EURO)
Salary of a Quantum Computing Engineer in Australia (AUD)
A fast-developing technology called quantum computing uses the principles of quantum physics to solve issues that are too complicated for conventional computers. Engineers and researchers mostly use supercomputers for resolving challenging tasks. These enormous classical computers frequently have thousands of cores for both the CPU and GPU. However, some types of issues are complex for even supercomputers to solve.
When a supercomputer struggles, it's often due to the sizeable classical machine given a challenging problem. Complexity is commonly to blame for the failure of traditional computers. Multiple variables that interact in intricate ways are considered complex issues. Because there are so many different electrons interacting with one another, modeling the behavior of individual atoms in a molecule is a challenging task. It is difficult to determine the best paths for a few 100 tankers in a vast transportation network.
Taking the helm of projects that support the team's and the company's expansion.
Engaging and working with other teams to improve synergy and offer new development opportunities.
Managing and guiding the project's resources.
Coordinate the teams' interactions and project delivery.
Explore novel analytic techniques as soon as possible, then assess their practical and commercial feasibility.
Build solid evidence and prototype models during sprint cycles to demonstrate and present to data scientists, internal stakeholders, and clients.
Try things out, fail rapidly, and learn to tell when you need help versus when technology isn't right for the job.
Due to their ability to test multiple solutions at once, quantum computers are substantially faster than traditional computers at solving problems. They aid in the resolution of intractable issues.
Due to this, quantum computing is the ideal technology to drive artificial intelligence. AI systems need a lot of computational capacity to handle the large volumes of data they process. For AI to fully realize its potential, quantum computers can supply that power. Hence the technology holds good future scope.
5 LPA
11 LPA
Salary of Back-End Developer
Salary of ServiceNow Developer
Salary of Cloud Computing Engineer
Salary of a Computer Engineer
Salary of SQL Developer
Salary of DevOps Engineer
Salary of Big Data Engineer
Salary of a Software Engineer
Salary of a Software Developer

redpajama_set_name: RedPajamaCommonCrawl


What's next for data breach legislation?
This piece originally appeared on POLITICO on September 4, 2018.
A BREACH OVER DATA BREACH — Amid a years-long standoff between rival industries and committees over federal data breach notification legislation, one House panel is plotting a move to go it alone — at least in the short run. Sometime this month, the House Financial Services panel might consider data breach notification and security legislation that applies only to the banking sector, a GOP committee aide told MC. The panel has been locked in an impasse with the House Energy and Commerce Committee, which has jurisdiction over the retail industry. That panel has typically written legislation more favorable to that sector; retailers have resisted proposals to make it adhere to the same security requirements as the financial services industry. Now, the Financial Services Committee wants to make some headway even if it has to do it by itself, using a modified existing draft bill written by Rep. Blaine Luetkeymeyer as a vehicle, the aide said.
WHY CAN'T WE BE FRIENDS — Perhaps you've read about the National Association of Secretaries of State bashing DEF CON, and DEF CON firing back, over its vote-hacking village last month. The bad blood is authentic, but it conceals a surprising development, Tim writes for Pros: The relationship between state and local election officials and ethical hackers is improving. "We've seen a 10-fold increase in participation from both state and local election officials since last year," Jake Braun, who organized DEF CON's Voting Village, told POLITICO following the conference. "We see a dramatic uptick on buy-in." Those who participated this year say they've seen the sentiment spread, that hackers can be helpful to exposing flaws in equipment despite all the unpleasant headlines they generate. "I would rather have vulnerabilities that might exist in election process today or next year identified by enthusiastic attendees at DEF CON than identified on election day after we've had an issue," said Amber McReynolds, who attended DEF CON as director of elections for the city and county of Denver. Read more here.
And the White House? "Here's the best indication I have about our relationship with the president: he meets with us regularly," Gordon said. "We are in the meetings, we are in the conversations. Probably this president has more consistently met with the intelligence community than the previous one in person. Just like every president that I've seen, there are days that we please him, but most often than not we're the people who depress him when we come in the room to tell him the things that are going on in the world." Read the full Q & A here.
HOUSE SET TO MOVE CYBER LEGISLATION — The House today will vote on two cybersecurity bills, one on global supply chain risks and another on DHS's Continuous Diagnostics and Mitigation program. The CDM bill (H.R. 6443),sponsored by Rep. John Ratcliffe, would require DHS to develop a strategy for the long-term, multibillion dollar program that helps protect federal agencies. The supply chain bill (H.R. 6430), sponsored by Republican Rep. Peter King, would give DHS more power to impose requirements on foreign-connected suppliers who pose potential security risks, but not as much as the Trump administration is seeking. This week is also expected to bring consideration of legislation (H.R. 5576) sponsored by Republican Rep. Ted Yoho that would set up a process for the executive branch to detect, respond to and deter state-sponsored cyber threats.
IF YOU'VE GOT IT, FLEX IT — Unclear lines of authority and rarely exercised oversight powers could slow down a response to a devastating cyberattack on critical infrastructure, according to a new report from the Intelligence and National Security Alliance. "The regulatory authorities and policy guidelines pertinent to cyber emergencies are complex and relatively new," the report notes in its introduction. "Consequently, they should be exercised regularly by the Department of Homeland Security (DHS), state and local officials, and their private sector partners." That was one of several high-level takeaways from a November 2017 cyberattack simulation that brought together officials from several utilities in the Baltimore region. One of the other recommendations: Better clarity around the "safe harbor" provisions that give companies legal immunity for good-faith actions taken during an emergency. The report also urged governors to designate a "Unified Incident Commander" who can take charge of state-level response activities and coordinate with federal agencies.
WHILE WE WERE ON BREAK — Here's what we wrote about for Pros while the newsletter was taking a hiatus: ES&S criticized DEF CON anew, and some Senate members weren't pleased. … The FBI disputed a right-wing outlet's account that Chinese hackers penetrated Hillary Clinton's email server. … The FBI launched a website offering campaigns security advice. … Sens. Kamala Harris and Bernie Sanders got on board with an election security measure. … House Energy and Commerce leader made recommendations for improving a DHS vulnerability database. … "Industrial consumers of natural gas want Congress to ensure natural gas pipelines are protected against cyberattacks." … The Senate confirmed Karen Evans to lead the Energy Department's new cyber shop. … Barracuda Networks found that business email compromise scammers rarely used dicey links to lure victims.
The U.S. and its closest intel allies warned companies against deploying end-to-end encryption if they wanted to avoid a legislative fight. … NATO named a new director of its cyber research center. … An international group called on Congress to pass any election security legislation at all. … Estonia created a "cyber ambassador" role. … Germany is establishing a DARPA-style research agency for cyber. … Recorded Future determined that spam emails dropped off after implementation of Europe's data privacy regulation.
FRIEND SUGGESTIONS — DHS and the FBI should work more closely with social media companies to clear their platforms of potential election meddlers, according to bipartisan pair of senators. "Intelligence officials have made it clear that social media platforms will continue to be targets used to spread misinformation and sow discord," Sens. Amy Klobuchar and Dan Sullivan wrote Friday in a letter to Homeland Secretary Kirstjen Nielsen and FBI Director Chris Wray. "Accordingly, we believe these threats require DHS and the FBI to work to ensure that there are open lines of communication between digital platforms and federal agencies in order to combat attacks against our political system." The missive comes ahead of the Senate Intelligence Committee open hearing with testimony expected from top executives of Twitter, and Facebook and Alphabet, Google's parent company.
NO TIME TO WASTE — IoT security represents a major gap in the federal government's regulation of consumer and business technology, according to a paper by two cyber experts, one of them a former NSA IoT researcher. "The federal government lacks clear and consistent policies on educating civil servants, contractors, and other employees who interact with IoT devices on a day-to-day basis," wrote Deb Crawford of North Carolina State University and Justin Sherman of Duke University in a paper published Aug. 30 in the Journal of Cyber Policy.
The problem is especially acute, they wrote, in the federal procurement space: "The federal government has not specified the level of IoT security standard required to engage with private-sector contractors, nor have they specified the vetting process for purchasing foreign-made IoT devices. Federal agencies and contractors are thus left without clear IoT security guidance." The duo recommended that the Federal CIO Council "establish common criteria for services and products, and create security and privacy policies for government-wide IoT components," paired with security-focused changes to federal procurement rules.
TWEET OF THE DAY — An undercovered oversight.


text:
package com.sleepycat.je;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import com.sleepycat.je.dbi.DatabaseImpl;
import com.sleepycat.je.trigger.ReplicatedDatabaseTrigger;
import com.sleepycat.je.trigger.PersistentTrigger;
import com.sleepycat.je.trigger.Trigger;

/**
 *
Specifies the attributes of a database.

 *
 *
There are two groups of database attributes: per-database handle
 * attributes, and database-wide attributes. An attribute may be
 * persistent/transient or mutable/immutable:

 *
 *

 *

 *     Scope
 *     Mutable
 *     Persistent
 *     Attribute
 *

 *

 *     Database-wide attribute
 *     True
 *     True
 *     {@link DatabaseConfig#getBtreeComparator() btree comparator}

 *         {@link DatabaseConfig#getDuplicateComparator() duplicate comparator}

 *         {@link DatabaseConfig#getKeyPrefixing() key prefixing}

 *         {@link DatabaseConfig#getNodeMaxEntries() nodeMaxEntries}

 *
 *

 *

 *     True
 *     False
 *     {@link DatabaseConfig#getDeferredWrite() deferred write}

 *         {@link DatabaseConfig#getTransactional() transactional}

 *

 *

 *     False
 *     True
 *
 *         {@link DatabaseConfig#getSortedDuplicates() sorted duplicates}

 *
 *

 *

 *     False
 *     False
 *     {@link DatabaseConfig#getTemporary() temporary}
 *

 *

 *     Per-database handle attributes
 *     False
 *     False
 *     {@link DatabaseConfig#getAllowCreate() allow create}

 *         {@link DatabaseConfig#getExclusiveCreate() exclusive create}

 *         {@link DatabaseConfig#getReadOnly() read only}

 *         {@link DatabaseConfig#getUseExistingConfig() use existing config}

 *
 *

 *

 *

 *
 *
Persistent attributes will be saved in the log and remain in effect
 * every time the environment is reopened. Transient attributes only remain
 * in effect until:

 *
 *

 *
the database configuration is updated

 *
the database handle(per-database handle attributes) is closed, or all
 * handles for this database (database-wide attributes) are closed.

 *

 */
public class DatabaseConfig implements Cloneable {

    /**
     * An instance created using the default constructor is initialized with
     * the system's default settings.
     */
    public static final DatabaseConfig DEFAULT = new DatabaseConfig();

    private boolean allowCreate = false;
    private boolean exclusiveCreate = false;
    private boolean transactional = false;
    private boolean readOnly = false;
    private boolean sortedDuplicates = false;
    private boolean deferredWrite = false;
    private boolean temporary = false;
    private boolean keyPrefixing = false;
    private boolean replicated = true;

    private int nodeMaxEntries;
    private Comparator<byte[]> btreeComparator = null;
    private Comparator<byte[]> duplicateComparator = null;
    private boolean btreeComparatorByClassName = false;
    private boolean duplicateComparatorByClassName = false;
    private boolean overrideBtreeComparator = false;
    private boolean overrideDuplicateComparator = false;
    private boolean useExistingConfig = false;
    private CacheMode cacheMode = null;
    private CacheModeStrategy cacheModeStrategy = null;
    private SecondaryAssociation secAssociation = null;

    /* User defined triggers associated with this database. */
    private List<Trigger> triggers = new LinkedList<Trigger>();
    private boolean overrideTriggers;

    /**
     * An instance created using the default constructor is initialized with
     * the system's default settings.
     */
    public DatabaseConfig() {
    }

    /**
     * Configures the {@link com.sleepycat.je.Environment#openDatabase
     * Environment.openDatabase} method to create the database if it does not
     * already exist.
     *
     * @param allowCreate If true, configure the {@link
     * com.sleepycat.je.Environment#openDatabase Environment.openDatabase}
     * method to create the database if it does not already exist.
     *
     * @return this
     */
    public DatabaseConfig setAllowCreate(boolean allowCreate) {
        setAllowCreateVoid(allowCreate);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setAllowCreateVoid(boolean allowCreate) {
        this.allowCreate = allowCreate;
    }

    /**
     * Returns true if the {@link com.sleepycat.je.Environment#openDatabase
     * Environment.openDatabase} method is configured to create the database
     * if it does not already exist.
     *
     *
This method may be called at any time during the life of the
     * application.

     *
     * @return true if the {@link com.sleepycat.je.Environment#openDatabase
     * Environment.openDatabase} method is configured to create the database
     * if it does not already exist.
     */
    public boolean getAllowCreate() {
        return allowCreate;
    }

    /**
     * Configure the {@link com.sleepycat.je.Environment#openDatabase
     * Environment.openDatabase} method to fail if the database already exists.
     *
     *
The exclusiveCreate mode is only meaningful if specified with the
     * allowCreate mode.

     *
     * @param exclusiveCreate If true, configure the {@link
     * com.sleepycat.je.Environment#openDatabase Environment.openDatabase}
     * method to fail if the database already exists.
     *
     * @return this
     */
    public DatabaseConfig setExclusiveCreate(boolean exclusiveCreate) {
        setExclusiveCreateVoid(exclusiveCreate);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setExclusiveCreateVoid(boolean exclusiveCreate) {
        this.exclusiveCreate = exclusiveCreate;
    }

    /**
     * Returns true if the {@link com.sleepycat.je.Environment#openDatabase
     * Environment.openDatabase} method is configured to fail if the database
     * already exists.
     *
     *
This method may be called at any time during the life of the
     * application.

     *
     * @return true if the {@link com.sleepycat.je.Environment#openDatabase
     * Environment.openDatabase} method is configured to fail if the database
     * already exists.
     */
    public boolean getExclusiveCreate() {
        return exclusiveCreate;
    }

    /**
     * Configures the database to support records with duplicate keys.
     *
     *
When duplicate keys are configured for a database, key prefixing is
     * also implicitly configured.  Without key prefixing, databases with
     * duplicates would store keys inefficiently. Key prefixing is therefore
     * mandatory for databases with duplicates.

     *
     *
Although two records may have the same key, they may not also have
     * the same data item.  Two identical records, that have the same key and
     * data, may not be stored in a database.

     *
     *
The ordering of duplicates in the database is determined by the
     * duplicate comparison function.  See {@link #setDuplicateComparator}.  If
     * the application does not specify a duplicate comparison function, a
     * default lexical comparison will be used.

     *
     *
If a primary database is to be associated with one or more secondary
     * databases, it may not be configured for duplicates.

     *
     *
Calling this method affects the database, including all threads of
     * control accessing the database.

     *
     *
If the database already exists when the database is opened, any
     * database configuration specified by this method must be the same as the
     * existing database or an error will be returned.

     *
     * @param sortedDuplicates If true, configure the database to support
     * duplicate data items. A value of false is illegal to this method, that
     * is, once set, the configuration cannot be cleared.
     *
     * @return this
     */
    public DatabaseConfig setSortedDuplicates(boolean sortedDuplicates) {
        setSortedDuplicatesVoid(sortedDuplicates);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setSortedDuplicatesVoid(boolean sortedDuplicates) {
        this.sortedDuplicates = sortedDuplicates;
        if (sortedDuplicates) {
            setKeyPrefixingVoid(true);
        }
    }

    /**
     * Returns true if the database is configured to support records with
     * duplicate keys.
     *
     *
This method may be called at any time during the life of the
     * application.

     *
     * @return true if the database is configured to support records with
     * duplicate keys.
     */
    public boolean getSortedDuplicates() {
        return sortedDuplicates;
    }

    /**
     * Returns the key prefixing configuration.  Note that key prefixing is
     * always enabled for a database with duplicates configured.
     *
     * @return true if key prefixing has been enabled in this database.
     */
    public boolean getKeyPrefixing() {
        return keyPrefixing;
    }

    /**
     * Configure the database to support key prefixing. Key prefixing causes
     * the representation of keys in the b-tree internal nodes to be split
     * between the common prefix of all keys and the suffixes.  Using this
     * may result in a more space-efficient representation in both the
     * in-memory and on-disk formats, but at some possible performance cost.
     *
     *
When duplicate keys are configured for a database, key prefixing is
     * also implicitly configured.  Without key prefixing, databases with
     * duplicates would store keys inefficiently. Key prefixing is therefore
     * mandatory for databases with duplicates.

     *
     * @param keyPrefixing If true, enables keyPrefixing for the
     * database.
     *
     * @return this
     *
     * @throws IllegalStateException if the keyPrefixing argument is false and
     * {@link #setSortedDuplicates} has been called to configure duplicates.
     * Key prefixing is therefore mandatory for databases with duplicates.
     *
     */
    public DatabaseConfig setKeyPrefixing(boolean keyPrefixing) {
        setKeyPrefixingVoid(keyPrefixing);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setKeyPrefixingVoid(boolean keyPrefixing) {
        if (!keyPrefixing && sortedDuplicates) {
            throw new IllegalStateException
                ("Key prefixing is mandatory for databases with duplicates");
        }
        this.keyPrefixing = keyPrefixing;
    }

    /**
     * Encloses the database open within a transaction.
     *
     *
If the call succeeds, the open operation will be recoverable.  If the
     * call fails, no database will have been created.

     *
     *
All future operations on this database, which are not explicitly
     * enclosed in a transaction by the application, will be enclosed in in a
     * transaction within the library.

     *
     * @param transactional If true, enclose the database open within a
     * transaction.
     *
     * @return this
     */
    public DatabaseConfig setTransactional(boolean transactional) {
        setTransactionalVoid(transactional);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setTransactionalVoid(boolean transactional) {
        this.transactional = transactional;
    }

    /**
     * Returns true if the database open is enclosed within a transaction.
     *
     *
This method may be called at any time during the life of the
     * application.

     *
     * @return true if the database open is enclosed within a transaction.
     */
    public boolean getTransactional() {
        return transactional;
    }

    /**
     * Configures the database in read-only mode.
     *
     *
Any attempt to modify items in the database will fail, regardless of
     * the actual permissions of any underlying files.

     *
     * @param readOnly If true, configure the database in read-only mode.
     *
     * @return this
     */
    public DatabaseConfig setReadOnly(boolean readOnly) {
        setReadOnlyVoid(readOnly);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setReadOnlyVoid(boolean readOnly) {
        this.readOnly = readOnly;
    }

    /**
     * Returns true if the database is configured in read-only mode.
     *
     *
This method may be called at any time during the life of the
     * application.

     *
     * @return true if the database is configured in read-only mode.
     */
    public boolean getReadOnly() {
        return readOnly;
    }

    /**
     * Configures the {@link com.sleepycat.je.Environment#openDatabase
     * Environment.openDatabase} method to have a B+Tree fanout of
     * nodeMaxEntries.
     *
     *
The nodeMaxEntries parameter is only meaningful if specified with the
     * allowCreate mode. See {@link EnvironmentConfig#NODE_MAX_ENTRIES} for the
     * valid value range, and the default value.

     *
     * @param nodeMaxEntries The maximum children per B+Tree node.
     *
     * @return this
     */
    public DatabaseConfig setNodeMaxEntries(int nodeMaxEntries) {
        setNodeMaxEntriesVoid(nodeMaxEntries);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setNodeMaxEntriesVoid(int nodeMaxEntries) {
        this.nodeMaxEntries = nodeMaxEntries;
    }

    /**
     * @deprecated this property no longer has any effect; {@link
     * #setNodeMaxEntries} should be used instead.
     */
    public DatabaseConfig setNodeMaxDupTreeEntries(int nodeMaxDupTreeEntries) {
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setNodeMaxDupTreeEntriesVoid(int nodeMaxDupTreeEntries) {
    }

    /**
     * Returns the maximum number of children a B+Tree node can have.
     *
     *
This method may be called at any time during the life of the
     * application.

     *
     * @return The maximum number of children a B+Tree node can have.
     */
    public int getNodeMaxEntries() {
        return nodeMaxEntries;
    }

    /**
     * @deprecated this property no longer has any effect and zero is always
     * returned; {@link #getNodeMaxEntries} should be used instead.
     */
    public int getNodeMaxDupTreeEntries() {
        return 0;
    }

    /**
     * By default, a byte by byte lexicographic comparison is used for btree
     * keys. To customize the comparison, supply a different Comparator.
     *
     *
Note that there are two ways to set the comparator: by specifying the
     * class or by specifying a serializable object.  This method is used to
     * specify a serializable object.  The comparator class must implement
     * java.util.Comparator and must be serializable.  JE will serialize the
     * Comparator and deserialize it when subsequently opening the
     * database.

     *
     *
If a comparator needs to be initialized before it is used or needs
     * access to the environment's ClassLoader property, it may implement the
     * {@link DatabaseComparator} interface.

     *
     *
The Comparator.compare() method is passed the byte arrays that are
     * stored in the database. If you know how your data is organized in the
     * byte array, then you can write a comparison routine that directly
     * examines the contents of the arrays. Otherwise, you have to reconstruct
     * your original objects, and then perform the comparison.  See the Getting Started Guide for examples.

     *
     *
WARNING: There are several special considerations that must
     * be taken into account when implementing a comparator.

     *

     *
Comparator instances are shared by multiple threads and comparator
     *   methods are called without any special synchronization. Therefore,
     *   comparators must be thread safe.  In general no shared state should be
     *   used and any caching of computed values must be done with proper
     *   synchronization.

     *
     *
Because records are stored in the order determined by the
     *   Comparator, the Comparator's behavior must not change over time and
     *   therefore should not be dependent on any state that may change over
     *   time.  In addition, although it is possible to change the comparator
     *   for an existing database, care must be taken that the new comparator
     *   provides compatible results with the previous comparator, or database
     *   corruption will occur.

     *
     *
JE uses comparators internally in a wide variety of circumstances,
     *   so custom comparators must be sure to return valid values for any two
     *   arbitrary keys.  The user must not make any assumptions about the
     *   range of key values that might be compared. For example, it's possible
     *   for the comparator may be used against previously deleted values.

     *

     *
     *
A special type of comparator is a partial comparator, which
     * compares a proper subset (not all bytes) of the key.  A partial
     * comparator allows uniquely identifying a record by a partial key value.
     * For example, the key could contain multiple fields but could uniquely
     * identify the record with a single field.  The partial comparator could
     * then compare only the single identifying field.  A query ({@link
     * Cursor#getSearchKey Cursor.getSearchKey}, for example) could then be
     * performed by passing a partial key that contains only the identifying
     * field.

     *
     * The comparator for an existing database will not be overridden unless
     * setOverrideBtreeComparator() is set to true.
     *
     * @return this
     */
    public DatabaseConfig
        setBtreeComparator(Comparator<byte[]> btreeComparator) {

        setBtreeComparatorVoid(btreeComparator);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setBtreeComparatorVoid(Comparator<byte[]> btreeComparator) {

        /* Note: comparator may be null */
        this.btreeComparator = validateComparator(btreeComparator, "Btree");
        this.btreeComparatorByClassName = false;
    }

    /**
     * By default, a byte by byte lexicographic comparison is used for btree
     * keys. To customize the comparison, supply a different Comparator.
     *
     *
Note that there are two ways to set the comparator: by specifying the
     * class or by specifying a serializable object.  This method is used to
     * specify a Comparator class.  The comparator class must implement
     * java.util.Comparator and must have a public zero-parameter constructor.
     * JE will store the class name and instantiate the Comparator by class
     * name (using Class.forName and newInstance)
     * when subsequently opening the database.  Because the Comparator is
     * instantiated using its default constructor, it should not be dependent
     * on other constructor parameters.

     *
     *
The Comparator.compare() method is passed the byte arrays that are
     * stored in the database. If you know how your data is organized in the
     * byte array, then you can write a comparison routine that directly
     * examines the contents of the arrays. Otherwise, you have to reconstruct
     * your original objects, and then perform the comparison.  See the Getting Started Guide for examples.

     *
     *
If a comparator needs to be initialized before it is used or needs
     * access to the environment's ClassLoader property, it may implement the
     * {@link DatabaseComparator} interface.

     *
     *
WARNING: There are several special considerations that must
     * be taken into account when implementing a comparator.

     *

     *
Comparator instances are shared by multiple threads and comparator
     *   methods are called without any special synchronization. Therefore,
     *   comparators must be thread safe.  In general no shared state should be
     *   used and any caching of computed values must be done with proper
     *   synchronization.

     *
     *
Because records are stored in the order determined by the
     *   Comparator, the Comparator's behavior must not change over time and
     *   therefore should not be dependent on any state that may change over
     *   time.  In addition, although it is possible to change the comparator
     *   for an existing database, care must be taken that the new comparator
     *   provides compatible results with the previous comparator, or database
     *   corruption will occur.

     *
     *
JE uses comparators internally in a wide variety of circumstances,
     *   so custom comparators must be sure to return valid values for any two
     *   arbitrary keys.  The user must not make any assumptions about the
     *   range of key values that might be compared. For example, it's possible
     *   for the comparator may be used against previously deleted values.

     *

     *
     *
A special type of comparator is a partial comparator, which
     * compares a proper subset (not all bytes) of the key.  A partial
     * comparator allows uniquely identifying a record by a partial key value.
     * For example, the key could contain multiple fields but could uniquely
     * identify the record with a single field.  The partial comparator could
     * then compare only the single identifying field.  A query ({@link
     * Cursor#getSearchKey Cursor.getSearchKey}, for example) could then be
     * performed by passing a partial key that contains only the identifying
     * field.

     *
     * The comparator for an existing database will not be overridden unless
     * setOverrideBtreeComparator() is set to true.
     *
     * @return this
     */
    public DatabaseConfig
        setBtreeComparator(Class<? extends Comparator<byte[]>>
                           btreeComparatorClass) {

        setBtreeComparatorVoid(btreeComparatorClass);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setBtreeComparatorVoid(Class<? extends Comparator<byte[]>>
                                       btreeComparatorClass) {

        /* Note: comparator may be null */
        this.btreeComparator = validateComparator(btreeComparatorClass,
                                                  "Btree");
        this.btreeComparatorByClassName = true;
    }

    /**
     * Returns the Comparator used for key comparison on this database.
     */
    public Comparator<byte[]> getBtreeComparator() {
        return btreeComparator;
    }

    /**
     * Returns true if the btree comparator is set by class name, not by
     * serializable Comparator object
     * @return true if the comparator is set by class name, not by serializable
     * Comparator object.
     */
    public boolean getBtreeComparatorByClassName() {
        return btreeComparatorByClassName;
    }

    /**
     * Sets to true if the database exists and the btree comparator specified
     * in this configuration object should override the current comparator.
     *
     * @param override Set to true to override the existing comparator.
     *
     * @return this
     */
    public DatabaseConfig setOverrideBtreeComparator(boolean override) {
        setOverrideBtreeComparatorVoid(override);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setOverrideBtreeComparatorVoid(boolean override) {
        overrideBtreeComparator = override;
    }

    /**
     * Returns the override setting for the btree comparator.
     */
    public boolean getOverrideBtreeComparator() {
        return overrideBtreeComparator;
    }

    /**
     * By default, a byte by byte lexicographic comparison is used for
     * duplicate data items in a duplicate set.  To customize the comparison,
     * supply a different Comparator.
     *
     *
Note that there are two ways to set the comparator: by specifying the
     * class or by specifying a serializable object.  This method is used to
     * specify a serializable object.  The comparator class must implement
     * java.util.Comparator and must be serializable.  JE will serialize the
     * Comparator and deserialize it when subsequently opening the
     * database.

     *
     *
The Comparator.compare() method is passed the byte arrays that are
     * stored in the database. If you know how your data is organized in the
     * byte array, then you can write a comparison routine that directly
     * examines the contents of the arrays. Otherwise, you have to reconstruct
     * your original objects, and then perform the comparison.  See the Getting Started Guide for examples.

     *
     *
If a comparator needs to be initialized before it is used or needs
     * access to the environment's ClassLoader property, it may implement the
     * {@link DatabaseComparator} interface.

     *
     *
WARNING: There are several special considerations that must
     * be taken into account when implementing a comparator.

     *

     *
Comparator instances are shared by multiple threads and comparator
     *   methods are called without any special synchronization. Therefore,
     *   comparators must be thread safe.  In general no shared state should be
     *   used and any caching of computed values must be done with proper
     *   synchronization.

     *
     *
Because records are stored in the order determined by the
     *   Comparator, the Comparator's behavior must not change over time and
     *   therefore should not be dependent on any state that may change over
     *   time.  In addition, although it is possible to change the comparator
     *   for an existing database, care must be taken that the new comparator
     *   provides compatible results with the previous comparator, or database
     *   corruption will occur.

     *
     *
JE uses comparators internally in a wide variety of circumstances,
     *   so custom comparators must be sure to return valid values for any two
     *   arbitrary keys.  The user must not make any assumptions about the
     *   range of key values that might be compared. For example, it's possible
     *   for the comparator may be used against previously deleted values.

     *

     *
     *
A special type of comparator is a partial comparator, which
     * is a comparator that compares a proper subset (not all bytes) of the
     * data.  A partial comparator allows uniquely identifying a record within
     * a duplicate set by a partial data value.  For example, the data could
     * contain multiple fields but could uniquely identify the record with a
     * single field.  The partial comparator could then compare only the single
     * identifying field.  A query ({@link Cursor#getSearchBoth
     * Cursor.getSearchBoth}, for example) could then be performed by passing a
     * partial data value that contains only the identifying field.

     *
     *
When using a partial comparator, it is possible to update the data
     * for a duplicate record, as long as only the non-identifying fields in
     * the data are changed.  See {@link Cursor#putCurrent Cursor.putCurrent}
     * for more information.

     *
     * The comparator for an existing database will not be overridden unless
     * setOverrideDuplicateComparator() is set to true.
     */
    public DatabaseConfig
        setDuplicateComparator(Comparator<byte[]> duplicateComparator) {

        /* Note: comparator may be null */
        setDuplicateComparatorVoid(duplicateComparator);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setDuplicateComparatorVoid(Comparator<byte[]>
                                           duplicateComparator) {

        /* Note: comparator may be null */
        this.duplicateComparator =
            validateComparator(duplicateComparator, "Duplicate");
        this.duplicateComparatorByClassName = false;
    }

    /**
     * By default, a byte by byte lexicographic comparison is used for
     * duplicate data items in a duplicate set.  To customize the comparison,
     * supply a different Comparator.
     *
     *
Note that there are two ways to set the comparator: by specifying the
     * class or by specifying a serializable object.  This method is used to
     * specify a Comparator class.  The comparator class must implement
     * java.util.Comparator and must have a public zero-parameter constructor.
     * JE will store the class name and instantiate the Comparator by class
     * name (using Class.forName and newInstance)
     * when subsequently opening the database.  Because the Comparator is
     * instantiated using its default constructor, it should not be dependent
     * on other constructor parameters.

     *
     *
The Comparator.compare() method is passed the byte arrays that are
     * stored in the database. If you know how your data is organized in the
     * byte array, then you can write a comparison routine that directly
     * examines the contents of the arrays. Otherwise, you have to reconstruct
     * your original objects, and then perform the comparison.  See the Getting Started Guide for examples.

     *
     *
If a comparator needs to be initialized before it is used or needs
     * access to the environment's ClassLoader property, it may implement the
     * {@link DatabaseComparator} interface.

     *
     *
WARNING: There are several special considerations that must
     * be taken into account when implementing a comparator.

     *

     *
Comparator instances are shared by multiple threads and comparator
     *   methods are called without any special synchronization. Therefore,
     *   comparators must be thread safe.  In general no shared state should be
     *   used and any caching of computed values must be done with proper
     *   synchronization.

     *
     *
Because records are stored in the order determined by the
     *   Comparator, the Comparator's behavior must not change over time and
     *   therefore should not be dependent on any state that may change over
     *   time.  In addition, although it is possible to change the comparator
     *   for an existing database, care must be taken that the new comparator
     *   provides compatible results with the previous comparator, or database
     *   corruption will occur.

     *
     *
JE uses comparators internally in a wide variety of circumstances,
     *   so custom comparators must be sure to return valid values for any two
     *   arbitrary keys.  The user must not make any assumptions about the
     *   range of key values that might be compared. For example, it's possible
     *   for the comparator may be used against previously deleted values.

     *

     *
     *
A special type of comparator is a partial comparator, which
     * is a comparator that compares a proper subset (not all bytes) of the
     * data.  A partial comparator allows uniquely identifying a record within
     * a duplicate set by a partial data value.  For example, the data could
     * contain multiple fields but could uniquely identify the record with a
     * single field.  The partial comparator could then compare only the single
     * identifying field.  A query ({@link Cursor#getSearchBoth
     * Cursor.getSearchBoth}, for example) could then be performed by passing a
     * partial data value that contains only the identifying field.

     *
     *
When using a partial comparator, it is possible to update the data
     * for a duplicate record, as long as only the non-identifying fields in
     * the data are changed.  See {@link Cursor#putCurrent Cursor.putCurrent}
     * for more information.

     *
     * The comparator for an existing database will not be overridden unless
     * setOverrideDuplicateComparator() is set to true.
     *
     * @return this
     */
    public DatabaseConfig
        setDuplicateComparator(Class<? extends Comparator<byte[]>>
                               duplicateComparatorClass) {

        setDuplicateComparatorVoid(duplicateComparatorClass);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setDuplicateComparatorVoid(Class<? extends Comparator<byte[]>>
                                           duplicateComparatorClass) {

        /* Note: comparator may be null */
        this.duplicateComparator =
            validateComparator(duplicateComparatorClass, "Duplicate");
        this.duplicateComparatorByClassName = true;
    }

    /**
     * Returns the Comparator used for duplicate record comparison on this
     * database.
     */
    public Comparator<byte[]> getDuplicateComparator() {
        return duplicateComparator;
    }

    /**
     * Returns true if the duplicate comparator is set by class name, not by
     * serializable Comparator object.
     *
     * @return true if the duplicate comparator is set by class name, not by
     * serializable Comparator object.
     */
    public boolean getDuplicateComparatorByClassName() {
        return duplicateComparatorByClassName;
    }

    /**
     * Sets to true if the database exists and the duplicate comparator
     * specified in this configuration object should override the current
     * comparator.
     *
     * @param override Set to true to override the existing comparator.
     *
     * @return this
     */
    public DatabaseConfig setOverrideDuplicateComparator(boolean override) {
        setOverrideDuplicateComparatorVoid(override);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setOverrideDuplicateComparatorVoid(boolean override) {
        overrideDuplicateComparator = override;
    }

    /**
     * Returns the override setting for the duplicate comparator.
     */
    public boolean getOverrideDuplicateComparator() {
        return overrideDuplicateComparator;
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Specifies the list of triggers associated with the database; triggers
     * are executed in the order specified by this list.
     *

     * This configuration parameter is only meaningful when configuring a
     * Primary database.
     *

     * The type of the trigger specified in the list must match the type of
     * database being configured. For example, the trigger object must
     * implement the ReplicatedDatabaseTrigger interface if it's
     * used to configure a replicated database.
     *

     * Some of the incorrect uses of this parameter are detected during calls
     * to {@link Environment#openDatabase Environment.openDatabase} or
     * {@link Environment#openSecondaryDatabase
     * Environment.openSecondaryDatabase} and will result in an
     * IllegalArgumentException.
     *
     * @param triggers the list of database triggers to be associated with the
     * environment.
     *
     * @throws IllegalArgumentException If the triggers in the list do not have
     * unique names, have conflicting types (e.g. only a subset implement
     * {@link ReplicatedDatabaseTrigger ReplicatedDatabaseTrigger}), or do not
     * implement {@link ReplicatedDatabaseTrigger ReplicatedDatabaseTrigger}
     * for a replicated database.
     *
     * @return this
     */
    public DatabaseConfig setTriggers(List<Trigger> triggers) {
        setTriggersVoid(triggers);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setTriggersVoid(List<Trigger> triggers) {
        this.triggers = triggers;

        if ((triggers == null) || (triggers.size() == 0)) {
            return;
        }

        checkTriggers(triggers);
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Returns the list of configured database triggers.
     */
    public List<Trigger> getTriggers() {
        return triggers;
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Set to true if the database exists and the {@link PersistentTrigger}s in
     * the trigger list specified in this configuration object should override
     * those in the current list of triggers.  Note that any transient triggers
     * that are specified are always configured, because they do not override
     * existing triggers.
     *
     * @param override Set to true to override the existing comparator.
     *
     * @return this
     */
    public DatabaseConfig setOverrideTriggers(boolean override) {
        setOverrideTriggersVoid(override);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setOverrideTriggersVoid(boolean override) {
        overrideTriggers = override;
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Returns the override setting for triggers.
     */
    public boolean getOverrideTriggers() {
        return overrideTriggers;
    }

    /**
     * Sets the temporary database option.
     *
     *
 Temporary databases operate internally in deferred-write mode to
     * provide reduced disk I/O and increased concurrency.  But unlike an
     * ordinary deferred-write database, the information in a temporary
     * database is not durable or persistent.
     *
     *
 A temporary database is not flushed to disk when the database is
     * closed or when a checkpoint is performed, and the Database.sync method
     * may not be called.  When all handles for a temporary database are
     * closed, the database is automatically removed.  If a crash occurs before
     * closing a temporary database, the database will be automatically removed
     * when the environment is re-opened.
     *
     *
 Note that although temporary databases can page to disk if the cache
     * is not large enough to hold the databases, they are much more efficient
     * if the database remains in memory. See the JE FAQ on the Oracle
     * Technology Network site for information on how to estimate the cache
     * size needed by a given database.
     *
     *

     * See the {@link Getting
     * Started Guide, Database chapter} for a full description of temporary
     * databases.
     *

     * @param temporary if true, the database will be opened as a temporary
     * database.
     *
     * @return this
     */
    public DatabaseConfig setTemporary(boolean temporary) {
        setTemporaryVoid(temporary);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setTemporaryVoid(boolean temporary) {
        this.temporary = temporary;
    }

    /**
     * Returns the temporary database option.
     * @return boolean if true, the database is temporary.
     */
    public boolean getTemporary() {
        return temporary;
    }

    /**
     * Sets the deferred-write option.
     *
     *
 Deferred-write databases have reduced disk I/O and improved
     * concurrency.  Disk I/O is reduced when data records are frequently
     * modified or deleted.  The information in a deferred-write database is
     * not guaranteed to be durable or persistent until {@link Database#close}
     * or {@link Database#sync} is called, or a checkpoint is performed. Since
     * the usual write ahead logging system is relaxed in order to improve
     * performance, if the environment crashes before a {@link Database#sync}
     * or {@link Database#close}, none, all, or a unpredictable set of the
     * operations previously done may be persistent.
     *
     *
 After a deferred-write database is closed it may be re-opened as an
     * ordinary transactional or non-transactional database.  For example, this
     * can be used to initially load a large data set in deferred-write mode
     * and then switch to transactional mode for subsequent operations.
     *
     *
 Note that although deferred-write databases can page to disk if the
     * cache is not large enough to hold the databases, they are much more
     * efficient if the database remains in memory. See the JE FAQ on the
     * Oracle Technology Network site for information on how to estimate the
     * cache size needed by a given database.
     *
     *

     * See the {@link Getting
     * Started Guide, Database chapter} for a full description
     * of deferred-write databases.
     *
     *

     * @param deferredWrite if true, the database will be opened as a
     * deferred-write database.
     *
     * @return this
     */
    public DatabaseConfig setDeferredWrite(boolean deferredWrite) {
        setDeferredWriteVoid(deferredWrite);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setDeferredWriteVoid(boolean deferredWrite) {
        this.deferredWrite = deferredWrite;
    }

    /**
     * Returns the deferred-write option.
     *
     * @return boolean if true, deferred-write is enabled.
     */
    public boolean getDeferredWrite() {
        return deferredWrite;
    }

    /**
     * Used to set the comparator when filling in a configuration from an
     * existing database.
     */
    void setBtreeComparatorInternal(Comparator<byte[]> comparator,
                                    boolean byClassName) {
        btreeComparator = comparator;
        btreeComparatorByClassName = byClassName;
    }

    /**
     * Used to set the comparator when filling in a configuration from an
     * existing database.
     */
    void setDuplicateComparatorInternal(Comparator<byte[]> comparator,
                                        boolean byClassName) {
        duplicateComparator = comparator;
        duplicateComparatorByClassName = byClassName;
    }

    /**
     * Setting useExistingConfig to true allows a program to open a database
     * without knowing a prior what its configuration is.  For example, if you
     * want to open a database without knowing whether it contains sorted
     * duplicates or not, you can set this property to true.  In general, this
     * is used by the JE utilities, to avoid having to know the configuration
     * of a database.  The databases should be opened readOnly when this
     * property is set to true.
     *
     * @param useExistingConfig true if this Database should be opened using
     * the existing configuration.
     *
     * @return this
     */
    public DatabaseConfig setUseExistingConfig(boolean useExistingConfig) {
        setUseExistingConfigVoid(useExistingConfig);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setUseExistingConfigVoid(boolean useExistingConfig) {
        this.useExistingConfig = useExistingConfig;
    }

    /**
     * Return the value of the useExistingConfig property.
     *
     * @return the value of the useExistingConfig property.
     */
    public boolean getUseExistingConfig() {
        return useExistingConfig;
    }

    /**
     * Sets the default {@code CacheMode} used for operations performed on this
     * database.  If this property is non-null, it overrides the default
     * specified using {@link EnvironmentConfig#setCacheMode} for operations on
     * this database.  The default cache mode may be overridden on a per-record
     * or per-operation basis using {@link Cursor#setCacheMode}.
     *
     * @param cacheMode is the default {@code CacheMode} used for operations
     * performed on this database.  If {@code null} is specified, the
     * environment default will be used.
     *
     * @see CacheMode for further details.
     *
     * @since 4.0.97
     */
    public DatabaseConfig setCacheMode(final CacheMode cacheMode) {
        setCacheModeVoid(cacheMode);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setCacheModeVoid(final CacheMode cacheMode) {
        this.cacheMode = cacheMode;
    }

    /**
     * Returns the default {@code CacheMode} used for operations performed on
     * this database, or null if the environment default is used.
     *
     * @return the default {@code CacheMode} used for operations performed on
     * this database, or null if the environment default is used.
     *
     * @see #setCacheMode
     *
     * @since 4.0.97
     */
    public CacheMode getCacheMode() {
        return cacheMode;
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Sets the {@code CacheModeStrategy} used for operations performed on this
     * database.  If this property is non-null, it overrides the default
     * specified using {@link EnvironmentConfig#setCacheModeStrategy} for
     * operations on this database.
     *
     * @param strategy is the {@code CacheModeStrategy} used for operations
     * performed on this database.  If {@code null} is specified, the
     * environment default will be used.
     *
     * @see CacheModeStrategy for further details.
     *
     * @since 4.0.97
     */
    public DatabaseConfig
        setCacheModeStrategy(final CacheModeStrategy strategy) {
        cacheModeStrategy = strategy;
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setCacheModeStrategyVoid(final CacheModeStrategy strategy) {
        cacheModeStrategy = strategy;
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Returns the {@code CacheModeStrategy} used for operations performed on
     * this database, or null if the environment default is used.
     *
     * @return the default {@code CacheModeStrategy} used for operations
     * performed on this database, or null if the environment default is used.
     *
     * @see #setCacheModeStrategy
     *
     * @since 4.0.97
     */
    public CacheModeStrategy getCacheModeStrategy() {
        return cacheModeStrategy;
    }

    /**
     * Configures a database to be replicated or non-replicated, in a
     * replicated Environment.  By default this property is true, meaning that
     * by default a database is replicated in a replicated Environment.
     *

     * In a non-replicated Environment, this property is ignored.  All
     * databases are non-replicated in a non-replicated Environment.
     *
     * @see
     * Non-replicated
     * Databases in a Replicated Environment
     */
    public DatabaseConfig setReplicated(boolean replicated) {
        setReplicatedVoid(replicated);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setReplicatedVoid(boolean replicated) {
        this.replicated = replicated;
    }

    /**
     * Returns the replicated property for the database.
     *

     * This method returns true by default.  However, in a non-replicated
     * Environment, this property is ignored.  All databases are non-replicated
     * in a non-replicated Environment.
     *
     * @see #setReplicated
     */
    public boolean getReplicated() {
        return replicated;
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Configures a SecondaryAssociation that is used to define
     * primary-secondary associations for a group of primary and secondary
     * databases.  The same SecondaryAssociation instance must be configured on
     * the primary and secondary databases.
     *
     * @see SecondaryAssociation
     */
    public DatabaseConfig
        setSecondaryAssociation(SecondaryAssociation association) {
        setSecondaryAssociationVoid(association);
        return this;
    }

    /**
     * @hidden
     * The void return setter for use by Bean editors.
     */
    public void setSecondaryAssociationVoid(SecondaryAssociation association) {
        secAssociation = association;
    }

    /**
     * @hidden
     * For internal use only.
     *
     * Returns the configured SecondaryAssociation.
     *
     * @see #setSecondaryAssociation
     * @see SecondaryAssociation
     */
    public SecondaryAssociation getSecondaryAssociation() {
        return secAssociation;
    }

    /**
     * Returns a copy of this configuration object.
     *
     * @deprecated As of JE 4.0.13, replaced by {@link
     * DatabaseConfig#clone()}.

     */
    public DatabaseConfig cloneConfig() {
        return clone();
    }

    /**
     * Returns a copy of this configuration object.
     */
    @Override
    public DatabaseConfig clone() {
        try {
            return (DatabaseConfig) super.clone();
        } catch (CloneNotSupportedException willNeverOccur) {
            return null;
        }
    }

    /**
     * For JCA Database handle caching.
     *
     * @throws IllegalArgumentException via JEConnection.openDatabase.
     */
    void validate(DatabaseConfig config)
        throws DatabaseException {

        if (config == null) {
            config = DatabaseConfig.DEFAULT;
        }

        boolean txnMatch = (config.transactional == transactional);
        boolean roMatch = (config.readOnly == readOnly);
        boolean sdMatch = (config.sortedDuplicates == sortedDuplicates);
        boolean dwMatch = (config.getDeferredWrite() == deferredWrite);
        boolean btCmpMatch = true;
        if (config.overrideBtreeComparator) {
            if (btreeComparator == null) {
                btCmpMatch = (config.btreeComparator == null);
            } else if (config.btreeComparatorByClassName !=
                       btreeComparatorByClassName) {
                btCmpMatch = false;
            } else if (btreeComparatorByClassName) {
                btCmpMatch = btreeComparator.getClass() ==
                             config.btreeComparator.getClass();
            } else {
                btCmpMatch = Arrays.equals
                    (DatabaseImpl.objectToBytes
                        (btreeComparator, "Btree"),
                     DatabaseImpl.objectToBytes
                        (config.btreeComparator, "Btree"));
            }
        }
        boolean dtCmpMatch = true;
        if (config.overrideDuplicateComparator) {
            if (duplicateComparator == null) {
                dtCmpMatch = (config.duplicateComparator == null);
            } else if (config.duplicateComparatorByClassName !=
                       duplicateComparatorByClassName) {
                dtCmpMatch = false;
            } else if (duplicateComparatorByClassName) {
                dtCmpMatch = duplicateComparator.getClass() ==
                             config.duplicateComparator.getClass();
            } else {
                dtCmpMatch = Arrays.equals
                    (DatabaseImpl.objectToBytes
                        (duplicateComparator, "Duplicate"),
                     DatabaseImpl.objectToBytes
                        (config.duplicateComparator, "Duplicate"));
            }
        }

        if (txnMatch &&
            roMatch &&
            sdMatch &&
            dwMatch &&
            btCmpMatch &&
            dtCmpMatch) {
            return;
        }
        String message = genDatabaseConfigMismatchMessage
            (txnMatch, roMatch, sdMatch, dwMatch,
             btCmpMatch, dtCmpMatch);
        throw new IllegalArgumentException(message);
    }

    private String genDatabaseConfigMismatchMessage(boolean txnMatch,
                                                    boolean roMatch,
                                                    boolean sdMatch,
                                                    boolean dwMatch,
                                                    boolean btCmpMatch,
                                                    boolean dtCmpMatch) {
        StringBuilder ret = new StringBuilder
            ("The following DatabaseConfig parameters for the\n" +
             "cached Database do not match the parameters for the\n" +
             "requested Database:\n");
        if (!txnMatch) {
            ret.append(" Transactional\n");
        }

        if (!roMatch) {
            ret.append(" Read-Only\n");
        }

        if (!sdMatch) {
            ret.append(" Sorted Duplicates\n");
        }

        if (!dwMatch) {
            ret.append(" Deferred Write");
        }

        if (!btCmpMatch) {
            ret.append(" Btree Comparator\n");
        }

        if (!dtCmpMatch) {
            ret.append(" Duplicate Comparator\n");
        }

        return ret.toString();
    }

    /**
     * Checks that this comparator can be serialized by JE.
     *
     * @throws IllegalArgumentException via setBtreeComparator and
     * setDuplicateComparator
     */
    private Comparator<byte[]>
        validateComparator(Comparator<byte[]> comparator, String type)

        throws IllegalArgumentException {

        if (comparator == null) {
            return null;
        }

        try {
            DatabaseImpl.comparatorToBytes(comparator, false /*byClassName*/,
                                           type);
            return comparator;
        } catch (DatabaseException e) {
            throw new IllegalArgumentException
                (type + " comparator is not valid.", e);
        }
    }

    /**
     * Checks that this comparator class can be instantiated by JE.
     *
     * @throws IllegalArgumentException via setBtreeComparator and
     * setDuplicateComparator
     */
    private Comparator<byte[]>
        validateComparator(Class<? extends Comparator<byte[]>> comparatorClass,
                           String type)
        throws IllegalArgumentException {

        if (comparatorClass == null) {
            return null;
        }

        if (!Comparator.class.isAssignableFrom(comparatorClass)) {
            throw new IllegalArgumentException
                (comparatorClass.getName() +
                 " is is not valid as a " + type +
                 " comparator because it does not " +
                 " implement java.util.Comparator.");
        }

        try {
            return DatabaseImpl.instantiateComparator(comparatorClass, type);
        } catch (DatabaseException e) {
            throw new IllegalArgumentException
                (type + " comparator is not valid. " +
                 "Perhaps you have not implemented a zero-parameter " +
                 "constructor for the comparator or the comparator class " +
                 "cannot be found.",
                 e);
        }
    }

    /**
     * Checks that this database configuration is valid for a new, non-existant
     * database.
     *
     * @throws IllegalArgumentException via Environment.openDatabase and
     * openSecondaryDatabase
     */
    void validateForNewDb()
        throws DatabaseException {

        if (readOnly) {
            throw new IllegalArgumentException
                ("DatabaseConfig.setReadOnly() must be set to false " +
                 "when creating a Database");
        }

        if (transactional && deferredWrite) {
            throw new IllegalArgumentException
                ("deferredWrite mode is not supported for transactional " +
                 "databases");
        }
    }

    /**
     * For unit tests, checks that the database configuration attributes that
     * are saved persistently are equal.
     */
    boolean persistentEquals(DatabaseConfig other) {
        if (sortedDuplicates != other.sortedDuplicates) {
            return false;
        }

        if (temporary != other.temporary) {
            return false;
        }

        if (replicated != other.replicated) {
            return false;
        }

        if (nodeMaxEntries != other.nodeMaxEntries) {
            return false;
        }

        if (((btreeComparator == null) && (other.btreeComparator != null)) ||
            ((btreeComparator != null) && (other.btreeComparator == null))) {
            return false;
        }

        if (btreeComparator != null) {
            if (btreeComparator.getClass() !=
                other.btreeComparator.getClass()) {
            return false;
        }
        }

        if (((duplicateComparator == null) &&
             (other.duplicateComparator != null)) ||
            ((duplicateComparator != null) &&
             (other.duplicateComparator == null))) {
            return false;
        }

        if ((duplicateComparator != null)) {
            if (duplicateComparator.getClass() !=
                other.duplicateComparator.getClass()) {
                return false;
        }
        }

        return true;
    }

    /**
     * Perform validations at database open time on the completed DbConfig
     * object. Inter-attribute checks are done here.
     */
    void validateOnDbOpen(String databaseName,
                          boolean dbIsReplicated) {

        if ((getDeferredWrite() && getTemporary()) ||
            (getDeferredWrite() && getTransactional()) ||
            (getTemporary() && getTransactional())) {
            throw new IllegalArgumentException
                ("Attempted to open Database " + databaseName +
                 " and two ore more of the following exclusive properties" +
                 " are true: deferredWrite, temporary, transactional");
        }

        if ((triggers != null) && (triggers.size() > 0)) {

            final boolean replicatedTriggers = checkTriggers(triggers);
            if (dbIsReplicated && !replicatedTriggers) {
                throw new IllegalArgumentException
                    ("For a replicated Database, triggers must implement " +
                     ReplicatedDatabaseTrigger.class.getName());
            }
        }
    }

    /**
     * Checks that the triggers in the list have consistent definitions.
     *
     * @param triggerList the list of triggers to be checked
     *
     * @return true if the list consists of just replicated triggers, false if
     * it consists entirely of non-replicated triggers.
     *
     * @throws IllegalArgumentException if the list had triggers with duplicate
     * names or the types were not consistent.
     */
    boolean checkTriggers(List<Trigger> triggerList) {

        final boolean replicatedTrigger =
            triggerList.get(0) instanceof ReplicatedDatabaseTrigger;

        final Set<String> triggerNames = new HashSet<String>();

        for (Trigger trigger : triggerList) {

            /*
             * Note that we do not disallow the unsupported PersistentTrigger
             * or ReplicatedDatabaseTrigger intefaces here, to enable the
             * continued testing of these partially implemented features.
             *
            if (trigger instanceof PersistentTrigger) {
                throw new IllegalArgumentException
                    ("PeristentTrigger not supported: " + trigger.getName());
            }
            */

            if (!triggerNames.add(trigger.getName())) {
                throw new IllegalArgumentException
                    ("Duplicate trigger name:" + trigger.getName());
            }
            if (replicatedTrigger !=
                (trigger instanceof ReplicatedDatabaseTrigger)) {
                throw new IllegalArgumentException
                    ("Conflicting trigger types in list:" + triggerList);
            }
        }
        return replicatedTrigger;
    }

    /**
     * Combine the per-Database handle and Database-wide properties for a
     * database handle.
     *
     * @param dbImpl the underlying DatabaseImpl for a database handle, which
     * provides the Database-wide properties
     *
     * @param dbHandleConfig DatabaseConfig field for the same database handle,
     * which provides the per-Database properties.
     *
     * @return a DatabaseConfig which includes the correct Database-wide and
     * per-Database handle properties.
     */
    static DatabaseConfig combineConfig(DatabaseImpl dbImpl,
                                        DatabaseConfig dbHandleConfig) {

        DatabaseConfig showConfig = dbHandleConfig.cloneConfig();

        /*
         * Set the Database-wide properties from the DatabaseImpl, since they
         * might have changed from other database handles.
         *
         * Note: sorted duplicates, temporary and replicated attributes are not
         * mutable and were checked at handle creation to make sure these
         * properties in dbHandleConfig are consistent with
         * DatabaseImpl. They're still set here in case the useExistingConfig
         * property is set, and those field were not initialized.
         */
        if (dbImpl != null) {
            /* mutable, persistent, database wide attributes. */
            showConfig.setBtreeComparatorInternal
                (dbImpl.getBtreeComparator(),
                 dbImpl.getBtreeComparatorByClass());
            showConfig.setDuplicateComparatorInternal
                (dbImpl.getDuplicateComparator(),
                 dbImpl.getDuplicateComparatorByClass());
            showConfig.setKeyPrefixing(dbImpl.getKeyPrefixing());
            showConfig.setNodeMaxEntries(dbImpl.getNodeMaxTreeEntries());
            showConfig.setTriggers(dbImpl.getTriggers());

            /* mutable, but non-persistent attributes. */
            showConfig.setTransactional(dbImpl.isTransactional());
            showConfig.setDeferredWrite(dbImpl.isDurableDeferredWrite());

            /* not mutable, but initialized in the showConfig. */
            showConfig.setReplicated(dbImpl.isReplicated());
            showConfig.setSortedDuplicates(dbImpl.getSortedDuplicates());
            showConfig.setTemporary(dbImpl.isTemporary());
        }

        return showConfig;
    }

    /**
     * Returns the values for each configuration attribute.
     *
     * @return the values for each configuration attribute.
     */
    @Override
    public String toString() {
        return "allowCreate=" + allowCreate +
            "\nexclusiveCreate=" + exclusiveCreate +
            "\ntransactional=" + transactional +
            "\nreadOnly=" + readOnly +
            "\nsortedDuplicates=" + sortedDuplicates +
            "\ndeferredWrite=" + deferredWrite +
            "\ntemporary=" + temporary +
            "\nkeyPrefixing=" + keyPrefixing +
            "\n";
    }
}

redpajama_set_name: RedPajamaGithub


text:
Man arrested after injured woman found at Dunkeld Bridge
Woman discovered with multiple injuries
Melanie Bonn
Dunkeld Bridge
Police have arrested a man in his 40s after a woman with multiple injuries was discovered in Dunkeld.
The discovery happened around 1.30am on Tuesday morning and led to a multi-vehicle police response.
In the darkness on December 3, a woman was found close to Dunkeld Bridge, where the 1850 stone crossing begins, on the A9 side of the river.
A part of the residential area near the community orchard, known as Little Dunkeld, was cordoned off and as many as five Police Scotland vehicles were noted at the scene by residents on Tuesday morning, searching the bank below the bridge.
Police revealed yesterday a man has been arrested for an alleged assault .
A statement issued by a Police Scotland spokesperson said: "Police Scotland can confirm that a 43-year-old man has been arrested in connection with an alleged assault of a woman at Dunkeld Bridge.
"The incident happened around 1.30am on Tuesday, December 3.
"The woman was taken to hospital for treatment to non-life threatening injuries.
"Inquiries are ongoing to establish the full set of circumstances."
As daylight came on Tuesday, police centred several hours of investigation on a wooded area at the foot of Dunkeld Bridge.
Structural contractor Gavin Park of Geo-Structural was conducting repair work on the famous arched bridge over the Tay.
He was based on the town side of the river.
He told the PA: "We spotted a lot of police activity across the water when we came in to work at 8am on Tuesday.
"They had an area taped off and they appeared to be looking in the trees.
At the Atholl Arms Hotel, staff member Alan said he saw a police car on-site when he came in for the early shift at work.
He said: "The first police vehicle was there when I got in at 6.30am on Tuesday and that one was joined by a support unit and several others as the morning went on."
Perthshire News


Master Sergeant (retired) Ron Spradling is a decorated, 20 year, Air Force veteran. He has an airframe maintenance background that includes working on the F-16 Falcon, A-10 Warthog, and numerous other aircraft. He has taught over 2000 hours at the Aircraft Structural Maintenance Technical School at NAS Pensacola, Florida, and he also has served overseas in Saudi Arabia, South Korea, and Afghanistan. He received his BS Degree from the University of Management and Technology and now runs a restaurant delivery service (CitySpree of Pensacola) with his wife, Patty. CitySpree of Pensacola has been recognized as an "Innovative Marketing Company", "Small Business of the Month", and "Best of the Bay" in 2014, 2015, and 2016. Together, Ron and Patty have three children, Alexandria, age 20, Thomas, age 14, and Samantha, age 12.
Patty Spradling is the beautiful wife of Master Sergeant (retired) Ron Spradling. She is a wonderful mother of three children, Alex (20), Thomas (14), and Samantha (12). She is a graduate of Leadership Pensacola, Class of 2016 and has performed duties as a Pensacola Chamber of Commerce Ambassador for the last 2 years. She, along with her husband, currently own a restaurant delivery service called CitySpree of Pensacola that has been recognized as an "Innovative Marketing Company", "Small Business of the Month", and "Best of the Bay – Food Delivery" in 2014, 2015, & 2016.
Currently heading up QwikMow and leading the Pensacola Elite Network Chapter. Started his first lawn care business at the age of 14. Upon graduation of Woodham High School in Pensacola, Fl he began working with Florida Pest Control. During his almost 7 years there he acquired licensure in several state pesticide categories. Launching into his first full time landscape business venture at 25. He has served as the chairman to the Pensacola State College Curriculum Landscape Horticulture committee, where he advised about current industry issues. In addition to pesticide certification he also has Horticulture and formerly a DEP certification for fertilizer and waterway management. Previously the host of his own garden talk radio show called, The Master's Gardener. Elden has passion for landscapes and small business. From his second year in business he understood the importance of building relationships. The year he first joined a networking organization he doubled his business revenue. The largest referral he'd ever received from network function led to over $200,000 from one contract over 5 years. The proud president of the original group of The ONE. He looks forward to leading the PEN towards building relationships and each others businesses through permission based referrals.
I became pregnant in 2010 and was excited for the next chapter in life to begin. Little did I know what was in store and the impact it would have on my future.My water broke unexpectedly at 21 weeks, and I was admitted to the hospital in pre-term labor. I was on bedrest for 20 days before my daughter was delivered by emergency C-section at 23 weeks and 4 days gestation. She weighed 1lb., 2.7oz at birth and was rushed to the NICU, where she stayed for 120 days before coming home. Our NICU journey inspired me to want to make a difference so that no other family would have to experience the trauma of having a sick baby.
I have served as the March of Dimes Community Director since February 2013.It is an honor to serve on the PFAC and to have an impact on our community.
Local Business Marketing Consultant. Specializing in Google Plus Optimization, Search Engine Optimization, Reputation Marketing (Reviews) and Google AdwordsPresently own Yolee Solutions. A digital marketing company based out of Pensacola FL. Consulting small to medium sized businesses in optimizing their Digital Real Estate.
In addition, president of a Networking Group called THOR – Tuesday Hour of Reciprocity that meet at Cactus Cantina Restaurant on 5121 N 12th Ave Pensacola FL. We focus on building relationships as a way of building trust then referring business to each other therebuy enhancing the end user.
Served 10 years as senior IT specialist and consultant to senior management in support of organization wide IT policy, budget and plans for systems development, acquisition, installation, operation and maintenance while planning, organizing, and overseeing the activities of the IT organization and reviewing policies, procedures, mission objectives and organizational design for the staff while serving as the recognized authority in the analysis and direction of IT programs and issues and in researching, interpreting, analyzing and applying operations and security guidance for the commands both as a Commander in the Navy and as a civilian contractor.
Former Naval Aviator and Member of 2nd Fleet Air Operation Center Member.
Recruiter Serving Former Military Members and finding them Civilian Opportunities with Fortune 500 companies. Specialized in acquiring Companies to Hire our former military members as well as finding eligible military members and entering them into the job force.
Betsy Tait has been a lifelong Pensacolian. She has a background in finance and has been a mortgage broker and an insurance agent. She is an entrepreneur that owns several businesses. Betsy is the owner of the Betsy Buys Houses, were she buys pretty houses, ugly houses and pretty ugly houses! She is a member of Saint Luke United Methodist Church, where she has held numerous positions on the church council, the preschool board and the youth Council. Also she's been involved with the PTA and the PTSA throughout Escambia County. She has been married to her husband, Scott for 34 years. Betsy is also the mother of four daughters, Brittany Kellogg age 28, Jamie Tait age 24, Kelly Tait age 22, and Lieutenant Shannon Tait-Luttrell age 39.
Bill Sheffield is celebrating his 20th year in real estate in the Greater Pensacola Market. Bill is graduate of the University of Tennessee and a Marine. During his time in Pensacola he has been an active Rotarian with Sub West Rotary. He is active in the Greater Pensacola Chamber serving as an ambassador for the past 5 years. After working with several networking groups including Pensacola Leaders, Business Netlink and BNI Bill is excited to be president of GROW, an active group of The One. "Working with people to develop relationships always leads to money" As John Maxwell says, "People don't care about how much you know unless they know how much you care" Bill is the proud husband of Delany Sheffield for 30 years and she is affectionately known as Precious.
Angela D'Alessandro has been a very successful Nail Technician & business owner for the past 18 years – current. She has worked at the same salon for over 17 years (Nail Boutique). She decided to start a career in Mary Kay as an Independent Beauty Consultant on April 7, 2014 for extra income, as well as, the relationships and support of such a wonderful and proven company. She also wanted to create a means of giving back to her community.Angela has since become a Team Leader in Mary Kay and is currently striving to become a Director. She has earned many accolades so far. She won the 2014 & 2015 Queen of Sharing within her unit, 2014 & 2015 Top 10 in Sales, & 4 quarter Star with the company.Working 2 jobs, she decided to spend her extra time volunteering for a few organizations that she's very passionate about. Pace Center For Girls, Impact 100; & added to the list; Take Stock In Children.She decided last November to expand her business by joining a networking group. In the first 2 months of joining she already made back the money she paid in dues & started creating amazing relationships.Angela is currently the President of her chapter PACE (Professional And Community Experts) within The One ( The Organization of Networking Entrepreneurs). She is looking forward to continued growth & building relationships through permission based referrals. She is the very proud mom of two great children and the wife of a wonderfully supportive husband.


Dinosaurs and Robots: Super Maniable!
I'm going to be the annoying francophile for a while since I'm back in Paris, taking a much-needed break and visiting my niece after a grueling summer of work. That means my subsequent posts (unless my D+R hosts decide to cut me off) will be about all the neat things I'm finding here. It will be Paris this and Paris that, my entries pretentiously peppered with French words and so forth. As my rather difficult ten-year old niece said to me the other day with a wave of her hand, "You'll have to get used to it." Today's find: this great postcard of a vintage Cady mini-moto-bicycle advertisement with a très jaunty gal (who would no doubt get harassed today in Paris for wearing red knee-high socks).


It's the battle of Christines!! Christyne from Granby joined the show this morning in attempt to beat our Christine Lee in our pop culture trivia game. See how well she does by listening and playing along to "Can't Beat Christine"
Jerry Seinfeld has been accused of auctioning off a bogus '58 Porsche for $1.54 M. What is the name of Jerry's Netflix show that features vintage cars and a new guest being interviewed every week?
Bradley Cooper and Lady Gaga are set to perform 'Shallow' for the 91st Academy Awards. Who was supposed to host the Oscars this year but stepped down amid controversy?
Rami Malek says director Bryan Singer was "not pleasant" on the Bohemian Rhapsody set. What's the name of the TV show where Rami play's a character named Elliot Anderson?
Pete Davidson and Kate Beckinsale were seen leaving a comedy club together on Friday night. What country is Kate Beckinsale from?
Ronald Reagan was born today in 1911. At the time of his death, what was his wife's name?


text:
Tractus Fossae – system rowów na powierzchni Marsa. Jego centrum znajduje się na 20,58° szerokości geograficznej północnej oraz 70° długości geograficznej zachodniej (). Obszar Tracus Fossae ma 403,06 km średnicy. Jest to system wyraźnych rynien oraz znaczących grzebietów utworzonych w wyniku aktywności tektonicznej.

Decyzją Międzynarodowej Unii Astronomicznej nadana w 1988 roku nazwa tego obszaru pochodzi od określenia biała droga po łacinie.

Przypisy

Linki zewnętrzne
 HiRISE zagląda na dno marsjańskiej dziury
 Położenie na mapie topograficznej Marsa

Topografia Marsa

redpajama_set_name: RedPajamaWikipedia


text:
Birtinya, Queensland
Suburb of Kawana Waters, Queensland, Australia
Kawana Waters, Queensland
26°44′35″S 153°07′08″E / 26.74306°S 153.11889°E / -26.74306; 153.11889Coordinates: 26°44′35″S 153°07′08″E / 26.74306°S 153.11889°E / -26.74306; 153.11889
1,933 (2016 census)[1]
Postcode(s)
2.5 km2 (1.0 sq mi)
9 km (6 mi) N of Caloundra
12 km (7 mi) SSE of Maroochydore
LGA(s)
Sunshine Coast Region
Bribie
State electorate(s)
Kawana
Federal Division(s)
Suburbs around Birtinya:
Sippy Downs Warana Warana
Palmview Birtinya Bokarina
Meridan Plains Currimundi Wurtulla
Birtinya is a suburb of Kawana Waters in the Sunshine Coast Region, Queensland, Australia.[2]
3 Amenities
It contains the neighbourhood of Kawana Forest.[citation needed]
The name Birtinya is reportedly an Aboriginal word meaning neighbouring proposed by the development company, Alfred Grant Pty Ltd, on 31 March 1960.[2]
In the 2011 census, Birtinya had a population of 314 people.[3]
Amenities[edit]
Birtinya is built around Lake Kawana, which includes a 2 kilometres (1.2 mi) buoyed course for flat water competitions.[4]
The Lake Kawana Community Centre located beside the lake on Sportsmans Drive (26°44′25″S 153°07′30″E / 26.74024°S 153.12492°E / -26.74024; 153.12492 (Lake Kawana Community Centre)) provides 15 spaces (halls and meeting rooms) together with commercial kitchen facilities and smaller kitchenettes for community events. It is operated by the Sunshine Coast Regional council.[5] The centre was officially opened on 5 November 2005 by City of Caloundra mayor Don Aldous.[6]
Sunshine Coast University Hospital (SCUH) is located in Birtinya; it is a tertiary, teaching hospital servicing all parts of the Sunshine Coast and Gympie Region. SCUH saw its first patients on 21 March 2017 and was officially opened on 19 April 2017 by the Queensland Premier and Minister for Health and Minister for Ambulance Services. SCUH opened with about 450 beds, with plans to grow to 738 beds by 2021. Services and capacity at SCUH will continue to develop over the coming years.[7]
^ Australian Bureau of Statistics (27 June 2017). "Birtinya (State Suburb)". 2016 Census QuickStats. Retrieved 15 April 2018.
^ a b "Birtinya (entry 47163)". Queensland Place Names. Queensland Government. Retrieved 22 April 2014.
^ Australian Bureau of Statistics (31 October 2012). "Birtinya (State Suburb)". 2011 Census QuickStats. Retrieved 4 January 2015.
^ "Lake Kawana". Sunshine Coast Regional Council. Archived from the original on 29 March 2014. Retrieved 21 April 2014.
^ "About the venue". Lake Kawana Community Centre. Sunshine Coast Regional Council. Archived from the original on 3 March 2014. Retrieved 21 April 2014.
^ "Lake Kawana community centre opening". My Sunshine Coast Life. Retrieved 21 April 2014.
^ "Sunshine Coast University Hospital". Queensland Health. Retrieved 18 February 2020.
University of Queensland: Queensland Places: Birtinya
Suburbs and towns in the Sunshine Coast Region, South East Queensland
Bald Knob
Balmoral Ridge
Battery Hill
Beerburrum
Beerwah
Belli Park
Bells Creek
Booroobin
Bribie Island North
Caloundra (suburb)
Caloundra (urban area)
Cambroon
Chevallum
Coes Creek
Conondale
Coochin Creek
Coolabine
Cooloolabin
Corbould Park
Crohamhurst
Curramore
Diamond Valley
Dicky Beach
Diddillibah
Doonan
Dulong
Eerwah Vale
Elaman Creek
Eudlo
Gagalba
Gheerulla
Image Flat
Kidaman Creek
Kiels Mountain
Kulangoor
Kuluin
Kureelpa
Landers Shoot
Maroochy River
Maryoochydore (town)
Maryoochydore (suburb)
Mooloolah
Mooloolah Valley
Mount Mellum
Mudjimba
Nirimba
North Arm
North Maleny
Obi Obi
Pelican Waters
Perwillowen
Point Arkwright
Towen Mountain
Twin Waters
Valdora
Verrierdale
West Woombye
Weyba Downs
Wootha
Yandina Creek
Yaroomba
Main article: Local government areas of Queensland
This article about the geography of the Sunshine Coast, Queensland is a stub. You can help Wikipedia by expanding it.
Retrieved from "https://en.wikipedia.org/w/index.php?title=Birtinya,_Queensland&oldid=995828525"
Suburbs of the Sunshine Coast Region
Sunshine Coast, Queensland geography stubs
Australian Statistical Geography Standard 2016 ID same as Wikidata
Use dmy dates from August 2012
Use Australian English from August 2012
All Wikipedia articles written in Australian English


text:
Q: jqGrid is not rendering mvc3 razor? My _Layout.cshtml like this

        <meta charset="utf-8" />
        <title>@ViewBag.Title - E-Reader Statistics</title>
        <link href="~/favicon.ico" rel="shortcut icon" type="image/x-icon" />
        <meta name="viewport" content="width=device-width" />
        @Styles.Render("~/Content/css")
        @Scripts.Render("~/bundles/modernizr")
       @* @Scripts.Render("~/bundles/jquery")*@
        <link href="~/jqGrid/css/ui.jqgrid.css" rel="stylesheet" />

in Index.chtml
@model List<LSStatisticalReport.ViewModels.GSViewModel>

@{
    ViewBag.Title = "Index";
}

@*
General Statistics
*@

But when I am running the project I am getting an error in console:
"Uncaught TypeError: Object [object Object] has no method 'jqGrid' "

A: This type of error says this : please Define jqgrid library before related init scripts. I have seen this error before, although you have defined related library in head tag. So I solved this problem by removing its library from head tag and placing it at the view before the script and works properly.
I think this occurs because of partial load of page. so use this at the index view:
@model List<LSStatisticalReport.ViewModels.GSViewModel>

@{
    ViewBag.Title = "Index";
}

@*
General Statistics
*@
//added

//end added

redpajama_set_name: RedPajamaStackExchange


A common New Year's resolution is to get in better shape — and setting a race goal is one way to get motivated.
Four local organizations are encouraging Space Coast residents to make a commitment to four races between January and March, with the goal of completing 20K in 2019.
The inaugural Run for the Kids Race Series is made up of four well-established local 5K races that benefit children and families. The race series consists of the Tooth Trot 5K on Jan. 26; Brevard PALS 5K on Feb. 16; Brianna Marie Foundation 5K on March 9; and the series finale Downtown Melbourne 5K on March 23.
Each race comes with its own set of amenities — from race T-shirts to medals for fastest runners — but those who sign up for the entire series also receive a series finisher medal with all four race logos and the series title emblazoned on it.
Suntree resident David Scholl is the race series director, who conceived the idea after speaking with individual race directors.
The combined audience reach of the races is more than 10,000 local runners.
The race series kickoff is the 21st annual Tooth Trot 5K held at the Wickham Park Community Center that benefits Give Kids a Smile. Local dentists helm the Brevard branch of the organization that provides children who need it with free dental care, as well as hygiene items like toothbrushes and toothpaste. The annual Give Kids a Smile event helps more than 100 children and includes dental exams, X-rays and cavity treatments.
In its 10th year, the Brevard PALS 5K run/walk for autism awareness raises funds to provide resources to local families facing autism diagnoses. The race is held at the Scott Center for Autism Treatment on the campus of the Florida Institute of Technology. Race proceeds help fund resources such as camps specifically designed for children with autism that take place over spring break and during the summer.
The 7th annual Brianna Marie Foundation 5K takes place on March 9 at Wickham Park and funds benefit advancements in fetal therapies. Foundation founder Aran Hissam lost her own child to a fetal condition and has since raised more than $300,000 for research advancement.
Series participants will receive their medals at the final race of the series, the 37th Downtown Melbourne 5K, held on March 23. It begins on Municipal Lane, between New Haven and Strawbridge avenues. The race benefits The Haven for Children, an organization that provides shelter and other resources to children who are abused, abandoned or neglected.
All four races are managed by Running Zone. In addition to the finisher medals, series awards will go to the top three finishers for male and female.
To sign up for the race series, visit Facebook.com/RunForTheKidsBrevard or RunningZone.com. Those interested in sponsoring can also reach out via the Facebook page.