text:
Edwards: Louisiana shouldn't be talking about new tax breaks
Melinda Deslatte, The Associated Press
May 11, 2019 at 10:19 AM May 11, 2019 at 11:28 AM
BATON ROUGE, La. (AP) " Louisiana lawmakers shouldn't be creating new tax break programs less than a year after reaching a tax compromise that ended nearly a decade of budget instability, said Gov. John Bel Edwards, suggesting he'd jettison any pricey exemptions that might reach his desk.
"For the most part, it's a conversation we should not be having," the Democratic governor said Friday.
As they head into the fall election period, lawmakers in the House have backed a proposal to restore suspended sales tax holidays. Republicans and Democrats have suggested creating new tax exemptions for low-producing oil wells, rural job investments, certain health providers, diapers and feminine hygiene products. And some Republicans want to rework or remove the 0.45% state sales tax passed last year as the centerpiece of the seven-year tax compromise that stabilized state finances.
Price tags for the bills range from a few hundred thousand dollars a year to tens of millions of dollars annually.
Lawmakers argue the tax breaks encourage business growth, economic development projects or fairness in state tax laws. The Republicans pushing to undo the 0.45% sales tax " one such proposal is scheduled for a Monday hearing " say state surpluses show Louisiana doesn't need the tax.
Edwards said the hard-fought tax deal struck with the majority-Republican Legislature after 10 legislative sessions since 2016 shouldn't be upended with new carve-outs for favored groups. He noted that several government watchdog groups told him and lawmakers that "what we needed to focus on was reining in all of the tax expenditures, the giveaways, the incentives."
"Here we finally achieved some level of stability, and the Legislature introduces a slew of new exemptions and so forth," the governor said. "So I think, for the most part, these are things that we should not be considering at this point in time. And it is my intention to protect the state general fund and the budget."
Edwards gave himself some wiggle room, however, declining to say he'd reject every tax break that could win final legislative passage.
"I'm obviously trying to leave myself just a little bit of flexibility," he said. "But I will tell you there won't be any high-dollar items in terms of new tax expenditures that will be approved."
Follow Melinda Deslatte on Twitter at http://twitter.com/melindadeslatte


text:
Нормативният акт или още нормативният юридически акт е властнически акт, съдържащ волеизявление на компетентен държавен орган под формата на правни норми, предписващи общи правила за поведение от неопределен кръг субекти, който има нееднократно действие за разлика от общия и индивидуален административен акт. Според Закона за нормативните актове, нормативният акт съдържа общи правила за поведение, които се прилагат към индивидуално неопределен кръг субекти, има нееднократно действие и се издава или приема от компетентен държавен орган. Нормативни актове могат да издават само органите, предвидени от Конституцията или от закон. Компетентността да се издават нормативни актове не може да се прехвърля.

Приетият през 2006 г. за пръв път в историята на България Административнопроцесуален кодекс дава легална дефиниция за нормативен административен акт, като подзаконов административен акт съдържащ административно-правни норми, отнасящ се за неопределен и неограничен брой адресати, и имащ многократно правно действие. Нормативните административни актове се издават по прилагане на закон или подзаконов нормативен акт от по-висока степен. Нормативните актове от по-висока степен са международните договори по които Република България е страна, Конституцията, кодексите и закона. Съгласно Закона за нормативните актове подзаконови нормативни актове са постановленията на Министерския съвет, правилниците, наредбите и инструкциите.

Подготовката, издаването и прилагането на нормативните актове в България се урежда от Закона за нормативните актове и Указ 883 за прилагане на Закона за нормативните актове на бившия Държавен съвет на Народна република България.

Вижте също
 Систематизация на нормативните актове

Източници
 Нормативни юридически актове

Правни актове

redpajama_set_name: RedPajamaWikipedia


text:
John Clark Ketcham (January 1, 1873 – December 4, 1941) was a politician from the U.S. state of Michigan.

Ketcham was born in Toledo, Ohio, and moved with his parents to Maple Grove, Michigan near Nashville, the same year. He attended the common schools of Barry County and high school at Nashville. He taught in rural and high schools from 1890 to 1899. Ketcham was county commissioner of schools for Barry County, 1899-1907, and chairman of the Republican county committee, 1902-1908. He was postmaster of Hastings, 1907-1914; master of the Michigan State Grange, 1912-1920; and lecturer of the National Grange, 1917-1921.

Ketcham was elected as a Republican from Michigan's 4th congressional district to the 67th United States Congress and to the five succeeding Congresses, serving from March 4, 1921, to March 3, 1933. He was an unsuccessful candidate for reelection in 1932, losing in the general election to Democrat George E. Foulkes.

Ketcham was president of the National Bank of Hastings, 1933-1937; State commissioner of insurance, 1935-1937; and counsel for the Michigan Chain Store Bureau, 1938-1941. He died in Hastings and was interred there in Riverside Cemetery.

He was the son-in-law, of Samuel Azariah Shelton, U.S. Representative from Missouri's 16th congressional district, 1921-1923.

References

John C. Ketcham at The Political Graveyard

1873 births
1941 deaths
Republican Party members of the United States House of Representatives from Michigan
People from Toledo, Ohio
People from Barry County, Michigan
People from Hastings, Michigan
State insurance commissioners of the United States


CMA Event – They Loved Your Pitch! Now What??
Lots of folks dream of having their own show – creating their own property from scratch, selling it to a network or production company, rolling around in piles of money like Scrooge McDuck. While there are more ways than ever to get original IP in front of an audience, there are still plenty of hurdles to… … Continue reading CMA Event – They Loved Your Pitch! Now What??


The Chemicals segment focuses on maintaining and developing BASF's Production Verbund. BASF's unique Verbund system of highly integrated production sites offers substantial competitive advantages..
Is there a high performance insulation that can give you design flexibility as well as energy efficiency? How do you build something that is both durable and sustainable?
Electronics and Electric (E&E) devices are an inseparable part of our daily lives and will become even more so in the future. At BASF, we connect our innovation with the needs of our customers in the global electronic industry to provide the most advanced chemicals and electronic materials in the E&E value chain.
BASF´s Home Care and Industrial & Institutional Cleaning Solutions develops, produces and markets a comprehensive range of products for detergent and cleaners worldwide.


Three tree improvement programs were analyzed by break-even, cost-benefit technique: one for ponderosa pine in the Pacific Northwest, and two for Douglas-fir in the Pacific Northwest-one of low intensity and the other of high intensity. A return of 8 percent on investment appears feasible by using short rotations or by accompanying tree improvement with thinning. Interest rates, length of rotation, the inclusion of thinnings, and site index had greater effects on profitability than program design. Large breeding zones improved profitability, although they incur the biological risks of nonadaptation to local conditions and loss of local genetic resources. Increasing orchard seed yield affected the results only slightly unless the planting program could be expanded, which is equivalent to increasing the size of the breeding zone. If the increase in seed yield merely reduced the required acreage of seed orchard and associated costs, the financial results improved only slightly.
Ledig, F. Thomas; Porterfield, Richard L. 1981. West Coast tree improvement programs: a break-even, cost-benefit analysis. Res. Pap. PSW-RP-156. Berkeley, CA: U.S. Department of Agriculture, Forest Service, Pacific Southwest Forest and Range Experiment Station. 8 p.


Saint Cloud State University is a member of the National Council for State Authorization Reciprocity Agreements (NC-SARA), a voluntary, regional approach to state oversight of postsecondary distance education.
Online education at St. Cloud State is designed for students who desire the flexibility of studying anytime, anyplace without the time and distance constraints of attending class on campus.
The university offers more than 200 online courses each semester including many major program courses for undergraduate degrees such as criminal justice and community psychology. Degree completion opportunities are available for six graduate programs as well as Bachelor of Elective Studies (BES), Associates of Arts (AA) and Science (AS), and Nursing RN-to-BSN.
We want you to have the convenience to learn your way – online, on-campus or both.
Already a student at another Minnesota state college or university? Register for individual courses as a non-degree seeking student.
Search undergraduate, graduate and certificate programs that offer online learning opportunities.
Find information for online tutoring, accessing D2L Brightspace and more.


text:
Q: CharliePlexing on a breadboard I was making a breadboard demo for a Microcontroller class. Basically my project is to make a score keeping device. I want to drive 4 seven segment displays using an atmega8. I read about charlie plexing and understand that it will enable me to drive all the 4 displays using a single port. I understood the theory but can't really figure out how to make the charlie plexing circuit on a bread board. Can anyone please help?

A: Take a look at my charlie-plexing schematic at
http://wiblocks.com/FAQ/faq-charlie-plex.html
Make each row connection the common pin of the seven segment readout.
Make each column the individual pin connection. For 28 segments
you need six pins. If you use eight pins instead of six you
may find it easier to program. With eight pins I would do four
rows and seven columns.
(* jcl *)
http://www.wiblocks.com

A: I'm only a beginner at all of this, so take this with a grain of salt, but I'd have a totally different approach.
I'd use a 7447 decoder instead. This would use 7 pins (4 for the output, and 3 to select the display), but it would be much simpler than having to work out the combinations to charlieplex and would give a brighter output too.

A: The Wikipedia article has simple examples on how to wire charlieplexed LEDs.
There are also a lot of instructables related to charlieplexing. This particular instructable explains how to wire 7-segment displays (with additional transistors though).
This page also explains how to wire 7-segment displays and contains pseudo code on how to drive them. The main difficulty of charlieplexing is to use flickering so that you can switch on arbitrary combinations of segments.

redpajama_set_name: RedPajamaStackExchange


The big difference between Web-based mail and the UNIX methods is that the former is much easier for non-experts to use. Since the idea was first developed, many companies have jumped on the Web-mail bandwagon, and the number of people using this technique has exploded into the millions in just a few years. Many free services even popped up in the late 1990s as part of the "dot com bubble", allowing any Internet user to send and receive e-mail using the Web at no charge (except perhaps for tolerating advertising). Many Internet Service Providers (ISPs) now offer Web access as an option in additional to conventional POP/IMAP access, which is useful for those who travel. Google's new Gmail service is the latest entrant into the sweepstakes, offering users 1 GB of e-mail storage in exchange for viewing Google's text ads on their site.
There are drawbacks to the technique, however, which as you might imagine are directly related to its advantages. Web-based mail is easy to use, but inflexible; the user does not have direct access to his or her mailbox, and can only use whatever features the provider's Web site implements. For example, suppose the user wants to search for a particular string in his or her mailbox; this requires that the Web interface provide this function. If it doesn't, the user is out of luck.
Web-based mail also has a disadvantage that is an issue for some people: performance. Using conventional UNIX direct access, it is easy to quickly read through a mailbox; the same is true of access using POP3, once the mail is downloaded. In contrast, Web-based mail services mean each request requires another HTTP request/response cycle. The fact that many Web-based services are free often means server overload that exacerbates the speed issue.
Note that when Web-based mail is combined with other methods such as POP3, care must be taken to avoid strange results. If the Web interface doesn't provide all the features of the conventional e-mail client, certain changes made by the client may not show up when Web-based access is used. Also, mail retrieval using POP3 by default removes the mail from the server. If you use POP3 to read your mailbox and then later try to use the Web to access those messages from elsewhere, you will find that the mail is "gone"—it's on the client machine where you used the POP3 client. Many e-mail client programs now allow you to specify that you want the mail left on the server after retrieving it using POP3.
Key Concept: In the last few years a new method has been developed to allow e-mail access using the World Wide Web (WWW). This technique is growing in popularity rapidly, because it provides many of the benefits of direct server access, such as the ability to receive e-mail anywhere around the world, while being much simpler and easier than the older methods of direct access such as making a Telnet connection to a server. WWW-based e-mail can in some cases be used in combination with other methods or protocols, such as POP3, giving users great flexibility in how they read their mail.


The perfect staple piece for anyone, anywhere -- this skirt can take you from desk to dinner or breakfast to beach in no time! Wear it with platform sneakers while you run errands, pair it with pumps for the office, or style it with stilettos for the night!
Hand wash/hang dry. Steam iron recommended.


text:
package org.springframework.web.servlet.view.tiles3;

import org.apache.tiles.access.TilesAccess;
import org.apache.tiles.impl.BasicTilesContainer;
import org.apache.tiles.request.ApplicationContext;
import org.apache.tiles.request.Request;
import org.apache.tiles.request.servlet.ServletRequest;
import org.apache.tiles.request.servlet.ServletUtil;
import org.junit.Test;

import org.springframework.context.annotation.Configuration;
import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.mock.web.test.MockHttpServletResponse;
import org.springframework.mock.web.test.MockServletContext;

import static org.junit.Assert.*;

/**
 * Test fixture for {@link TilesConfigurer}.
 *
 * @author Nicolas Le Bas
 */
public class TilesConfigurerTests {

	@Test
	public void simpleBootstrap() {
		MockServletContext servletContext = new MockServletContext();

		TilesConfigurer tc = new TilesConfigurer();
		tc.setDefinitions("/org/springframework/web/servlet/view/tiles3/tiles-definitions.xml");
		tc.setCheckRefresh(true);
		tc.setServletContext(servletContext);
		tc.afterPropertiesSet();

		ApplicationContext tilesContext = ServletUtil.getApplicationContext(servletContext);

		BasicTilesContainer container = (BasicTilesContainer) TilesAccess.getContainer(tilesContext);
		Request requestContext = new ServletRequest(container.getApplicationContext(),
				new MockHttpServletRequest(), new MockHttpServletResponse());
		assertNotNull(container.getDefinitionsFactory().getDefinition("test", requestContext));

		tc.destroy();
	}

	@Configuration
	public static class AppConfig {
	}

}

redpajama_set_name: RedPajamaGithub


text:
"The Right Way To Learn To Play" (801) 272-7917
Welcome To On Track!
Scott Graves
Free Guitar Lessons Right Now
Drum, Bass, Keys, Vocal Lessons
Perform Live
AMPD Rock bands
Summer Jam 2022
Most Recent Student Fest
Summer Music Program
Winter Expo Recap
Student Fest Recap
Office Info / School Calendar
New 900 East Remodel!
Instruments and Gear
AMPD Bands Only!
Professional Entertainment
Bands With Scott Graves
Scott Graves' Bio
Scott Graves founded the On Track Music Guitar School in 1992. His unique teaching style has earned him a reputation as Utah's premier Guitar instructor. His versatility as a guitarist has enabled him to work with students from the beginning to professional level covering all styles of acoustic and electric guitar.
Scott started playing guitar at the age of seven and started playing professionally at the age of eighteen. He graduated from G.I.T., the world famous Musician's Institute, in 1986. Scott was signed to an instructional video deal with Backstage Pass Productions in the early 1990's. The owner of the prominent Los Angeles based company viewed Scott's work on "Intro to Playing Rock Guitar" and decided the title would be a great addition to their line of existing videos by famous rock stars. Scott's videos were distributed throughout the United States and Canada and quickly became one of the companies top sellers.
During the 80's, 90's and 2000's, Scott has played and recorded professionally throughout the Inter-Mountain West, but his true passion is sharing the excitement of music with others. The On Track Music Guitar School has become known as "the place" to learn to play guitar in Utah. Scott works daily helping private students and bands to develop their musical skills the right way. He coaches at least eleven bands on a weekly basis and is constantly seeking new and exciting ways to improve upon his already phenomenal guitar program. Although Scott has been running On Track Music for over two decades, he is still excited about what the future holds for his outstanding program and all of the students who have been a part of it.
To Book Scott Graves To Play At Your Event: Click Here
Scott Graves founded the On Track Music Guitar School in 1992. His unique teaching style has earned him a reputation as Utah'sread more..
Click Here for Drum Lessons
Student Rock Band Program!
Online Classes now available! Call now for details! 801-272-7917

redpajama_set_name: RedPajamaCommonCrawl


text:
package prefuse.data;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;

import javax.swing.event.TableModelEvent;

import prefuse.data.column.Column;
import prefuse.data.column.ColumnFactory;
import prefuse.data.column.ColumnMetadata;
import prefuse.data.event.ColumnListener;
import prefuse.data.event.EventConstants;
import prefuse.data.event.TableListener;
import prefuse.data.expression.Expression;
import prefuse.data.expression.Predicate;
import prefuse.data.expression.parser.ExpressionParser;
import prefuse.data.tuple.AbstractTupleSet;
import prefuse.data.tuple.TableTuple;
import prefuse.data.tuple.TupleManager;
import prefuse.data.util.FilterIteratorFactory;
import prefuse.data.util.Index;
import prefuse.data.util.RowManager;
import prefuse.data.util.Sort;
import prefuse.data.util.TableIterator;
import prefuse.data.util.TreeIndex;
import prefuse.util.TypeLib;
import prefuse.util.collections.CopyOnWriteArrayList;
import prefuse.util.collections.IncompatibleComparatorException;
import prefuse.util.collections.IntIterator;

/**
 *
A Table organizes a collection of data into rows and columns, each row
 * containing a data record, and each column containing data values for a
 * named data field with a specific data type. Table data can be accessed
 * directly using the row number and column name, or rows can be treated
 * in an object-oriented fashion using {@link prefuse.data.Tuple}
 * instances that represent a single row of data in the table. As such,
 * tables implement the {@link prefuse.data.tuple.TupleSet} interface.

 *
 *
Table rows can be inserted or deleted. In any case, none of the other
 * existing table rows are effected by an insertion or deletion. A deleted
 * row simply becomes invalid--any subsequent attempts to access the row
 * either directly or through a pre-existing Tuple instance will result
 * in an exception. However, if news rows are later added to the table,
 * the row number for previously deleted nodes can be reused. In fact, the
 * lower row number currently unused is assigned to the new row. This results
 * in an efficient reuse of the table rows, but carries an important side
 * effect -- rows do not necesarily maintain the order in which they were
 * added once deletions have occurred on the table. If not deletions
 * occur, the ordering of table rows will reflect the order in which
 * rows were added to the table.

 *
 *
Collections of table rows can be accessed using both iterators over
 * the actual row numbers and iterators over the Tuple instances that
 * encapsulate access to that row. Both types of iteration can also be
 * filtered by providing a {@link prefuse.data.expression.Predicate},
 * allowing tables to be queried for specific values.

 *
 *
Columns (alternativele referred to as data fields) can be added to
 * the Table using {@link #addColumn(String, Class)} and a host of
 * similar methods. This method will automatically determine the right
 * kind of backing column instance to use. Furthermore, Table columns
 * can be specified using a {@link Schema} instance, which describes
 * the column names, data types, and default values. The Table class
 * also maintains its own internal Schema, which be accessed (in a
 * read-only way) using the {@link #getSchema()} method.

 *
 *
Tables also support additional structures. The {@link ColumnMetadata}
 * class returned by the {@link #getMetadata(String)} method supports
 * calculation of different statistics for a column, including minimum
 * and maximum values, and the number of unique data values in the column.
 * {@link prefuse.data.util.Index} instances can be created and retrieved
 * using the {@link #index(String)} method and retrieved without triggering
 * creation using {@link #getIndex(String)} method. An index keeps a
 * sorted collection of all data values in a column, accelerating the creation
 * of filtered iterators by optimizing query calculations and also providing
 * faster computation of many of the {@link ColumnMetadata} methods. If
 * you will be issuing a number of queries (i.e., requesting filtered
 * iterators) dependent on the values of a given column, indexing that column
 * may result in a significant performance increase, though at the cost
 * of storing and maintaining the backing index structure.

 *
 * @author jeffrey heer
 */
public class Table extends AbstractTupleSet implements ColumnListener {

    /** Listeners for changes to this table */
    protected CopyOnWriteArrayList m_listeners;

    /** Locally stored data columns */
    protected ArrayList m_columns;
    /** Column names for locally store data columns */
    protected ArrayList m_names;

    /** Mapping between column names and column entries
     * containing column, metadata, and index references */
    protected HashMap m_entries;

    /** Manager for valid row indices */
    protected RowManager m_rows;

    /** manager for tuples, which are object representations for rows */
    protected TupleManager m_tuples;

    /** Tracks the number of edits of this table */
    protected int m_modCount = 0;

    /** Memoize the index of the last column operated on,
     * used to expedite handling of column updates. */
    protected int m_lastCol = -1;

    /** A cached schema instance, loaded lazily */
    protected Schema m_schema;

    // ------------------------------------------------------------------------
    // Constructors

    /**
     * Create a new, empty Table. Rows can be added to the table using
     * the {@link #addRow()} method.
     */
    public Table() {
        this(0, 0);
    }

    /**
     * Create a new Table with a given number of rows, and the starting
     * capacity for a given number of columns.
     * @param nrows the starting number of table rows
     * @param ncols the starting capacity for columns
     */
    public Table(int nrows, int ncols) {
        this(nrows, ncols, TableTuple.class);
    }

    /**
     * Create a new Table.
     * @param nrows the starting number of table rows
     * @param ncols the starting capacity for columns
     * @param tupleType the class of the Tuple instances to use
     */
    protected Table(int nrows, int ncols, Class tupleType) {
        m_listeners = new CopyOnWriteArrayList();
        m_columns = new ArrayList(ncols);
        m_names = new ArrayList(ncols);
        m_rows = new RowManager(this);
        m_entries = new HashMap(ncols+5);
        m_tuples = new TupleManager(this, null, tupleType);

        if ( nrows > 0 )
            addRows(nrows);
    }

    // ------------------------------------------------------------------------
    // Table Metadata

    /**
     * Get the number of columns / data fields in this table.
     * @return the number of columns
     */
    public int getColumnCount() {
        return m_columns.size();
    }

    /**
     * Get the data type of the column at the given column index.
     * @param col the column index
     * @return the data type (as a Java Class) of the column
     */
    public Class getColumnType(int col) {
        return getColumn(col).getColumnType();
    }

    /**
     * Get the data type of the column with the given data field name.
     * @param field the column / data field name
     * @return the data type (as a Java Class) of the column
     */
    public Class getColumnType(String field) {
        Column c = getColumn(field);
        return (c==null ? null : c.getColumnType());
    }

    /**
     * Get the number of rows in the table.
     * @return the number of rows
     */
    public int getRowCount() {
        return m_rows.getRowCount();
    }

    /**
     * Get the minimum row index currently in use by this Table.
     * @return the minimum row index
     */
    public int getMinimumRow() {
        return m_rows.getMinimumRow();
    }

    /**
     * Get the maximum row index currently in use by this Table.
     * @return the maximum row index
     */
    public int getMaximumRow() {
        return m_rows.getMaximumRow();
    }

    /**
     * Indicates if the value of the given table cell can be changed.
     * @param row the row number
     * @param col the column number
     * @return true if the value can be edited/changed, false otherwise
     */
    public boolean isCellEditable(int row, int col) {
        if ( !m_rows.isValidRow(row) ) {
            return false;
        } else {
            return getColumn(col).isCellEditable(row);
        }
    }

    /**
     * Get the number of times this Table has been modified. Adding rows,
     * deleting rows, and updating table cell values all contribute to
     * this count.
     * @return the number of modifications to this table
     */
    public int getModificationCount() {
        return m_modCount;
    }

    /**
     * Sets the TupleManager used by this Table. Use this method
     * carefully, as it will cause all existing Tuples retrieved
     * from this Table to be invalidated.
     * @param tm the TupleManager to use
     */
    public void setTupleManager(TupleManager tm) {
        m_tuples.invalidateAll();
        m_tuples = tm;
    }

    /**
     * Returns this Table's schema. The returned schema will be
     * locked, which means that any attempts to edit the returned schema
     * by adding additional columns will result in a runtime exception.
     *
     * If this Table subsequently has columns added or removed, this will not
     * be reflected in the returned schema. Instead, this method will need to
     * be called again to get a current schema. Accordingly, it is not
     * recommended that Schema instances returned by this method be stored
     * or reused across scopes unless that exact schema snapshot is
     * desired.
     *
     * @return a copy of this Table's schema
     */
    public Schema getSchema() {
        if ( m_schema == null ) {
            Schema s = new Schema();
            for ( int i=0; i<getColumnCount(); ++i ) {
                s.addColumn(getColumnName(i), getColumnType(i),
                            getColumn(i).getDefaultValue());
            }
            s.lockSchema();
            m_schema = s;
        }
        return m_schema;
    }

    /**
     * Invalidates this table's cached schema. This method should be called
     * whenever columns are added or removed from this table.
     */
    protected void invalidateSchema() {
        m_schema = null;
    }

    // ------------------------------------------------------------------------
    // Row Operations

    /**
     * Get the row value for accessing an underlying Column instance,
     * corresponding to the given table cell. For basic tables this just
     * returns the input row value. However, for tables that inherit
     * data columns from a parent table and present a filtered view on
     * this data, a mapping between the row numbers of the table and
     * the row numbers of the backing data column is needed. In those cases,
     * this method returns the result of that mapping. The method
     * {@link #getTableRow(int, int)} accesses this map in the reverse
     * direction.
     * @param row the table row to lookup
     * @param col the table column to lookup
     * @return the column row number for accessing the desired table cell
     */
    public int getColumnRow(int row, int col) {
        return m_rows.getColumnRow(row, col);
    }

    /**
     * Get the row number for this table given a row number for a backing
     * data column and the column number for the data column. For basic
     * tables this just returns the column row value. However, for tables that
     * inherit data columns from a parent table and present a filtered view on
     * this data, a mapping between the row numbers of the table and
     * the row numbers of the backing data column is needed. In those cases,
     * this method returns the result of this mapping, in the direction of
     * the backing column rows to the table rows of the cascaded table. The
     * method {@link #getColumnRow(int, int)} accesses this map in the reverse
     * direction.
     * @param colrow the row of the backing data column
     * @param col the table column to lookup.
     * @return the table row number for accessing the desired table cell
     */
    public int getTableRow(int colrow, int col) {
        return m_rows.getTableRow(colrow, col);
    }

    /**
     * Add a row to this table. All data columns will be notified and will
     * take on the appropriate default values for the added row.
     * @return the row number of the newly added row
     */
    public int addRow() {
        int r = m_rows.addRow();
        updateRowCount();

        fireTableEvent(r, r, TableModelEvent.ALL_COLUMNS,
                       TableModelEvent.INSERT);
        return r;
    }

    /**
     * Add a given number of rows to this table. All data columns will be
     * notified and will take on the appropriate default values for the
     * added rows.
     * @param nrows the number of rows to add.
     */
    public void addRows(int nrows) {
        for ( int i=0; i<nrows; ++i ) {
            addRow();
        }
    }

    /**
     * Internal method that updates the row counts for local data columns.
     */
    protected void updateRowCount() {
        int maxrow = m_rows.getMaximumRow() + 1;

        // update columns
        Iterator cols = getColumns();
        while ( cols.hasNext() ) {
            Column c = (Column)cols.next();
            c.setMaximumRow(maxrow);
        }
    }

    /**
     * Removes a row from this table.
     * @param row the row to delete
     * @return true if the row was successfully deleted, false if the
     * row was already invalid
     */
    public boolean removeRow(int row) {
        if ( m_rows.isValidRow(row) ) {
            // the order of operations here is extremely important
            // otherwise listeners may end up with corrupted state.
            // fire update *BEFORE* clearing values
            // allow listeners (e.g., indices) to perform clean-up
            fireTableEvent(row, row, TableModelEvent.ALL_COLUMNS,
                           TableModelEvent.DELETE);
            // invalidate the tuple
            m_tuples.invalidate(row);
            // release row with row manager
            // do this before clearing column values, so that any
            // listeners can determine that the row is invalid
            m_rows.releaseRow(row);
            // now clear column values
            for ( Iterator cols = getColumns(); cols.hasNext(); ) {
                Column c = (Column)cols.next();
                c.revertToDefault(row);
            }
            return true;
        }
        return false;
    }

    /**
     * Clear this table, removing all rows.
     * @see prefuse.data.tuple.TupleSet#clear()
     */
    public void clear() {
        IntIterator rows = rows(true);
        while ( rows.hasNext() ) {
            removeRow(rows.nextInt());
        }
    }

    /**
     * Indicates if the given row number corresponds to a valid table row.
     * @param row the row number to check for validity
     * @return true if the row is valid, false if it is not
     */
    public boolean isValidRow(int row) {
        return m_rows.isValidRow(row);
    }

    // ------------------------------------------------------------------------
    // Column Operations

    /**
     * Internal method indicating if the given data field is included as a
     * data column.
     */
    protected boolean hasColumn(String name) {
        return getColumnNumber(name) != -1;
    }

    /**
     * Get the data field name of the column at the given column number.
     * @param col the column number
     * @return the data field name of the column
     */
    public String getColumnName(int col) {
        return (String)m_names.get(col);
    }

    /**
     * Get the column number for a given data field name.
     * @param field the name of the column to lookup
     * @return the column number of the column, or -1 if the name is not found
     */
    public int getColumnNumber(String field) {
        ColumnEntry e = (ColumnEntry)m_entries.get(field);
        return ( e==null ? -1 : e.colnum );
    }

    /**
     * Get the column number for the given Column instance.
     * @param col the Column instance to lookup
     * @return the column number of the column, or -1 if the name is not found
     */
    public int getColumnNumber(Column col) {
        return m_columns.indexOf(col);
    }

    /**
     * Get the column at the given column number.
     * @param col the column number
     * @return the Column instance
     */
    public Column getColumn(int col) {
        m_lastCol = col;
        return (Column)m_columns.get(col);
    }

    /**
     * Get the column with the given data field name
     * @param field the data field name of the column
     * @return the Column instance
     */
    public Column getColumn(String field) {
        ColumnEntry e = (ColumnEntry)m_entries.get(field);
        return ( e != null ? e.column : null );
    }

    /**
     * Add a column with the given name and data type to this table.
     * @param name the data field name for the column
     * @param type the data type, as a Java Class, for the column
     * @see prefuse.data.tuple.TupleSet#addColumn(java.lang.String, java.lang.Class)
     */
    public void addColumn(String name, Class type) {
        addColumn(name, type, null);
    }

    /**
     * Add a column with the given name and data type to this table.
     * @param name the data field name for the column
     * @param type the data type, as a Java Class, for the column
     * @param defaultValue the default value for column data values
     * @see prefuse.data.tuple.TupleSet#addColumn(java.lang.String, java.lang.Class, java.lang.Object)
     */
    public void addColumn(String name, Class type, Object defaultValue) {
        Column col = ColumnFactory.getColumn(type,
                        m_rows.getMaximumRow()+1, defaultValue);
        addColumn(name, col);
    }

    /**
     * Add a derived column to this table, using an Expression instance to
     * dynamically calculate the column data values.
     * @param name the data field name for the column
     * @param expr a String expression in the prefuse expression language, to
     * be parsed into an {@link prefuse.data.expression.Expression} instance.
     * The string is parsed by the
     * {@link prefuse.data.expression.parser.ExpressionParser}. If an error
     * occurs during parsing, an exception will be thrown.
     * @see prefuse.data.tuple.TupleSet#addColumn(java.lang.String, java.lang.String)
     */
    public void addColumn(String name, String expr) {
        Expression ex = ExpressionParser.parse(expr);
        Throwable t = ExpressionParser.getError();
        if ( t != null ) {
            throw new RuntimeException(t);
        } else {
            addColumn(name, ex);
        }
    }

    /**
     * Add a derived column to this table, using an Expression instance to
     * dynamically calculate the column data values.
     * @param name the data field name for the column
     * @param expr the Expression that will determine the column values
     * @see prefuse.data.tuple.TupleSet#addColumn(java.lang.String, prefuse.data.expression.Expression)
     */
    public void addColumn(String name, Expression expr) {
        addColumn(name, ColumnFactory.getColumn(this, expr));
    }

    /**
     * Add a constant column to this table, which returns one constant value
     * for all column rows.
     * @param name the data field name for the column
     * @param type the data type, as a Java Class, for the column
     * @param dflt the default value for column data values
     */
    public void addConstantColumn(String name, Class type, Object dflt) {
        addColumn(name, ColumnFactory.getConstantColumn(type, dflt));
    }

    /**
     * Internal method for adding a column.
     * @param name the name of the column
     * @param col the actual Column instance
     */
    protected void addColumn(String name, Column col) {
        int idx = getColumnNumber(name);
        if ( idx >= 0 && idx < m_columns.size() ) {
        	if (!getColumnType(idx).equals(col.getColumnType())) {
            	throw new IllegalArgumentException(
            			"Table already has column with name \""+name+"\"" + " and type " + getColumnType(idx));
            }
            // column already exists with given type, do nothing
            return;
        }

        // add the column
        m_columns.add(col);
        m_names.add(name);
        m_lastCol = m_columns.size()-1;
        ColumnEntry entry = new ColumnEntry(m_lastCol, col,
                new ColumnMetadata(this, name));

        // add entry, dispose of an overridden entry if needed
        ColumnEntry oldEntry = (ColumnEntry)m_entries.put(name, entry);
        if ( oldEntry != null ) oldEntry.dispose();

        invalidateSchema();

        // listen to what the column has to say
        col.addColumnListener(this);

        // fire notification
        fireTableEvent(m_rows.getMinimumRow(), m_rows.getMaximumRow(),
                m_lastCol, TableModelEvent.INSERT);
    }

    /**
     * Internal method for removing a column.
     * @param idx the column number of the column to remove
     * @return the removed Column instance
     */
    protected Column removeColumn(int idx) {
        // make sure index is legal
        if ( idx < 0 || idx >= m_columns.size() ) {
            throw new IllegalArgumentException("Column index is not legal.");
        }

        String name = (String)m_names.get(idx);
        ((ColumnEntry)m_entries.get(name)).dispose();
        Column col = (Column)m_columns.remove(idx);
        m_entries.remove(name);
        m_names.remove(idx);
        renumberColumns();

        m_lastCol = -1;
        invalidateSchema();

        // ignore what the old column has to say
        col.removeColumnListener(this);

        // fire notification
        fireTableEvent(m_rows.getMinimumRow(), m_rows.getMaximumRow(),
                       idx, TableModelEvent.DELETE);

        return col;
    }

    /**
     * Remove a data field from this table
     * @param field the name of the data field / column to remove
     * @return the removed Column instance
     */
    public Column removeColumn(String field) {
        int idx = m_names.indexOf(field);
        if ( idx < 0 ) {
            throw new IllegalArgumentException("No such column.");
        }
        return removeColumn(idx);
    }

    /**
     * Remove a column from this table
     * @param c the column instance to remove
     */
    public void removeColumn(Column c) {
        int idx = m_columns.indexOf(c);
        if ( idx < 0 ) {
            throw new IllegalArgumentException("No such column.");
        }
        removeColumn(idx);
    }

    /**
     * Internal method that re-numbers columns upon column removal.
     */
    protected void renumberColumns() {
        Iterator iter = m_names.iterator();
        for ( int idx=0; iter.hasNext(); ++idx ) {
            String name = (String)iter.next();
            ColumnEntry e = (ColumnEntry)m_entries.get(name);
            e.colnum = idx;
        }
    }

    /**
     * Internal method that returns an iterator over columns
     * @return an iterator over columns
     */
    protected Iterator getColumns() {
        return m_columns.iterator();
    }

    /**
     * Internal method that returns an iterator over column names
     * @return an iterator over column name
     */
    protected Iterator getColumnNames() {
        return m_names.iterator();
    }

    // ------------------------------------------------------------------------
    // Column Metadata

    /**
     * Return a metadata instance providing summary information about a column.
     * @param field the data field name of the column
     * @return the columns' associated ColumnMetadata instance
     */
    public ColumnMetadata getMetadata(String field) {
        ColumnEntry e = (ColumnEntry)m_entries.get(field);
        if ( e == null ) {
            throw new IllegalArgumentException("Unknown column name: "+field);
        }
        return e.metadata;
    }

    // ------------------------------------------------------------------------
    // Index Methods

    /**
     * Create (if necessary) and return an index over the given data field.
     * The first call to this method with a given field name will cause the
     * index to be created and stored. Subsequent calls will simply return
     * the stored index. To attempt to retrieve an index without triggering
     * creation of a new index, use the {@link #getIndex(String)} method.
     * @param field the data field name of the column to index
     * @return the index over the specified data column
     */
    public Index index(String field) {
        ColumnEntry e = (ColumnEntry)m_entries.get(field);
        if ( e == null ) {
            throw new IllegalArgumentException("Unknown column name: "+field);
        } else if ( e.index != null ) {
            return e.index; // already indexed
        }

        Column col = e.column;
        try {
            e.index = new TreeIndex(this, m_rows, col, null);
        } catch ( IncompatibleComparatorException ice ) { /* can't happen */ }

        return e.index;
    }

    /**
     * Retrieve, without creating, an index for the given data field.
     * @param field the data field name of the column
     * @return the stored index for the column, or null if no index has
     * been created
     */
    public Index getIndex(String field) {
        ColumnEntry e = (ColumnEntry)m_entries.get(field);
        if ( e == null ) {
            throw new IllegalArgumentException("Unknown column name: "+field);
        }
        return e.index;
    }

    /**
     * Internal method for index creation and retrieval.
     * @param field the data field name of the column
     * @param expType the expected data type of the index
     * @param create indicates whether or not a new index should be created
     * if none currently exists for the given data field
     * @return the Index for the given data field
     */
    protected Index getIndex(String field, Class expType, boolean create) {
        if ( !expType.equals(getColumnType(field)) ) {
            // TODO: need more nuanced type checking here?
            throw new IllegalArgumentException("Column type does not match.");
        }
        if ( getIndex(field)==null && create) {
            index(field);
        }
        return getIndex(field);
    }

    /**
     * Remove the Index associated with the given data field / column name.
     * @param field the name of the column for which to remove the index
     * @return true if an index was successfully removed, false if no
     * such index was found
     */
    public boolean removeIndex(String field) {
        ColumnEntry e = (ColumnEntry)m_entries.get(field);
        if ( e == null ) {
            throw new IllegalArgumentException("Unknown column name: "+field);
        }
        if ( e.index == null ) {
            return false;
        } else {
            e.index.dispose();
            e.index = null;
            return true;
        }
    }

    // ------------------------------------------------------------------------
    // Tuple Methods

    /**
     * Get the Tuple instance providing object-oriented access to the given
     * table row.
     * @param row the table row
     * @return the Tuple for the given table row
     */
    public Tuple getTuple(int row) {
        return m_tuples.getTuple(row);
    }

    /**
     * Add a Tuple to this table. If the Tuple is already a member of this
     * table, nothing is done and null is returned. If the Tuple is not
     * a member of this Table but has a compatible data schema, as
     * determined by {@link Schema#isAssignableFrom(Schema)}, a new row
     * is created, the Tuple's values are copied, and the new Tuple that
     * is a member of this Table is returned. If the data schemas are not
     * compatible, nothing is done and null is returned.
     * @param t the Tuple to "add" to this table
     * @return the actual Tuple instance added to this table, or null if
     * no new Tuple has been added
     * @see prefuse.data.tuple.TupleSet#addTuple(prefuse.data.Tuple)
     */
    public Tuple addTuple(Tuple t) {
        if ( t.getTable() == this ) {
            return null;
        } else {
            Schema s = t.getSchema();
            if ( getSchema().isAssignableFrom(s) ) {
                int r = addRow();
                for ( int i=0; i<s.getColumnCount(); ++i ) {
                    String field = s.getColumnName(i);
                    this.set(r, field, t.get(i));
                }
                return getTuple(r);
            } else {
                return null;
            }
        }
    }

    /**
     * Clears the contents of this table and then attempts to add the given
     * Tuple instance.
     * @param t the Tuple to make the sole tuple in thie table
     * @return the actual Tuple instance added to this table, or null if
     * no new Tuple has been added
     * @see prefuse.data.tuple.TupleSet#setTuple(prefuse.data.Tuple)
     */
    public Tuple setTuple(Tuple t) {
        clear();
        return addTuple(t);
    }

    /**
     * Remove a tuple from this table. If the Tuple is a member of this table,
     * its row is deleted from the table. Otherwise, nothing is done.
     * @param t the Tuple to remove from the table
     * @return true if the Tuple row was successfully deleted, false if the
     * Tuple is invalid or not a member of this table
     * @see prefuse.data.tuple.TupleSet#removeTuple(prefuse.data.Tuple)
     */
    public boolean removeTuple(Tuple t) {
        if ( containsTuple(t) ) {
            removeRow(t.getRow());
            return true;
        } else {
            return false;
        }
    }

    /**
     * Indicates if this table contains the given Tuple instance.
     * @param t the Tuple to check for containment
     * @return true if the Tuple represents a row of this table, false if
     * it does not
     * @see prefuse.data.tuple.TupleSet#containsTuple(prefuse.data.Tuple)
     */
    public boolean containsTuple(Tuple t) {
        return (t.getTable()==this && isValidRow(t.getRow()));
    }

    /**
     * Get the number of tuples in this table. This is the same as the
     * value returned by {@link #getRowCount()}.
     * @return the number of tuples, which is the same as the number of rows
     * @see prefuse.data.tuple.TupleSet#getTupleCount()
     */
    public int getTupleCount() {
        return getRowCount();
    }

    /**
     * Returns true, as this table supports the addition of new data fields.
     * @see prefuse.data.tuple.TupleSet#isAddColumnSupported()
     */
    public boolean isAddColumnSupported() {
        return true;
    }

    // ------------------------------------------------------------------------
    // Data Access Methods

    /**
     * Check if the get method for the given data field returns
     * values that are compatible with a given target type.
     * @param field the data field to check
     * @param type a Class instance to check for compatibility with the
     * data field values.
     * @return true if the data field is compatible with provided type,
     * false otherwise. If the value is true, objects returned by
     * the {@link #get(int, String)} can be cast to the given type.
     * @see #get(int, String)
     */
    public boolean canGet(String field, Class type) {
        Column c = getColumn(field);
        return ( c==null ? false : c.canGet(type) );
    }

    /**
     * Check if the set method for the given data field can
     * accept values of a given target type.
     * @param field the data field to check
     * @param type a Class instance to check for compatibility with the
     * data field values.
     * @return true if the data field is compatible with provided type,
     * false otherwise. If the value is true, objects of the given type
     * can be used as parameters of the {@link #set(int, String, Object)}
     * method.
     * @see #set(int, String, Object)
     */
    public boolean canSet(String field, Class type) {
        Column c = getColumn(field);
        return ( c==null ? false : c.canSet(type) );
    }

    /**
     * Get the data value at the given row and field as an Object.
     * @param row the table row to get
     * @param field the data field to retrieve
     * @return the data value as an Object. The concrete type of this
     * Object is dependent on the underlying data column used.
     * @see #canGet(String, Class)
     * @see #getColumnType(String)
     */
    public Object get(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).get(row);
    }

    /**
     * Set the value of a given row and data field.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value for the field. If the concrete type of this
     * Object is not compatible with the underlying data model, an
     * Exception will be thrown. Use the {@link #canSet(String, Class)}
     * method to check the type-safety ahead of time.
     * @see #canSet(String, Class)
     * @see #getColumnType(String)
     */
    public void set(int row, String field, Object val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).set(val, row);

        // we don't fire a notification here, as we catch the
        // notification from the column itself and then dispatch
    }

    /**
     * Get the data value at the given row and column numbers as an Object.
     * @param row the row number
     * @param col the column number
     * @return the data value as an Object. The concrete type of this
     * Object is dependent on the underlying data column used.
     * @see #canGet(String, Class)
     * @see #getColumnType(int)
     */
    public Object get(int row, int col) {
        row = getColumnRow(row, col);
        return getColumn(col).get(row);
    }

    /**
     * Set the value of at the given row and column numbers.
     * @param row the row number
     * @param col the column number
     * @param val the value for the field. If the concrete type of this
     * Object is not compatible with the underlying data model, an
     * Exception will be thrown. Use the {@link #canSet(String, Class)}
     * method to check the type-safety ahead of time.
     * @see #canSet(String, Class)
     * @see #getColumnType(String)
     */
    public void set(int row, int col, Object val) {
        row = getColumnRow(row, col);
        getColumn(col).set(val, row);

        // we don't fire a notification here, as we catch the
        // notification from the column itself and then dispatch
    }

    /**
     * Get the default value for the given data field.
     * @param field the data field
     * @return the default value, as an Object, used to populate rows
     * of the data field.
     */
    public Object getDefault(String field) {
        int col = getColumnNumber(field);
        return getColumn(col).getDefaultValue();
    }

    /**
     * Revert this tuple's value for the given field to the default value
     * for the field.
     * @param field the data field
     * @see #getDefault(String)
     */
    public void revertToDefault(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).revertToDefault(row);
    }

    // ------------------------------------------------------------------------
    // Convenience Data Access Methods

    /**
     * Check if the given data field can return primitive int
     * values.
     * @param field the data field to check
     * @return true if the data field can return primitive int
     * values, false otherwise. If true, the {@link #getInt(int, String)}
     * method can be used safely.
     */
    public final boolean canGetInt(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canGetInt() );
    }

    /**
     * Check if the setInt method can safely be used for the
     * given data field.
     * @param field the data field to check
     * @return true if the {@link #setInt(int, String, int)} method can safely
     * be used for the given field, false otherwise.
     */
    public final boolean canSetInt(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canSetInt() );
    }

    /**
     * Get the data value at the given row and field as an
     * int.
     * @param row the table row to retrieve
     * @param field the data field to retrieve
     * @see #canGetInt(String)
     */
    public final int getInt(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).getInt(row);
    }

    /**
     * Set the data value of the given row and field as an
     * int.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value to set
     * @see #canSetInt(String)
     */
    public final void setInt(int row, String field, int val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).setInt(val, row);
    }

    /**
     * Get the data value at the given row and field as an
     * int.
     * @param row the table row to retrieve
     * @param col the column number of the data field to retrieve
     * @see #canGetInt(String)
     */
    public final int getInt(int row, int col) {
        row = getColumnRow(row, col);
        return getColumn(col).getInt(row);
    }

    /**
     * Set the data value of the given row and field as an
     * int.
     * @param row the table row to set
     * @param col the column number of the data field to set
     * @param val the value to set
     * @see #canSetInt(String)
     */
    public final void setInt(int row, int col, int val) {
        row = getColumnRow(row, col);
        getColumn(col).setInt(val, row);
    }

    // --------------------------------------------------------------

    /**
     * Check if the given data field can return primitive long
     * values.
     * @param field the data field to check
     * @return true if the data field can return primitive long
     * values, false otherwise. If true, the {@link #getLong(int, String)}
     * method can be used safely.
     */
    public final boolean canGetLong(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canGetLong() );
    }

    /**
     * Check if the setLong method can safely be used for the
     * given data field.
     * @param field the data field to check
     * @return true if the {@link #setLong(int, String, long)} method can
     * safely be used for the given field, false otherwise.
     */
    public final boolean canSetLong(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canSetLong() );
    }

    /**
     * Get the data value at the given row and field as a
     * long.
     * @param row the table row to retrieve
     * @param field the data field to retrieve
     * @see #canGetLong(String)
     */
    public final long getLong(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).getLong(row);
    }

    /**
     * Set the data value of the given row and field as a
     * long.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value to set
     * @see #canSetLong(String)
     */
    public final void setLong(int row, String field, long val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).setLong(val, row);
    }

    /**
     * Get the data value at the given row and field as an
     * long.
     * @param row the table row to retrieve
     * @param col the column number of the data field to retrieve
     * @see #canGetLong(String)
     */
    public final long getLong(int row, int col)  {
        row = getColumnRow(row, col);
        return getColumn(col).getLong(row);
    }

    /**
     * Set the data value of the given row and field as an
     * long.
     * @param row the table row to set
     * @param col the column number of the data field to set
     * @param val the value to set
     * @see #canSetLong(String)
     */
    public final void setLong(int row, int col, long val) {
        row = getColumnRow(row, col);
        getColumn(col).setLong(val, row);
    }

    // --------------------------------------------------------------

    /**
     * Check if the given data field can return primitive float
     * values.
     * @param field the data field to check
     * @return true if the data field can return primitive float
     * values, false otherwise. If true, the {@link #getFloat(int, String)}
     * method can be used safely.
     */
    public final boolean canGetFloat(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canGetFloat() );
    }

    /**
     * Check if the setFloat method can safely be used for the
     * given data field.
     * @param field the data field to check
     * @return true if the {@link #setFloat(int, String, float)} method can
     * safely be used for the given field, false otherwise.
     */
    public final boolean canSetFloat(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canSetFloat() );
    }

    /**
     * Get the data value at the given row and field as a
     * float.
     * @param row the table row to retrieve
     * @param field the data field to retrieve
     * @see #canGetFloat(String)
     */
    public final float getFloat(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).getFloat(row);
    }

    /**
     * Set the data value of the given row and field as a
     * float.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value to set
     * @see #canSetFloat(String)
     */
    public final void setFloat(int row, String field, float val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).setFloat(val, row);
    }

    /**
     * Get the data value at the given row and field as a
     * float.
     * @param row the table row to retrieve
     * @param col the column number of the data field to get
     * @see #canGetFloat(String)
     */
    public final float getFloat(int row, int col) {
        row = getColumnRow(row, col);
        return getColumn(col).getFloat(row);
    }

    /**
     * Set the data value of the given row and field as a
     * float.
     * @param row the table row to set
     * @param col the column number of the data field to set
     * @param val the value to set
     * @see #canSetFloat(String)
     */
    public final void setFloat(int row, int col, float val) {
        row = getColumnRow(row, col);
        getColumn(col).setFloat(val, row);
    }

    // --------------------------------------------------------------

    /**
     * Check if the given data field can return primitive double
     * values.
     * @param field the data field to check
     * @return true if the data field can return primitive double
     * values, false otherwise. If true, the {@link #getDouble(int, String)}
     * method can be used safely.
     */
    public final boolean canGetDouble(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canGetDouble() );
    }

    /**
     * Check if the setDouble method can safely be used for the
     * given data field.
     * @param field the data field to check
     * @return true if the {@link #setDouble(int, String, double)} method can
     * safely be used for the given field, false otherwise.
     */
    public final boolean canSetDouble(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canSetDouble() );
    }

    /**
     * Get the data value at the given row and field as a
     * double.
     * @param row the table row to retrieve
     * @param field the data field to retrieve
     * @see #canGetDouble(String)
     */
    public final double getDouble(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).getDouble(row);
    }

    /**
     * Set the data value of the given row and field as a
     * double.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value to set
     * @see #canSetDouble(String)
     */
    public final void setDouble(int row, String field, double val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).setDouble(val, row);
    }

    /**
     * Get the data value at the given row and field as a
     * double.
     * @param row the table row to retrieve
     * @param col the column number of the data field to get
     * @see #canGetDouble(String)
     */
    public final double getDouble(int row, int col) {
        row = getColumnRow(row, col);
        return getColumn(col).getDouble(row);
    }

    /**
     * Set the data value of the given row and field as a
     * double.
     * @param row the table row to set
     * @param col the column number of the data field to set
     * @param val the value to set
     * @see #canSetDouble(String)
     */
    public final void setDouble(int row, int col, double val) {
        row = getColumnRow(row, col);
        getColumn(col).setDouble(val, row);
    }

    // --------------------------------------------------------------

    /**
     * Check if the given data field can return primitive boolean
     * values.
     * @param field the data field to check
     * @return true if the data field can return primitive boolean
     * values, false otherwise. If true, the {@link #getBoolean(int, String)}
     * method can be used safely.
     */
    public final boolean canGetBoolean(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canGetBoolean() );
    }

    /**
     * Check if the setBoolean method can safely be used for the
     * given data field.
     * @param field the data field to check
     * @return true if the {@link #setBoolean(int, String, boolean)} method can
     * safely be used for the given field, false otherwise.
     */
    public final boolean canSetBoolean(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canSetBoolean() );
    }

    /**
     * Get the data value at the given row and field as a
     * boolean.
     * @param row the table row to retrieve
     * @param field the data field to retrieve
     * @see #canGetBoolean(String)
     */
    public final boolean getBoolean(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).getBoolean(row);
    }

    /**
     * Set the data value of the given row and field as a
     * boolean.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value to set
     * @see #canSetBoolean(String)
     */
    public final void setBoolean(int row, String field, boolean val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).setBoolean(val, row);
    }

    /**
     * Get the data value at the given row and field as a
     * boolean.
     * @param row the table row to retrieve
     * @param col the column number of the data field to get
     * @see #canGetBoolean(String)
     */
    public final boolean getBoolean(int row, int col) {
        row = getColumnRow(row, col);
        return getColumn(col).getBoolean(row);
    }

    /**
     * Set the data value of the given row and field as a
     * boolean.
     * @param row the table row to set
     * @param col the column number of the data field to set
     * @param val the value to set
     * @see #canSetBoolean(String)
     */
    public final void setBoolean(int row, int col, boolean val) {
        row = getColumnRow(row, col);
        getColumn(col).setBoolean(val, row);
    }

    // --------------------------------------------------------------

    /**
     * Check if the given data field can return primitive String
     * values.
     * @param field the data field to check
     * @return true if the data field can return primitive String
     * values, false otherwise. If true, the {@link #getString(int, String)}
     * method can be used safely.
     */
    public final boolean canGetString(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canGetString() );
    }

    /**
     * Check if the setString method can safely be used for the
     * given data field.
     * @param field the data field to check
     * @return true if the {@link #setString(int, String, String)} method can
     * safely be used for the given field, false otherwise.
     */
    public final boolean canSetString(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canSetString() );
    }

    /**
     * Get the data value at the given row and field as a
     * String.
     * @param row the table row to retrieve
     * @param field the data field to retrieve
     * @see #canGetString(String)
     */
    public final String getString(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).getString(row);
    }

    /**
     * Set the data value of the given row and field as a
     * String.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value to set
     * @see #canSetString(String)
     */
    public final void setString(int row, String field, String val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).setString(val, row);
    }

    /**
     * Get the data value at the given row and field as a
     * String.
     * @param row the table row to retrieve
     * @param col the column number of the data field to retrieve
     * @see #canGetString(String)
     */
    public final String getString(int row, int col) {
        row = getColumnRow(row, col);
        return getColumn(col).getString(row);
    }

    /**
     * Set the data value of the given row and field as a
     * String.
     * @param row the table row to set
     * @param col the column number of the data field to set
     * @param val the value to set
     * @see #canSetString(String)
     */
    public final void setString(int row, int col, String val) {
        row = getColumnRow(row, col);
        getColumn(col).setString(val, row);
    }

    // --------------------------------------------------------------

    /**
     * Check if the given data field can return primitive Date
     * values.
     * @param field the data field to check
     * @return true if the data field can return primitive Date
     * values, false otherwise. If true, the {@link #getDate(int, String)}
     * method can be used safely.
     */
    public final boolean canGetDate(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canGetDate() );
    }

    /**
     * Check if the setDate method can safely be used for the
     * given data field.
     * @param field the data field to check
     * @return true if the {@link #setDate(int, String, Date)} method can
     * safely be used for the given field, false otherwise.
     */
    public final boolean canSetDate(String field) {
        Column col = getColumn(field);
        return ( col==null ? false : col.canSetDate() );
    }

    /**
     * Get the data value at the given row and field as a
     * Date.
     * @param row the table row to retrieve
     * @param field the data field to retrieve
     * @see #canGetDate(String)
     */
    public final Date getDate(int row, String field) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        return getColumn(col).getDate(row);
    }

    /**
     * Set the data value of the given row and field as a
     * Date.
     * @param row the table row to set
     * @param field the data field to set
     * @param val the value to set
     * @see #canSetDate(String)
     */
    public final void setDate(int row, String field, Date val) {
        int col = getColumnNumber(field);
        row = getColumnRow(row, col);
        getColumn(col).setDate(val, row);
    }

    /**
     * Get the data value at the given row and field as a
     * Date.
     * @param row the table row to retrieve
     * @param col the column number of the data field to retrieve
     * @see #canGetDate(String)
     */
    public final Date getDate(int row, int col) {
        row = getColumnRow(row, col);
        return getColumn(col).getDate(row);
    }

    /**
     * Set the data value of the given row and field as a
     * Date.
     * @param row the table row to set
     * @param col the column number of the data field to set
     * @param val the value to set
     * @see #canSetDate(String)
     */
    public final void setDate(int row, int col, Date val) {
        row = getColumnRow(row, col);
        getColumn(col).setDate(val, row);
    }

    // ------------------------------------------------------------------------
    // Query Operations

    /**
     * Query this table for a filtered, sorted subset of this table. This
     * operation creates an entirely new table independent of this table.
     * If a filtered view of this same table is preferred, use the
     * {@link CascadedTable} class.
     * @param filter the predicate filter determining which rows to include
     * in the new table. If this value is null, all rows will be included.
     * @param sort the sorting criteria determining the order in which
     * rows are added to the new table. If this value is null, the rows
     * will not be sorted.
     * @return a new table meeting the query specification
     */
    public Table select(Predicate filter, Sort sort) {
        Table t = getSchema().instantiate();
        Iterator tuples = tuples(filter, sort);
        while ( tuples.hasNext() ) {
            t.addTuple((Tuple)tuples.next());
        }
        return t;
    }

    /**
     * Removes all table rows that meet the input predicate filter.
     * @param filter a predicate specifying which rows to remove from
     * the table.
     */
    public void remove(Predicate filter) {
        for ( IntIterator ii = rows(filter); ii.hasNext(); )
            removeRow(ii.nextInt());
    }

    // ------------------------------------------------------------------------
    // Iterators

    /**
     * Return a TableIterator over the rows of this table.
     * @return a TableIterator over this table
     */
    public TableIterator iterator() {
        return iterator(rows());
    }

    /**
     * Return a TableIterator over the given rows of this table.
     * @param rows an iterator over the table rows to visit
     * @return a TableIterator over this table
     */
    public TableIterator iterator(IntIterator rows) {
        return new TableIterator(this, rows);
    }

    /**
     * Get an iterator over the tuples in this table.
     * @return an iterator over the table tuples
     * @see prefuse.data.tuple.TupleSet#tuples()
     */
    public Iterator tuples() {
        return m_tuples.iterator(rows());
    }

    /**
     * Get an iterator over the tuples in this table in reverse order.
     * @return an iterator over the table tuples in reverse order
     */
    public Iterator tuplesReversed() {
        return m_tuples.iterator(rows(true));
    }

    /**
     * Get an iterator over the tuples for the given rows in this table.
     * @param rows an iterator over the table rows to visit
     * @return an iterator over the selected table tuples
     */
    public Iterator tuples(IntIterator rows) {
        return m_tuples.iterator(rows);
    }

    /**
     * Get an interator over the row numbers of this table.
     * @return an iterator over the rows of this table
     */
    public IntIterator rows() {
        return m_rows.rows();
    }

    /**
     * Get a filtered iterator over the row numbers of this table, returning
     * only the rows whose tuples match the given filter predicate.
     * @param filter the filter predicate to apply
     * @return a filtered iterator over the rows of this table
     */
    public IntIterator rows(Predicate filter) {
        return FilterIteratorFactory.rows(this, filter);
    }

    /**
     * Get an interator over the row numbers of this table.
     * @param reverse true to iterate in rever order, false for normal order
     * @return an iterator over the rows of this table
     */
    public IntIterator rows(boolean reverse) {
        return m_rows.rows(reverse);
    }

    /**
     * Get an iterator over the rows of this table, sorted by the given data
     * field. This method will create an index over the field if one does
     * not yet exist.
     * @param field the data field to sort by
     * @param ascend true if the iteration should proceed in an ascending
     * (lowest to highest) sort order, false for a descending order
     * @return the sorted iterator over rows of this table
     */
    public IntIterator rowsSortedBy(String field, boolean ascend) {
        Class type = getColumnType(field);
        Index index = getIndex(field, type, true);
        int t = ascend ? Index.TYPE_ASCENDING : Index.TYPE_DESCENDING;
        return index.allRows(t);
    }

    /**
     * Return an iterator over a range of rwos in this table, determined
     * by a bounded range for a given data field. A new index over the
     * data field will be created if it doesn't already exist.
     * @param field the data field for determining the bounded range
     * @param lo the minimum range value
     * @param hi the maximum range value
     * @param indexType indicate the sort order and inclusivity/exclusivity
     * of the range bounds, using the constants of the
     * {@link prefuse.data.util.Index} class.
     * @return an iterator over a range of table rows, determined by a
     * sorted bounded range of a data field
     */
    public IntIterator rangeSortedBy(String field, int lo, int hi, int indexType) {
        Index index = getIndex(field, int.class, true);
        return index.rows(lo, hi, indexType);
    }

    /**
     * Return an iterator over a range of rwos in this table, determined
     * by a bounded range for a given data field. A new index over the
     * data field will be created if it doesn't already exist.
     * @param field the data field for determining the bounded range
     * @param lo the minimum range value
     * @param hi the maximum range value
     * @param indexType indicate the sort order and inclusivity/exclusivity
     * of the range bounds, using the constants of the
     * {@link prefuse.data.util.Index} class.
     * @return an iterator over a range of table rows, determined by a
     * sorted bounded range of a data field
     */
    public IntIterator rangeSortedBy(String field, long lo, long hi, int indexType) {
        Index index = getIndex(field, long.class, true);
        return index.rows(lo, hi, indexType);
    }

    /**
     * Return an iterator over a range of rwos in this table, determined
     * by a bounded range for a given data field. A new index over the
     * data field will be created if it doesn't already exist.
     * @param field the data field for determining the bounded range
     * @param lo the minimum range value
     * @param hi the maximum range value
     * @param indexType indicate the sort order and inclusivity/exclusivity
     * of the range bounds, using the constants of the
     * {@link prefuse.data.util.Index} class.
     * @return an iterator over a range of table rows, determined by a
     * sorted bounded range of a data field
     */
    public IntIterator rangeSortedBy(String field, float lo, float hi, int indexType) {
        Index index = getIndex(field, float.class, true);
        return index.rows(lo, hi, indexType);
    }

    /**
     * Return an iterator over a range of rwos in this table, determined
     * by a bounded range for a given data field. A new index over the
     * data field will be created if it doesn't already exist.
     * @param field the data field for determining the bounded range
     * @param lo the minimum range value
     * @param hi the maximum range value
     * @param indexType indicate the sort order and inclusivity/exclusivity
     * of the range bounds, using the constants of the
     * {@link prefuse.data.util.Index} class.
     * @return an iterator over a range of table rows, determined by a
     * sorted bounded range of a data field
     */
    public IntIterator rangeSortedBy(String field, double lo, double hi, int indexType) {
        Index index = getIndex(field, double.class, true);
        return index.rows(lo, hi, indexType);
    }

    /**
     * Return an iterator over a range of rwos in this table, determined
     * by a bounded range for a given data field. A new index over the
     * data field will be created if it doesn't already exist.
     * @param field the data field for determining the bounded range
     * @param lo the minimum range value
     * @param hi the maximum range value
     * @param indexType indicate the sort order and inclusivity/exclusivity
     * of the range bounds, using the constants of the
     * {@link prefuse.data.util.Index} class.
     * @return an iterator over a range of table rows, determined by a
     * sorted bounded range of a data field
     */
    public IntIterator rangeSortedBy(String field, Object lo, Object hi, int indexType) {
        Class type = TypeLib.getSharedType(lo, hi);
        // TODO: check this for correctness
        if ( type == null )
            throw new IllegalArgumentException("Incompatible arguments");
        Index index = getIndex(field, type, true);
        return index.rows(lo, hi, indexType);
    }

    // ------------------------------------------------------------------------
    // Listener Methods

    // -- ColumnListeners -----------------------------------------------------

    /**
     * @see prefuse.data.event.ColumnListener#columnChanged(prefuse.data.column.Column, int, boolean)
     */
    public void columnChanged(Column src, int idx, boolean prev) {
        handleColumnChanged(src, idx, idx);
    }

    /**
     * @see prefuse.data.event.ColumnListener#columnChanged(prefuse.data.column.Column, int, double)
     */
    public void columnChanged(Column src, int idx, double prev) {
        handleColumnChanged(src, idx, idx);
    }

    /**
     * @see prefuse.data.event.ColumnListener#columnChanged(prefuse.data.column.Column, int, float)
     */
    public void columnChanged(Column src, int idx, float prev) {
        handleColumnChanged(src, idx, idx);
    }

    /**
     * @see prefuse.data.event.ColumnListener#columnChanged(prefuse.data.column.Column, int, int)
     */
    public void columnChanged(Column src, int idx, int prev) {
        handleColumnChanged(src, idx, idx);
    }

    /**
     * @see prefuse.data.event.ColumnListener#columnChanged(prefuse.data.column.Column, int, long)
     */
    public void columnChanged(Column src, int idx, long prev) {
        handleColumnChanged(src, idx, idx);
    }

    /**
     * @see prefuse.data.event.ColumnListener#columnChanged(prefuse.data.column.Column, int, java.lang.Object)
     */
    public void columnChanged(Column src, int idx, Object prev) {
        handleColumnChanged(src, idx, idx);
    }

    /**
     * @see prefuse.data.event.ColumnListener#columnChanged(prefuse.data.column.Column, int, int, int)
     */
    public void columnChanged(Column src, int type, int start, int end) {
        handleColumnChanged(src, start, end);
    }

    /**
     * Handle a column change event.
     * @param c the modified column
     * @param start the starting row of the modified range
     * @param end the ending row (inclusive) of the modified range
     */
    protected void handleColumnChanged(Column c, int start, int end) {
        for ( ; !isValidRow(start) && start <= end; ++start );
        if ( start > end ) return; // bail if no valid rows

        // determine the index of the updated column
        int idx;
        if ( m_lastCol != -1 && c == getColumn(m_lastCol) ) {
            // constant time
            idx = m_lastCol;
        } else {
            // linear time
            idx = getColumnNumber(c);
        }

        // if we have a valid index, fire a notification
        if ( idx >= 0 ) {
            fireTableEvent(start, end, idx, TableModelEvent.UPDATE);
        }
    }

    // -- TableListeners ------------------------------------------------------

    /**
     * Add a table listener to this table.
     * @param listnr the listener to add
     */
    public void addTableListener(TableListener listnr) {
        if ( !m_listeners.contains(listnr) )
            m_listeners.add(listnr);
    }

    /**
     * Remove a table listener from this table.
     * @param listnr the listener to remove
     */
    public void removeTableListener(TableListener listnr) {
        m_listeners.remove(listnr);
    }

    /**
     * Removes all table listeners from this table.
     */
    public void removeAllTableListeners() {
    	m_listeners.clear();
    }

    /**
     * Fire a table event to notify listeners.
     * @param row0 the starting row of the modified range
     * @param row1 the ending row (inclusive) of the modified range
     * @param col the number of the column modified, or
     * {@link prefuse.data.event.EventConstants#ALL_COLUMNS} for operations
     * effecting all columns.
     * @param type the table modification type, one of
     * {@link prefuse.data.event.EventConstants#INSERT},
     * {@link prefuse.data.event.EventConstants#DELETE}, or
     * {@link prefuse.data.event.EventConstants#UPDATE}.
     */
    protected void fireTableEvent(int row0, int row1, int col, int type) {
        // increment the modification count
        ++m_modCount;

        if ( type != EventConstants.UPDATE &&
             col == EventConstants.ALL_COLUMNS )
        {
            // fire event to all tuple set listeners
            fireTupleEvent(this, row0, row1, type);
        }

        if ( !m_listeners.isEmpty() ) {
            // fire event to all table listeners
            Object[] lstnrs = m_listeners.getArray();
            for ( int i=0; i<lstnrs.length; ++i ) {
                ((TableListener)lstnrs[i]).tableChanged(
                        this, row0, row1, col, type);
            }
        }
    }

    // ------------------------------------------------------------------------
    // String Methods

    /**
     * @see java.lang.Object#toString()
     */
    public String toString() {
        StringBuffer sbuf = new StringBuffer();
        sbuf.append("Table[");
        sbuf.append("rows=").append(getRowCount());
        sbuf.append(", cols=").append(getColumnCount());
        sbuf.append(", maxrow=").append(m_rows.getMaximumRow());
        sbuf.append("]");
        return sbuf.toString();
    }

    // ------------------------------------------------------------------------
    // ColumnEntry helper

    /**
     * Helper class that encapsulates a map entry for a column, including the
     * column itself and its metadata and index.
     *
     * @author jeffrey heer
     */
    protected static class ColumnEntry {

        /** The column number. */
        public int            colnum;
        /** The Column instance. */
        public Column         column;
        /** The column metadata instance. */
        public ColumnMetadata metadata;
        /** The column Index instance. */
        public Index          index;

        /**
         * Create a new ColumnEntry.
         * @param col the column number
         * @param column the Column instance
         * @param metadata the ColumnMetadata instance
         */
        public ColumnEntry(int col, Column column, ColumnMetadata metadata) {
            this.colnum = col;
            this.column = column;
            this.metadata = metadata;
            this.index = null;
        }

        /**
         * Dispose of this column entry, disposing of any allocated
         * metadata or index instances.
         */
        public void dispose() {
            if ( metadata != null )
                metadata.dispose();
            if ( index != null )
                index.dispose();
        }

    } // end of inner class ColumnEntry

} // end of class Table


text:
Tennis Star Caroline Wozniacki Shows Off Her Latest "SI" Swimsuit Issue Photos
"Tennis in bathing suits... Who's in?!"
By Best Life Editors February 15, 2017
By Best Life Editors
First it was Christie Brinkley. Then it was Kate Upton. Today, the latest globally famous beauty to alert Instagram to her presence in the new Sport's Illustrated swimsuit issue is Caroline Wozniacki, the 26 year-old Danish professional tennis player and one-time fiance to professional golfer, Rory McIlroy. As she notes in one of her posts, it's her third-straight appearance in the issue, and she's joined by a host of famous athletes who are moonlighting as swimsuit models. (Others include gymnast Aly Raisman and fellow tennis stars Serena Williams and Genie Bouchard.)
The announcement caps a pretty big week for the 20th-ranked player in the world. On Valentine's Day, she all but confirmed rumors that she's dating veteran NBA player and current San Antonio Spur, David Lee, when she published an Instagram story in which she tagged his handle and wrote, "I'm a lucky girl."
As tennis fans know all too well, Wozniacki has faced some injury problems in recent years. But as her posts reveal, she's looking in top form:
Tennis in bathing suits… Who's in?! 😎☀🎾 @si_swimsuit #SISwim
A post shared by Caroline Wozniacki (@carowozniacki) on Feb 15, 2017 at 9:00am PST
The new @si_swimsuit is on the stands today!!! So excited and honored to be included in the issue for the third straight year! Thank you @mj_day for believing in me and for making every shoot memorable and for making me part of the #SISwim family!!! Love you!!! 😘😘 📸 @emmanuelle.hauguel
For amazing advice for living smarter, looking better, feeling younger, and playing harder, sign up for our newsletter—delivered every day!
Fashion • News
10 Things You Didn't Know about Justin Trudeau
Athlete, nerd, hopeless romantic, thespian. Yes, there's a lot more to Canada's Prime Minister than just politics.
Where Did the Name "March Madness" Come From?
The real story behind the NCAA basketball tournament's bankable nickname.
Christie Brinkley's Triumphant Return to the Beach
And, yes, it's something to behold.
Jon Hamm: The Best Life Interview
Jon Hamm, star of TV's Mad Men, reveals the secrets of manliness in a postmodern world.
Driving Tips Smart Men Know
Ten easy ways to be the safest driver on the road.
Men Who Set the Time: Colin Hanks
Men Who Set the Time: Cash Warren
The successful producer, entrepreneur and husband of Jessica Alba reveals how you, too, can live your best life.
Dr. Oz: The Best Life Interview
Mehmet Oz, M.D., asks the toughest question: Are you living or dying?


Jollof rice takes on different forms and flavours across the continent. Each country claims to have the best and that's part of the reason Black Foodie and Supafrik have partnered to host an event that celebrates this friendly rivalry- Jollof Wars. A Food tasting/ party that will settle the score once and for all. If you're interested in tasting and adding your 2 cents- be sure to get a ticket!
But what is the difference in recipes and presentation across the continent. Check out these recipe videos to see!


text:
Rodrigues Gomes
Mention Winner on OpenGap Competition's platform
. a floating cube.
Urusla is one of six cubes that composed an old ancient city that submersed a long time ago. This lonely cube was found by a group of emerging artists that decided to give a new life to this abandoned place.
Since the beginning, it was clear that its structure should be kept like it was found. Therefore, all of its pillars were maintained and the interiors were thought as an attachment to its original shape. Being an immense apparent concrete construction, the architectural body seemed a long-term shelter, not only for the artists, but also for the art itself.
Divided in five floors the building shows that each level houses a different program. On a first approach the silence room shows up like an extension of the grand lobby, welcoming the visitor and inviting everyone to continue their journey. After this first moment, the group rooms seems like an open space that connects with the interior patio, which is also the core of the project creating a connection
between all floors, being the source of a faded light to the previous silence room.
The library was designed as an intermediate space between the public program and the residential studios. These last ones were thought as a transparent glass structure, with long white curtains that would softener its transparency. It was thought as a versatile structure that would suite every type of artists. Therefore, a central box -with the program of the kitchen and the bathroom- divides the entrance/private library and the living room. The bedroom it's a simple intermediate platform that floats through the space.
Being transparent the studios are permanently contacting with the outside landscape: a rocky island in the middle of the ocean, whose atmosphere its foggy and enigmatic.
The gallery -on the top of the building- finishes the program of this hostel being an open space that is closed to the outside landscape, opening to the patio and to the sky.
Portugal - no specific location
Project Facts
Program Inspiration Hostel
Publications http://www.opengap.net/index.php?p=ficha_concurso_cerrado&id=599
Ideas for Hospitality
Il Quadrato - Homage to Bruno Munari
Isometric. Oblique Drawing


text:
How should Christians think about race and racism? How do we define such issues biblically? Over the next four weeks, Nathan and Gus will attempt to provide some biblical guidance on these complex and often uncomfortable questions.
This is the third of four episodes.
This is the second of four episodes.
001.Starting a Discussion on Race (1 of 4)
How should Christians think about race and racism? How do we define such issues biblically? Over the next four weeks, Nathan and Gus will attempt to provide some biblical guidance on these complex and often uncomfortable questions. Here is the first of four...


Mobile devices allow employees to access information resources wherever they are, whenever they need. The constant Internet access available through a mobile device's cellular and Wi-Fi connections has the potential to make business practices more efficient and effective. As mobile technologies mature, employees increasingly want to use mobile devices to access corporate enterprise services, data, and other resources to perform work-related activities. Unfortunately, security controls have not kept pace with the security risks that mobile devices can pose.
If sensitive data is stored on a poorly secured mobile device that is lost or stolen, an attacker may be able to gain unauthorized access to that data. Even worse, a mobile device with remote access to sensitive organizational data could be leveraged by an attacker to gain access to not only that data, but also any other data that the user is allowed to access from that mobile device. The challenge lies in ensuring the confidentiality, integrity, and availability of the information that a mobile device accesses, stores, and processes. Despite the security risks posed by today's mobile devices, enterprises are under pressure to accept them due to several factors, such as anticipated cost savings and employees' demand for more convenience.
The NIST Cybersecurity Practice Guide, Mobile Device Security: Cloud and Hybrid Builds, demonstrates how commercially available technologies can meet your organization's needs to secure sensitive enterprise data accessed by and/or stored on employees' mobile devices.
In our lab at the National Cybersecurity Center of Excellence (NCCoE), we built an environment based on typical mobile devices and an enterprise email, calendaring, and contact management solution.
handle the de-provisioning of a mobile device that should no longer have enterprise access (e.g., device lost or stolen, employee leaves the company.
This document proposes a reference design on how to architect enterprise-class protection for mobile devices accessing an organization's resources. The example solutions presented here can be used by any organization implementing an enterprise mobility management solution. This project contains two distinct builds: cloud and hybrid. The cloud build uses cloud-based services and solutions, while the hybrid build achieves the same functionality, but hosts at least some of the data and services within an enterprise's own infrastructure. The example solutions and architectures presented here are based on open standards and commercially available products.


When performing a Geocode request from Resource Manager using Geoserver 3.1.0 the user only had to enter the postcode, or part of the postcode, and the user was returned with a list of possible addresses from which they could select one. Using Geoserver 3.6.1, the user needs to enter the full postcode and house number, name or business name in order to have a single address returned to them. QAS is recommended to customers who require to do address validation as part of the geocoding process and this is now not possible using the latest version.


Quick, sturdy and agile, the Jumping Sumo transforms your environment into a giant playground. With it, everything becomes an excuse for stories and adventures. Chases, slaloms, acrobatics, obstacle jumps, photos or videos – you've got plenty of choices! What's more, with its on-board camera, you can follow it as if you were there. Experience the amazing sensations in real time!
No FAA registration required ; Jumps up to 2.5 feet high and always falls back on its wheels.
The free FreeFlight Jumping app offers an intuitive control from your smartphone or tablet through Wi-Fi.
Swipe for perfect turns and hit predefined buttons for acrobatics like spins or jumps; Equipped with a wide angle camera that streams live immersive views on the piloting screen.