jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject [22/42] jena git commit: Merge commit 'refs/pull/143/head' of github.com:apache/jena
Date Sat, 14 May 2016 14:03:21 GMT
http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/main/java/org/apache/jena/propertytable/impl/ColumnImpl.java
----------------------------------------------------------------------
diff --cc jena-csv/src/main/java/org/apache/jena/propertytable/impl/ColumnImpl.java
index 808441a,808441a..ce456f9
--- a/jena-csv/src/main/java/org/apache/jena/propertytable/impl/ColumnImpl.java
+++ b/jena-csv/src/main/java/org/apache/jena/propertytable/impl/ColumnImpl.java
@@@ -1,57 -1,57 +1,57 @@@
--/*
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package org.apache.jena.propertytable.impl;
--
--
--import java.util.List;
--
--import org.apache.jena.graph.Node ;
--import org.apache.jena.propertytable.Column;
--import org.apache.jena.propertytable.PropertyTable;
--
--/**
-- * The simple implementation of Column
-- *
-- */
--public class ColumnImpl implements Column {
--	
--	
--	private final PropertyTable table;
--	private Node p;
--
--	ColumnImpl(PropertyTable table, Node p) {
--		this.table = table;
--		this.p = p;
--	}
--
--	@Override
--	public PropertyTable getTable() {
--		return table;
--	}
--
--	@Override
--	public Node getColumnKey() {
--		return p;
--	}
--
--	@Override
--	public List<Node> getValues() {
--		return table.getColumnValues(this);
--	}
--}
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package org.apache.jena.propertytable.impl;
++
++
++import java.util.List;
++
++import org.apache.jena.graph.Node ;
++import org.apache.jena.propertytable.Column;
++import org.apache.jena.propertytable.PropertyTable;
++
++/**
++ * The simple implementation of Column
++ *
++ */
++public class ColumnImpl implements Column {
++	
++	
++	private final PropertyTable table;
++	private Node p;
++
++	ColumnImpl(PropertyTable table, Node p) {
++		this.table = table;
++		this.p = p;
++	}
++
++	@Override
++	public PropertyTable getTable() {
++		return table;
++	}
++
++	@Override
++	public Node getColumnKey() {
++		return p;
++	}
++
++	@Override
++	public List<Node> getValues() {
++		return table.getColumnValues(this);
++	}
++}

http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableArrayImpl.java
----------------------------------------------------------------------
diff --cc jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableArrayImpl.java
index 6b8bd6e,6b8bd6e..1920045
--- a/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableArrayImpl.java
+++ b/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableArrayImpl.java
@@@ -1,345 -1,345 +1,345 @@@
--/*
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package org.apache.jena.propertytable.impl;
--
--import java.util.ArrayList;
--import java.util.Collection;
--import java.util.HashMap;
--import java.util.List;
--import java.util.Map;
--
--import org.apache.jena.atlas.iterator.Iter;
--import org.apache.jena.atlas.iterator.IteratorConcat;
--import org.apache.jena.graph.Node ;
--import org.apache.jena.graph.Triple ;
--import org.apache.jena.propertytable.Column;
--import org.apache.jena.propertytable.PropertyTable;
--import org.apache.jena.propertytable.Row;
--import org.apache.jena.util.iterator.ExtendedIterator ;
--import org.apache.jena.util.iterator.WrappedIterator ;
--
--/**
-- * A PropertyTable Implementation using a two dimension array.
-- * It contains SPO and PSO indexes.
-- * 
-- */
--public class PropertyTableArrayImpl implements PropertyTable {
--	
--	private final List<Node> rowList;
--	private final List<Node> columnList;
--
--	private final Map<Node, Integer> rowKeyToIndex;
--	private final Map<Node, Integer> columnKeyToIndex;
--	private final Node[][] array;
--	private final int rowNum;
--	private final int columnNum;
--	
--	public PropertyTableArrayImpl(int rowNum, int columnNum){
--		rowList = new ArrayList<Node>(rowNum);
--		columnList = new ArrayList<Node>(columnNum);
--		rowKeyToIndex = new HashMap<Node, Integer>();
--		columnKeyToIndex = new HashMap<Node, Integer>();
--		this.rowNum = rowNum;
--		this.columnNum = columnNum;
--		array = new Node [rowNum][columnNum];
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Column column, Node value) {
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		if (value == null){
--			throw new NullPointerException("value is null");
--		}
--		
--		ArrayList<Triple> triples = new ArrayList<Triple>();
--		
--		Node p = column.getColumnKey();
--		Integer columnIndex = this.columnKeyToIndex.get(p);
--		if (columnIndex != null){
--			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
--				if ( value.equals( this.get(rowIndex, columnIndex))){
--					triples.add(Triple.create(rowList.get(rowIndex), p, value));
--				}
--			}
--		}
--		return WrappedIterator.create(triples.iterator());
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Column column) {
--		
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		ArrayList<Triple> triples = new ArrayList<Triple>();
--		
--		Node p = column.getColumnKey();
--		Integer columnIndex = this.columnKeyToIndex.get(p);
--		if (columnIndex != null){
--			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
--				if(this.get(rowIndex, columnIndex)!=null){
--					triples.add(Triple.create(rowList.get(rowIndex), p, this.get(rowIndex, columnIndex)));
--				}
--			}
--		}
--		return WrappedIterator.create(triples.iterator());
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Node value) {
--		if (value == null)
--			throw new NullPointerException("value is null");
--		
--		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
--		for (Column column : this.getColumns()) {
--			ExtendedIterator<Triple> eIter = getTripleIterator(column,value);
--			iter.add(eIter);
--		}
--		return WrappedIterator.create(Iter.distinct(iter));
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Row row) {
--		if (row == null || row.getRowKey() == null)
--			throw new NullPointerException("row is null");
--		
--		ArrayList<Triple> triples = new ArrayList<Triple>();
--	    Integer rowIndex = this.rowKeyToIndex.get(row.getRowKey());
--
--		if (rowIndex != null){
--			for(int columnIndex=0; columnIndex < columnList.size(); columnIndex++){
--				triples.add(Triple.create( row.getRowKey(), columnList.get(columnIndex), this.get(rowIndex, columnIndex)));
--			}
--		}
--		return WrappedIterator.create(triples.iterator());
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator() {
--
--		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
--		for (Column column : getColumns()) {
--			iter.add(getTripleIterator(column));
--		}
--		return WrappedIterator.create(Iter.distinct(iter));
--	}
--
--	@Override
--	public Collection<Column> getColumns() {
--		Collection<Column> columns = new ArrayList<Column>();
--		for(Node p: columnKeyToIndex.keySet() ){
--			columns.add(new ColumnImpl(this, p));
--		}
--		return columns;
--	}
--
--	@Override
--	public Column getColumn(Node p) {
--		if (p == null)
--			throw new NullPointerException("column name is null");
--	    Integer columnIndex = columnKeyToIndex.get(p);
--	    return (columnIndex == null)
--	        ? null : new ColumnImpl(this, p);
--	}
--
--	@Override
--	public Column createColumn(Node p) {
--		if (p == null)
--			throw new NullPointerException("column name is null");
--
--		if (columnKeyToIndex.containsKey(p))
--			throw new IllegalArgumentException("column already exists: '"
--					+ p.toString());
--		
--		if (columnList.size()>= columnNum)
--			throw new IllegalArgumentException("cannot create new column for max column count: " + columnNum);
--		
--		columnList.add(p);
--		columnKeyToIndex.put(p, columnList.indexOf(p));
--		return getColumn(p);
--	}
--
--	@Override
--	public Row getRow(Node s) {
--		if (s == null)
--			throw new NullPointerException("subject node is null");
--		
--		Integer rowIndex = rowKeyToIndex.get(s);
--		return (rowIndex == null) ? null : new InternalRow(rowIndex);
--	}
--
--	@Override
--	public Row createRow(Node s) {
--		Row row = this.getRow(s);
--		if (row != null)
--			return row;
--
--		if (rowList.size()>= rowNum)
--			throw new IllegalArgumentException("cannot create new row for max row count: " + rowNum);
--		
--		rowList.add(s);
--		int rowIndex = rowList.indexOf(s);
--		rowKeyToIndex.put(s, rowIndex);		
--		
--		return new InternalRow(rowIndex);
--	}
--	
--	private void set(int rowIndex, int columnIndex, Node value) {
--		
--		if (rowIndex >= rowList.size())
--			throw new IllegalArgumentException("row index out of bound: " + rowList.size());
--		if (columnIndex >= columnList.size())
--			throw new IllegalArgumentException("column index out of bound: " + columnList.size());
--		array[rowIndex][columnIndex] = value;
--	}
--	
--	public Node get(int rowIndex, int columnIndex) {
--	    if (rowIndex >= rowList.size())
--			throw new IllegalArgumentException("row index out of bound: " + rowList.size());
--		if (columnIndex >= columnList.size())
--			throw new IllegalArgumentException("column index out of bound: " + columnList.size());
--		return array[rowIndex][columnIndex];
--    }
--
--	@Override
--	public List<Row> getAllRows() {
--		ArrayList<Row> rows = new ArrayList<Row>();
--		for (int rowIndex=0;rowIndex<rowList.size();rowIndex++){
--			rows.add( new InternalRow(rowIndex));
--		}
--		return rows;
--	}
--
--	@Override
--	public List<Node> getColumnValues(Column column) {
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		Node p = column.getColumnKey();
--		Integer columnIndex = this.columnKeyToIndex.get(p);
--		
--		List<Node> list = new ArrayList<Node>();
--		
--		if (columnIndex != null){
--			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
--				if(this.get(rowIndex, columnIndex)!=null){
--					list.add(this.get(rowIndex, columnIndex));
--				}
--			}
--		}
--		return list;
--	}
--	
--
--	@Override
--	public Collection<Row> getMatchingRows(Column column, Node value) {
--		
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		if (value == null){
--			throw new NullPointerException("value is null");
--		}
--		
--		final ArrayList<Row> matchingRows = new ArrayList<Row>();
--		
--		Node p = column.getColumnKey();
--		Integer columnIndex = this.columnKeyToIndex.get(p);
--		if (columnIndex != null){
--			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
--				if ( value.equals( this.get(rowIndex, columnIndex))){
--					matchingRows.add( this.getRow( rowList.get(rowIndex) ));
--				}
--			}
--		}
--		return matchingRows;
--	}
--	
--	private final class InternalRow implements Row {
--
--	    final int rowIndex;
--
--	    InternalRow(int rowIndex) {
--	      this.rowIndex = rowIndex;
--	    }
--		
--		@Override
--		public PropertyTable getTable() {
--			return PropertyTableArrayImpl.this;
--		}
--
--		@Override
--		public void setValue(Column column, Node value) {
--			if (column == null || column.getColumnKey() == null)
--				throw new NullPointerException("column is null");
--			
--		    Integer columnIndex = columnKeyToIndex.get(column.getColumnKey());
--		    if (columnIndex == null)
--		    	throw new IllegalArgumentException("column index does not exist: " + column.getColumnKey());
--
--		    set(rowIndex, columnIndex, value);
--			
--		}
--
--		@Override
--		public Node getValue(Column column) {
--			if (column == null)
--				throw new NullPointerException("column is null");
--			return this.getValue(column.getColumnKey());
--		}
--
--		@Override
--		public Node getValue(Node columnKey) {
--			if (columnKey == null)
--				throw new NullPointerException("column key is null");
--			
--		    Integer columnIndex = columnKeyToIndex.get(columnKey);
--		    if (columnIndex == null)
--		    	throw new IllegalArgumentException("column index does not exist: " + columnKey);
--		    
--		    return get(rowIndex, columnIndex);
--		}
--
--		@Override
--		public Node getRowKey() {
--			return rowList.get(rowIndex);
--		}
--
--		@Override
--		public ExtendedIterator<Triple> getTripleIterator() {
--			ArrayList<Triple> triples = new ArrayList<Triple>();
--			for (int columnIndex=0;columnIndex<columnList.size();columnIndex++) {
--				triples.add(Triple.create(getRowKey(), columnList.get(columnIndex), get(rowIndex, columnIndex)));
--			}
--			return WrappedIterator.create(triples.iterator());
--		}
--
--		@Override
--		public Collection<Column> getColumns() {
--			return PropertyTableArrayImpl.this.getColumns();
--		}
--		
--	}
--
--
--
--
--}
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package org.apache.jena.propertytable.impl;
++
++import java.util.ArrayList;
++import java.util.Collection;
++import java.util.HashMap;
++import java.util.List;
++import java.util.Map;
++
++import org.apache.jena.atlas.iterator.Iter;
++import org.apache.jena.atlas.iterator.IteratorConcat;
++import org.apache.jena.graph.Node ;
++import org.apache.jena.graph.Triple ;
++import org.apache.jena.propertytable.Column;
++import org.apache.jena.propertytable.PropertyTable;
++import org.apache.jena.propertytable.Row;
++import org.apache.jena.util.iterator.ExtendedIterator ;
++import org.apache.jena.util.iterator.WrappedIterator ;
++
++/**
++ * A PropertyTable Implementation using a two dimension array.
++ * It contains SPO and PSO indexes.
++ * 
++ */
++public class PropertyTableArrayImpl implements PropertyTable {
++	
++	private final List<Node> rowList;
++	private final List<Node> columnList;
++
++	private final Map<Node, Integer> rowKeyToIndex;
++	private final Map<Node, Integer> columnKeyToIndex;
++	private final Node[][] array;
++	private final int rowNum;
++	private final int columnNum;
++	
++	public PropertyTableArrayImpl(int rowNum, int columnNum){
++		rowList = new ArrayList<Node>(rowNum);
++		columnList = new ArrayList<Node>(columnNum);
++		rowKeyToIndex = new HashMap<Node, Integer>();
++		columnKeyToIndex = new HashMap<Node, Integer>();
++		this.rowNum = rowNum;
++		this.columnNum = columnNum;
++		array = new Node [rowNum][columnNum];
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Column column, Node value) {
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		if (value == null){
++			throw new NullPointerException("value is null");
++		}
++		
++		ArrayList<Triple> triples = new ArrayList<Triple>();
++		
++		Node p = column.getColumnKey();
++		Integer columnIndex = this.columnKeyToIndex.get(p);
++		if (columnIndex != null){
++			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
++				if ( value.equals( this.get(rowIndex, columnIndex))){
++					triples.add(Triple.create(rowList.get(rowIndex), p, value));
++				}
++			}
++		}
++		return WrappedIterator.create(triples.iterator());
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Column column) {
++		
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		ArrayList<Triple> triples = new ArrayList<Triple>();
++		
++		Node p = column.getColumnKey();
++		Integer columnIndex = this.columnKeyToIndex.get(p);
++		if (columnIndex != null){
++			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
++				if(this.get(rowIndex, columnIndex)!=null){
++					triples.add(Triple.create(rowList.get(rowIndex), p, this.get(rowIndex, columnIndex)));
++				}
++			}
++		}
++		return WrappedIterator.create(triples.iterator());
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Node value) {
++		if (value == null)
++			throw new NullPointerException("value is null");
++		
++		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
++		for (Column column : this.getColumns()) {
++			ExtendedIterator<Triple> eIter = getTripleIterator(column,value);
++			iter.add(eIter);
++		}
++		return WrappedIterator.create(Iter.distinct(iter));
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Row row) {
++		if (row == null || row.getRowKey() == null)
++			throw new NullPointerException("row is null");
++		
++		ArrayList<Triple> triples = new ArrayList<Triple>();
++	    Integer rowIndex = this.rowKeyToIndex.get(row.getRowKey());
++
++		if (rowIndex != null){
++			for(int columnIndex=0; columnIndex < columnList.size(); columnIndex++){
++				triples.add(Triple.create( row.getRowKey(), columnList.get(columnIndex), this.get(rowIndex, columnIndex)));
++			}
++		}
++		return WrappedIterator.create(triples.iterator());
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator() {
++
++		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
++		for (Column column : getColumns()) {
++			iter.add(getTripleIterator(column));
++		}
++		return WrappedIterator.create(Iter.distinct(iter));
++	}
++
++	@Override
++	public Collection<Column> getColumns() {
++		Collection<Column> columns = new ArrayList<Column>();
++		for(Node p: columnKeyToIndex.keySet() ){
++			columns.add(new ColumnImpl(this, p));
++		}
++		return columns;
++	}
++
++	@Override
++	public Column getColumn(Node p) {
++		if (p == null)
++			throw new NullPointerException("column name is null");
++	    Integer columnIndex = columnKeyToIndex.get(p);
++	    return (columnIndex == null)
++	        ? null : new ColumnImpl(this, p);
++	}
++
++	@Override
++	public Column createColumn(Node p) {
++		if (p == null)
++			throw new NullPointerException("column name is null");
++
++		if (columnKeyToIndex.containsKey(p))
++			throw new IllegalArgumentException("column already exists: '"
++					+ p.toString());
++		
++		if (columnList.size()>= columnNum)
++			throw new IllegalArgumentException("cannot create new column for max column count: " + columnNum);
++		
++		columnList.add(p);
++		columnKeyToIndex.put(p, columnList.indexOf(p));
++		return getColumn(p);
++	}
++
++	@Override
++	public Row getRow(Node s) {
++		if (s == null)
++			throw new NullPointerException("subject node is null");
++		
++		Integer rowIndex = rowKeyToIndex.get(s);
++		return (rowIndex == null) ? null : new InternalRow(rowIndex);
++	}
++
++	@Override
++	public Row createRow(Node s) {
++		Row row = this.getRow(s);
++		if (row != null)
++			return row;
++
++		if (rowList.size()>= rowNum)
++			throw new IllegalArgumentException("cannot create new row for max row count: " + rowNum);
++		
++		rowList.add(s);
++		int rowIndex = rowList.indexOf(s);
++		rowKeyToIndex.put(s, rowIndex);		
++		
++		return new InternalRow(rowIndex);
++	}
++	
++	private void set(int rowIndex, int columnIndex, Node value) {
++		
++		if (rowIndex >= rowList.size())
++			throw new IllegalArgumentException("row index out of bound: " + rowList.size());
++		if (columnIndex >= columnList.size())
++			throw new IllegalArgumentException("column index out of bound: " + columnList.size());
++		array[rowIndex][columnIndex] = value;
++	}
++	
++	public Node get(int rowIndex, int columnIndex) {
++	    if (rowIndex >= rowList.size())
++			throw new IllegalArgumentException("row index out of bound: " + rowList.size());
++		if (columnIndex >= columnList.size())
++			throw new IllegalArgumentException("column index out of bound: " + columnList.size());
++		return array[rowIndex][columnIndex];
++    }
++
++	@Override
++	public List<Row> getAllRows() {
++		ArrayList<Row> rows = new ArrayList<Row>();
++		for (int rowIndex=0;rowIndex<rowList.size();rowIndex++){
++			rows.add( new InternalRow(rowIndex));
++		}
++		return rows;
++	}
++
++	@Override
++	public List<Node> getColumnValues(Column column) {
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		Node p = column.getColumnKey();
++		Integer columnIndex = this.columnKeyToIndex.get(p);
++		
++		List<Node> list = new ArrayList<Node>();
++		
++		if (columnIndex != null){
++			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
++				if(this.get(rowIndex, columnIndex)!=null){
++					list.add(this.get(rowIndex, columnIndex));
++				}
++			}
++		}
++		return list;
++	}
++	
++
++	@Override
++	public Collection<Row> getMatchingRows(Column column, Node value) {
++		
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		if (value == null){
++			throw new NullPointerException("value is null");
++		}
++		
++		final ArrayList<Row> matchingRows = new ArrayList<Row>();
++		
++		Node p = column.getColumnKey();
++		Integer columnIndex = this.columnKeyToIndex.get(p);
++		if (columnIndex != null){
++			for(int rowIndex=0; rowIndex< rowList.size();rowIndex++){
++				if ( value.equals( this.get(rowIndex, columnIndex))){
++					matchingRows.add( this.getRow( rowList.get(rowIndex) ));
++				}
++			}
++		}
++		return matchingRows;
++	}
++	
++	private final class InternalRow implements Row {
++
++	    final int rowIndex;
++
++	    InternalRow(int rowIndex) {
++	      this.rowIndex = rowIndex;
++	    }
++		
++		@Override
++		public PropertyTable getTable() {
++			return PropertyTableArrayImpl.this;
++		}
++
++		@Override
++		public void setValue(Column column, Node value) {
++			if (column == null || column.getColumnKey() == null)
++				throw new NullPointerException("column is null");
++			
++		    Integer columnIndex = columnKeyToIndex.get(column.getColumnKey());
++		    if (columnIndex == null)
++		    	throw new IllegalArgumentException("column index does not exist: " + column.getColumnKey());
++
++		    set(rowIndex, columnIndex, value);
++			
++		}
++
++		@Override
++		public Node getValue(Column column) {
++			if (column == null)
++				throw new NullPointerException("column is null");
++			return this.getValue(column.getColumnKey());
++		}
++
++		@Override
++		public Node getValue(Node columnKey) {
++			if (columnKey == null)
++				throw new NullPointerException("column key is null");
++			
++		    Integer columnIndex = columnKeyToIndex.get(columnKey);
++		    if (columnIndex == null)
++		    	throw new IllegalArgumentException("column index does not exist: " + columnKey);
++		    
++		    return get(rowIndex, columnIndex);
++		}
++
++		@Override
++		public Node getRowKey() {
++			return rowList.get(rowIndex);
++		}
++
++		@Override
++		public ExtendedIterator<Triple> getTripleIterator() {
++			ArrayList<Triple> triples = new ArrayList<Triple>();
++			for (int columnIndex=0;columnIndex<columnList.size();columnIndex++) {
++				triples.add(Triple.create(getRowKey(), columnList.get(columnIndex), get(rowIndex, columnIndex)));
++			}
++			return WrappedIterator.create(triples.iterator());
++		}
++
++		@Override
++		public Collection<Column> getColumns() {
++			return PropertyTableArrayImpl.this.getColumns();
++		}
++		
++	}
++
++
++
++
++}

http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableBuilder.java
----------------------------------------------------------------------
diff --cc jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableBuilder.java
index 0532dc9,0532dc9..a0c5af1
--- a/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableBuilder.java
+++ b/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableBuilder.java
@@@ -1,135 -1,135 +1,135 @@@
--/*
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package org.apache.jena.propertytable.impl;
--
--import java.io.InputStream ;
--import java.util.ArrayList ;
--import java.util.Iterator ;
--import java.util.List ;
--
--import org.apache.jena.atlas.csv.CSVParser ;
--import org.apache.jena.atlas.io.IO ;
--import org.apache.jena.datatypes.xsd.XSDDatatype ;
--import org.apache.jena.graph.Node ;
--import org.apache.jena.graph.NodeFactory ;
--import org.apache.jena.propertytable.PropertyTable ;
--import org.apache.jena.propertytable.Row ;
--import org.apache.jena.propertytable.lang.LangCSV ;
--import org.apache.jena.riot.system.IRIResolver ;
--
--
--/**
-- * A tool for constructing PropertyTable from a file (e.g., a CSV file).
-- * 
-- *
-- */
--public class PropertyTableBuilder {
--	
--	public static Node CSV_ROW_NODE = NodeFactory.createURI(LangCSV.CSV_ROW);
--	
--	public static PropertyTable buildPropetyTableHashMapImplFromCsv(String csvFilePath) {		
--		PropertyTable table = new PropertyTableHashMapImpl();
--		return fillPropertyTable(table, csvFilePath);
--	}
--	
--	public static PropertyTable buildPropetyTableArrayImplFromCsv(String csvFilePath) {
--		PropertyTable table = createEmptyPropertyTableArrayImpl(csvFilePath);
--		return fillPropertyTable(table, csvFilePath);
--	}
--	
--	private static PropertyTable createEmptyPropertyTableArrayImpl (String csvFilePath) {
--		CSVParser parser = CSVParser.create(csvFilePath);
--		List<String> rowLine = null;
--		int rowNum = 0;
--		int columnNum = 0;
--		
--		while ((rowLine = parser.parse1()) != null) {
--			if (rowNum == 0) {
--				columnNum = rowLine.size();
--			}
--			rowNum++;
--		}
--		if (rowNum!=0 && columnNum!=0){
--			return new PropertyTableArrayImpl(rowNum, columnNum+1);
--		} else {
--			return null;
--		}
--	}
--
--	protected static PropertyTable fillPropertyTable(PropertyTable table, String csvFilePath ){
--		InputStream input = IO.openFile(csvFilePath) ;
--		CSVParser iterator = CSVParser.create(input) ;
--		return fillPropertyTable(table, iterator, csvFilePath);
--	}
--	
--	protected static PropertyTable fillPropertyTable(PropertyTable table, CSVParser parser, String csvFilePath){
--		if (table == null){
--			return null;
--		}
--		ArrayList<Node> predicates = new ArrayList<Node>();
--		int rowNum = 0;
--		
--		Iterator<List<String>> iter = parser.iterator() ;
--		if ( ! iter.hasNext() )
--		    return table ;
--		List<String> row1 = iter.next() ;
--		table.createColumn(CSV_ROW_NODE);
--        for (String column : row1) {
--            String uri = createColumnKeyURI(csvFilePath, column);
--            Node p = NodeFactory.createURI(uri);
--            predicates.add(p);
--            table.createColumn(p);
--        }
--        
--        rowNum++ ;
--        while(iter.hasNext()) {
--            List<String> rowLine = iter.next();
--            Node subject = LangCSV.caculateSubject(rowNum, csvFilePath);
--            Row row = table.createRow(subject);
--
--            row.setValue(table.getColumn(CSV_ROW_NODE), 
--                         NodeFactory.createLiteral((rowNum + ""), XSDDatatype.XSDinteger));
--
--            for (int col = 0; col < rowLine.size() && col<predicates.size(); col++) {
--
--                String columnValue = rowLine.get(col).trim();
--                if("".equals(columnValue)){
--                    continue;
--                }
--                Node o;
--                try {
--                    // Try for a double.
--                    double d = Double.parseDouble(columnValue);
--                    o = NodeFactory.createLiteral(columnValue,
--                                                  XSDDatatype.XSDdouble);
--                } catch (Exception e) {
--                    o = NodeFactory.createLiteral(columnValue);
--                }
--                row.setValue(table.getColumn(predicates.get(col)), o);
--            }
--            rowNum++ ;
--        }
--        return table;
--	}
--	
--	protected static String createColumnKeyURI(String csvFilePath, String column){
--		String uri = IRIResolver.resolveString(csvFilePath) + "#" + LangCSV.toSafeLocalname(column);
--		return uri;
--	}
--}
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package org.apache.jena.propertytable.impl;
++
++import java.io.InputStream ;
++import java.util.ArrayList ;
++import java.util.Iterator ;
++import java.util.List ;
++
++import org.apache.jena.atlas.csv.CSVParser ;
++import org.apache.jena.atlas.io.IO ;
++import org.apache.jena.datatypes.xsd.XSDDatatype ;
++import org.apache.jena.graph.Node ;
++import org.apache.jena.graph.NodeFactory ;
++import org.apache.jena.propertytable.PropertyTable ;
++import org.apache.jena.propertytable.Row ;
++import org.apache.jena.propertytable.lang.LangCSV ;
++import org.apache.jena.riot.system.IRIResolver ;
++
++
++/**
++ * A tool for constructing PropertyTable from a file (e.g., a CSV file).
++ * 
++ *
++ */
++public class PropertyTableBuilder {
++	
++	public static Node CSV_ROW_NODE = NodeFactory.createURI(LangCSV.CSV_ROW);
++	
++	public static PropertyTable buildPropetyTableHashMapImplFromCsv(String csvFilePath) {		
++		PropertyTable table = new PropertyTableHashMapImpl();
++		return fillPropertyTable(table, csvFilePath);
++	}
++	
++	public static PropertyTable buildPropetyTableArrayImplFromCsv(String csvFilePath) {
++		PropertyTable table = createEmptyPropertyTableArrayImpl(csvFilePath);
++		return fillPropertyTable(table, csvFilePath);
++	}
++	
++	private static PropertyTable createEmptyPropertyTableArrayImpl (String csvFilePath) {
++		CSVParser parser = CSVParser.create(csvFilePath);
++		List<String> rowLine = null;
++		int rowNum = 0;
++		int columnNum = 0;
++		
++		while ((rowLine = parser.parse1()) != null) {
++			if (rowNum == 0) {
++				columnNum = rowLine.size();
++			}
++			rowNum++;
++		}
++		if (rowNum!=0 && columnNum!=0){
++			return new PropertyTableArrayImpl(rowNum, columnNum+1);
++		} else {
++			return null;
++		}
++	}
++
++	protected static PropertyTable fillPropertyTable(PropertyTable table, String csvFilePath ){
++		InputStream input = IO.openFile(csvFilePath) ;
++		CSVParser iterator = CSVParser.create(input) ;
++		return fillPropertyTable(table, iterator, csvFilePath);
++	}
++	
++	protected static PropertyTable fillPropertyTable(PropertyTable table, CSVParser parser, String csvFilePath){
++		if (table == null){
++			return null;
++		}
++		ArrayList<Node> predicates = new ArrayList<Node>();
++		int rowNum = 0;
++		
++		Iterator<List<String>> iter = parser.iterator() ;
++		if ( ! iter.hasNext() )
++		    return table ;
++		List<String> row1 = iter.next() ;
++		table.createColumn(CSV_ROW_NODE);
++        for (String column : row1) {
++            String uri = createColumnKeyURI(csvFilePath, column);
++            Node p = NodeFactory.createURI(uri);
++            predicates.add(p);
++            table.createColumn(p);
++        }
++        
++        rowNum++ ;
++        while(iter.hasNext()) {
++            List<String> rowLine = iter.next();
++            Node subject = LangCSV.caculateSubject(rowNum, csvFilePath);
++            Row row = table.createRow(subject);
++
++            row.setValue(table.getColumn(CSV_ROW_NODE), 
++                         NodeFactory.createLiteral((rowNum + ""), XSDDatatype.XSDinteger));
++
++            for (int col = 0; col < rowLine.size() && col<predicates.size(); col++) {
++
++                String columnValue = rowLine.get(col).trim();
++                if("".equals(columnValue)){
++                    continue;
++                }
++                Node o;
++                try {
++                    // Try for a double.
++                    double d = Double.parseDouble(columnValue);
++                    o = NodeFactory.createLiteral(columnValue,
++                                                  XSDDatatype.XSDdouble);
++                } catch (Exception e) {
++                    o = NodeFactory.createLiteral(columnValue);
++                }
++                row.setValue(table.getColumn(predicates.get(col)), o);
++            }
++            rowNum++ ;
++        }
++        return table;
++	}
++	
++	protected static String createColumnKeyURI(String csvFilePath, String column){
++		String uri = IRIResolver.resolveString(csvFilePath) + "#" + LangCSV.toSafeLocalname(column);
++		return uri;
++	}
++}

http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableHashMapImpl.java
----------------------------------------------------------------------
diff --cc jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableHashMapImpl.java
index 622b3f1,622b3f1..45ec40f
--- a/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableHashMapImpl.java
+++ b/jena-csv/src/main/java/org/apache/jena/propertytable/impl/PropertyTableHashMapImpl.java
@@@ -1,352 -1,352 +1,352 @@@
--/*
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package org.apache.jena.propertytable.impl;
--
--import java.util.* ;
--import java.util.Map.Entry;
--
--import org.apache.jena.atlas.iterator.Iter;
--import org.apache.jena.atlas.iterator.IteratorConcat;
--import org.apache.jena.ext.com.google.common.collect.HashMultimap;
--import org.apache.jena.ext.com.google.common.collect.SetMultimap ;
--import org.apache.jena.graph.Node ;
--import org.apache.jena.graph.Triple ;
--import org.apache.jena.propertytable.Column;
--import org.apache.jena.propertytable.PropertyTable;
--import org.apache.jena.propertytable.Row;
--import org.apache.jena.util.iterator.ExtendedIterator ;
--import org.apache.jena.util.iterator.NullIterator ;
--import org.apache.jena.util.iterator.WrappedIterator ;
--
--/**
-- * A PropertyTable Implementation using HashMap.
-- * It contains PSO and POS indexes.
-- * 
-- */
--public class PropertyTableHashMapImpl implements PropertyTable {
--
--	private Map<Node, Column> columnIndex; // Maps property Node key to Column
--	private List<Column> columnList; // Stores the list of columns in the table
--	private Map<Node, Row> rowIndex; // Maps the subject Node key to Row.
--	private List<Row> rowList; // Stores the list of rows in the table
--
--	// PSO index
--	// Maps column Node to (subject Node, value) pairs
--	private Map<Node, Map<Node, Node>> valueIndex; 
--	// POS index
--	// Maps column Node to (value, subject Node) pairs
--	private Map<Node, SetMultimap<Node, Node>> valueReverseIndex; 
--
--	PropertyTableHashMapImpl() {
--		columnIndex = new HashMap<Node, Column>();
--		columnList = new ArrayList<Column>();
--		rowIndex = new HashMap<Node, Row>();
--		rowList = new ArrayList<Row>();
--		valueIndex = new HashMap<Node, Map<Node, Node>>();
--		valueReverseIndex = new HashMap<Node, SetMultimap<Node, Node>>();
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator() {
--		
--		// use PSO index to scan all the table (slow)
--		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
--		for (Column column : getColumns()) {
--			iter.add(getTripleIterator(column));
--		}
--		return WrappedIterator.create(Iter.distinct(iter));
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Column column) {
--		
--		// use PSO index directly (fast)
--		
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		ArrayList<Triple> triples = new ArrayList<Triple>();
--		Map<Node, Node> values = valueIndex.get(column.getColumnKey());
--
--		for (Entry<Node, Node> entry : values.entrySet()) {
--			Node subject = entry.getKey();
--			Node value = entry.getValue();
--			triples.add(Triple.create(subject, column.getColumnKey(), value));
--		}
--		return WrappedIterator.create(triples.iterator());
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Node value) {
--		
--		// use POS index ( O(n), n= column count )
--		
--		if (value == null)
--			throw new NullPointerException("value is null");
--		
--		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
--		for (Column column : this.getColumns()) {
--			ExtendedIterator<Triple> eIter = getTripleIterator(column,value);
--			iter.add(eIter);
--		}
--		return WrappedIterator.create(Iter.distinct(iter));
--	}
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Column column, Node value) {
--		
--		// use POS index directly (fast)
--		
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		if (value == null)
--			throw new NullPointerException("value is null");
--		
--		
--		Node p = column.getColumnKey();
--		final SetMultimap<Node, Node> valueToSubjectMap = valueReverseIndex.get(p);
--		if ( valueToSubjectMap == null ) 
--		    return NullIterator.instance() ;
--		final Set<Node> subjects = valueToSubjectMap.get(value);
--		ArrayList<Triple> triples = new ArrayList<Triple>();
--		for (Node subject : subjects) {
--		    triples.add(Triple.create(subject, p, value));
--		}
--		return WrappedIterator.create(triples.iterator());
--	}
--
--
--	@Override
--	public ExtendedIterator<Triple> getTripleIterator(Row row) {
--		// use PSO index ( O(n), n= column count )
--		
--		if (row == null || row.getRowKey() == null)
--			throw new NullPointerException("row is null");
--		
--		ArrayList<Triple> triples = new ArrayList<Triple>();
--		for (Column column : getColumns()) {
--			Node value = row.getValue(column);
--			triples.add(Triple.create(row.getRowKey(), column.getColumnKey(), value));
--		}
--		return WrappedIterator.create(triples.iterator());
--	}
--
--	@Override
--	public Collection<Column> getColumns() {
--		return columnList;
--	}
--
--	@Override
--	public Column getColumn(Node p) {
--		if (p == null)
--			throw new NullPointerException("column node is null");
--		return columnIndex.get(p);
--	}
--
--	@Override
--	public Column createColumn(Node p) {
--		if (p == null)
--			throw new NullPointerException("column node is null");
--
--		if (columnIndex.containsKey(p))
--			throw new IllegalArgumentException("column already exists: '"
--					+ p.toString());
--
--		columnIndex.put(p, new ColumnImpl(this, p));
--		columnList.add(columnIndex.get(p));
--		valueIndex.put(p, new HashMap<Node, Node>());
--		valueReverseIndex.put(p, HashMultimap.create());
--		return getColumn(p);
--	}
--
--	@Override
--	public Row getRow(final Node s) {
--		if (s == null)
--			throw new NullPointerException("subject node is null");
--		Row row = rowIndex.get(s);
--		return row;
--
--	}
--	
--	@Override
--	public Row createRow(final Node s){
--		Row row = this.getRow(s);
--		if (row != null)
--			return row;
--
--		row = new InternalRow(s);
--		rowIndex.put(s, row);
--		rowList.add(row);
--
--		return row;
--	}
--	
--	@Override
--	public List<Row> getAllRows() {
--		return rowList;
--	}
--
--	
--	
--	@Override
--	public List<Node> getColumnValues(Column column) {
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		Map<Node, Node> values = valueIndex.get(column.getColumnKey());
--
--		List<Node> list = new ArrayList<Node>(values.size());
--		list.addAll(values.values());
--		return list;
--	}
--	
--	@Override
--	public Collection<Row> getMatchingRows(Column column, Node value) {
--		if (column == null || column.getColumnKey() == null)
--			throw new NullPointerException("column is null");
--		
--		if (value == null)
--			throw new NullPointerException("value is null");
--		
--		
--		Node p = column.getColumnKey();
--		final SetMultimap<Node, Node> valueToSubjectMap = valueReverseIndex.get(p);
--		if ( valueToSubjectMap == null )
--		    return Collections.emptyList() ;
--		final Set<Node> subjects = valueToSubjectMap.get(value);
--		if ( subjects == null )
--		    return Collections.emptyList() ;
--		final ArrayList<Row> matchingRows = new ArrayList<Row>();
--		for (Node subject : subjects) {
--		    matchingRows.add(this.getRow(subject));
--		}
--		return matchingRows;
--	}
--
--	private final void setX(final Node s, final Node p, final Node value) {
--		if (p == null)
--			throw new NullPointerException("column Node must not be null.");
--		if (value == null)
--			throw new NullPointerException("value must not be null.");
--
--		Map<Node, Node> subjectToValueMap = valueIndex.get(p);
--		if (!columnIndex.containsKey(p) || subjectToValueMap == null)
--			throw new IllegalArgumentException("column: '" + p
--					+ "' does not yet exist.");
--
--		Node oldValue = subjectToValueMap.get(s);
--		subjectToValueMap.put(s, value);
--		addToReverseMap(p, s, oldValue, value);
--	}
--
--	private void addToReverseMap(final Node p, final Node s, final Node oldValue, final Node value) {
--
--		final SetMultimap<Node, Node> valueToSubjectMap = valueReverseIndex.get(p);
--		if ( valueToSubjectMap == null )
--            return ; 
--		valueToSubjectMap.remove(oldValue, s);
--		valueToSubjectMap.put(value, s);
--	}
--
--	private void unSetX(final Node s, final Node p) {
--
--		final Map<Node, Node> subjectToValueMap = valueIndex.get(p);
--		if (!columnIndex.containsKey(p) || subjectToValueMap == null)
--			throw new IllegalArgumentException("column: '" + p
--					+ "' does not yet exist.");
--
--		final Node value = subjectToValueMap.get(s);
--		if (value == null)
--			return;
--
--		subjectToValueMap.remove(s);
--		removeFromReverseMap(p, s, value);
--	}
--
--	private void removeFromReverseMap(final Node p, final Node s,
--			final Node value) {
--		final SetMultimap<Node, Node> valueTokeysMap = valueReverseIndex.get(p);
--		if ( valueTokeysMap == null )
--		    return ;
--		valueTokeysMap.remove(s, value);
--	}
--
--	private Node getX(final Node s, final Node p) {
--		final Map<Node, Node> subjectToValueMap = valueIndex.get(p);
--		if (!columnIndex.containsKey(p) || subjectToValueMap == null)
--			throw new IllegalArgumentException("column: '" + p
--					+ "' does not yet exist.");
--		return subjectToValueMap.get(s);
--	}
--
--	private final class InternalRow implements Row {
--		private final Node key;
--
--		InternalRow(final Node key) {
--			this.key = key;
--		}
--
--		@Override
--		public void setValue(Column column, Node value) {
--			if (value == null)
--				unSetX(key, column.getColumnKey());
--			else
--				setX(key, column.getColumnKey(), value);
--		}
--
--		@Override
--		public Node getValue(Column column) {
--			return getX(key, column.getColumnKey());
--		}
--		
--		@Override
--		public Node getValue(Node columnKey) {
--			return getX(key, columnKey);
--		}
--
--		@Override
--		public PropertyTable getTable() {
--			return PropertyTableHashMapImpl.this;
--		}
--
--		@Override
--		public Node getRowKey() {
--			return key;
--		}
--
--		@Override
--		public Collection<Column> getColumns() {
--			// TODO Auto-generated method stub
--			return PropertyTableHashMapImpl.this.getColumns();
--		}
--
--		@Override
--		public ExtendedIterator<Triple> getTripleIterator() {
--			ArrayList<Triple> triples = new ArrayList<Triple>();
--			for (Column column : getColumns()) {
--				Node value = this.getValue(column);
--				triples.add(Triple.create(key, column.getColumnKey(), value));
--			}
--			return WrappedIterator.create(triples.iterator());
--		}
--
--	}
--
--}
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package org.apache.jena.propertytable.impl;
++
++import java.util.* ;
++import java.util.Map.Entry;
++
++import org.apache.jena.atlas.iterator.Iter;
++import org.apache.jena.atlas.iterator.IteratorConcat;
++import org.apache.jena.ext.com.google.common.collect.HashMultimap;
++import org.apache.jena.ext.com.google.common.collect.SetMultimap ;
++import org.apache.jena.graph.Node ;
++import org.apache.jena.graph.Triple ;
++import org.apache.jena.propertytable.Column;
++import org.apache.jena.propertytable.PropertyTable;
++import org.apache.jena.propertytable.Row;
++import org.apache.jena.util.iterator.ExtendedIterator ;
++import org.apache.jena.util.iterator.NullIterator ;
++import org.apache.jena.util.iterator.WrappedIterator ;
++
++/**
++ * A PropertyTable Implementation using HashMap.
++ * It contains PSO and POS indexes.
++ * 
++ */
++public class PropertyTableHashMapImpl implements PropertyTable {
++
++	private Map<Node, Column> columnIndex; // Maps property Node key to Column
++	private List<Column> columnList; // Stores the list of columns in the table
++	private Map<Node, Row> rowIndex; // Maps the subject Node key to Row.
++	private List<Row> rowList; // Stores the list of rows in the table
++
++	// PSO index
++	// Maps column Node to (subject Node, value) pairs
++	private Map<Node, Map<Node, Node>> valueIndex; 
++	// POS index
++	// Maps column Node to (value, subject Node) pairs
++	private Map<Node, SetMultimap<Node, Node>> valueReverseIndex; 
++
++	PropertyTableHashMapImpl() {
++		columnIndex = new HashMap<Node, Column>();
++		columnList = new ArrayList<Column>();
++		rowIndex = new HashMap<Node, Row>();
++		rowList = new ArrayList<Row>();
++		valueIndex = new HashMap<Node, Map<Node, Node>>();
++		valueReverseIndex = new HashMap<Node, SetMultimap<Node, Node>>();
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator() {
++		
++		// use PSO index to scan all the table (slow)
++		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
++		for (Column column : getColumns()) {
++			iter.add(getTripleIterator(column));
++		}
++		return WrappedIterator.create(Iter.distinct(iter));
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Column column) {
++		
++		// use PSO index directly (fast)
++		
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		ArrayList<Triple> triples = new ArrayList<Triple>();
++		Map<Node, Node> values = valueIndex.get(column.getColumnKey());
++
++		for (Entry<Node, Node> entry : values.entrySet()) {
++			Node subject = entry.getKey();
++			Node value = entry.getValue();
++			triples.add(Triple.create(subject, column.getColumnKey(), value));
++		}
++		return WrappedIterator.create(triples.iterator());
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Node value) {
++		
++		// use POS index ( O(n), n= column count )
++		
++		if (value == null)
++			throw new NullPointerException("value is null");
++		
++		IteratorConcat<Triple> iter = new IteratorConcat<Triple>();
++		for (Column column : this.getColumns()) {
++			ExtendedIterator<Triple> eIter = getTripleIterator(column,value);
++			iter.add(eIter);
++		}
++		return WrappedIterator.create(Iter.distinct(iter));
++	}
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Column column, Node value) {
++		
++		// use POS index directly (fast)
++		
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		if (value == null)
++			throw new NullPointerException("value is null");
++		
++		
++		Node p = column.getColumnKey();
++		final SetMultimap<Node, Node> valueToSubjectMap = valueReverseIndex.get(p);
++		if ( valueToSubjectMap == null ) 
++		    return NullIterator.instance() ;
++		final Set<Node> subjects = valueToSubjectMap.get(value);
++		ArrayList<Triple> triples = new ArrayList<Triple>();
++		for (Node subject : subjects) {
++		    triples.add(Triple.create(subject, p, value));
++		}
++		return WrappedIterator.create(triples.iterator());
++	}
++
++
++	@Override
++	public ExtendedIterator<Triple> getTripleIterator(Row row) {
++		// use PSO index ( O(n), n= column count )
++		
++		if (row == null || row.getRowKey() == null)
++			throw new NullPointerException("row is null");
++		
++		ArrayList<Triple> triples = new ArrayList<Triple>();
++		for (Column column : getColumns()) {
++			Node value = row.getValue(column);
++			triples.add(Triple.create(row.getRowKey(), column.getColumnKey(), value));
++		}
++		return WrappedIterator.create(triples.iterator());
++	}
++
++	@Override
++	public Collection<Column> getColumns() {
++		return columnList;
++	}
++
++	@Override
++	public Column getColumn(Node p) {
++		if (p == null)
++			throw new NullPointerException("column node is null");
++		return columnIndex.get(p);
++	}
++
++	@Override
++	public Column createColumn(Node p) {
++		if (p == null)
++			throw new NullPointerException("column node is null");
++
++		if (columnIndex.containsKey(p))
++			throw new IllegalArgumentException("column already exists: '"
++					+ p.toString());
++
++		columnIndex.put(p, new ColumnImpl(this, p));
++		columnList.add(columnIndex.get(p));
++		valueIndex.put(p, new HashMap<Node, Node>());
++		valueReverseIndex.put(p, HashMultimap.create());
++		return getColumn(p);
++	}
++
++	@Override
++	public Row getRow(final Node s) {
++		if (s == null)
++			throw new NullPointerException("subject node is null");
++		Row row = rowIndex.get(s);
++		return row;
++
++	}
++	
++	@Override
++	public Row createRow(final Node s){
++		Row row = this.getRow(s);
++		if (row != null)
++			return row;
++
++		row = new InternalRow(s);
++		rowIndex.put(s, row);
++		rowList.add(row);
++
++		return row;
++	}
++	
++	@Override
++	public List<Row> getAllRows() {
++		return rowList;
++	}
++
++	
++	
++	@Override
++	public List<Node> getColumnValues(Column column) {
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		Map<Node, Node> values = valueIndex.get(column.getColumnKey());
++
++		List<Node> list = new ArrayList<Node>(values.size());
++		list.addAll(values.values());
++		return list;
++	}
++	
++	@Override
++	public Collection<Row> getMatchingRows(Column column, Node value) {
++		if (column == null || column.getColumnKey() == null)
++			throw new NullPointerException("column is null");
++		
++		if (value == null)
++			throw new NullPointerException("value is null");
++		
++		
++		Node p = column.getColumnKey();
++		final SetMultimap<Node, Node> valueToSubjectMap = valueReverseIndex.get(p);
++		if ( valueToSubjectMap == null )
++		    return Collections.emptyList() ;
++		final Set<Node> subjects = valueToSubjectMap.get(value);
++		if ( subjects == null )
++		    return Collections.emptyList() ;
++		final ArrayList<Row> matchingRows = new ArrayList<Row>();
++		for (Node subject : subjects) {
++		    matchingRows.add(this.getRow(subject));
++		}
++		return matchingRows;
++	}
++
++	private final void setX(final Node s, final Node p, final Node value) {
++		if (p == null)
++			throw new NullPointerException("column Node must not be null.");
++		if (value == null)
++			throw new NullPointerException("value must not be null.");
++
++		Map<Node, Node> subjectToValueMap = valueIndex.get(p);
++		if (!columnIndex.containsKey(p) || subjectToValueMap == null)
++			throw new IllegalArgumentException("column: '" + p
++					+ "' does not yet exist.");
++
++		Node oldValue = subjectToValueMap.get(s);
++		subjectToValueMap.put(s, value);
++		addToReverseMap(p, s, oldValue, value);
++	}
++
++	private void addToReverseMap(final Node p, final Node s, final Node oldValue, final Node value) {
++
++		final SetMultimap<Node, Node> valueToSubjectMap = valueReverseIndex.get(p);
++		if ( valueToSubjectMap == null )
++            return ; 
++		valueToSubjectMap.remove(oldValue, s);
++		valueToSubjectMap.put(value, s);
++	}
++
++	private void unSetX(final Node s, final Node p) {
++
++		final Map<Node, Node> subjectToValueMap = valueIndex.get(p);
++		if (!columnIndex.containsKey(p) || subjectToValueMap == null)
++			throw new IllegalArgumentException("column: '" + p
++					+ "' does not yet exist.");
++
++		final Node value = subjectToValueMap.get(s);
++		if (value == null)
++			return;
++
++		subjectToValueMap.remove(s);
++		removeFromReverseMap(p, s, value);
++	}
++
++	private void removeFromReverseMap(final Node p, final Node s,
++			final Node value) {
++		final SetMultimap<Node, Node> valueTokeysMap = valueReverseIndex.get(p);
++		if ( valueTokeysMap == null )
++		    return ;
++		valueTokeysMap.remove(s, value);
++	}
++
++	private Node getX(final Node s, final Node p) {
++		final Map<Node, Node> subjectToValueMap = valueIndex.get(p);
++		if (!columnIndex.containsKey(p) || subjectToValueMap == null)
++			throw new IllegalArgumentException("column: '" + p
++					+ "' does not yet exist.");
++		return subjectToValueMap.get(s);
++	}
++
++	private final class InternalRow implements Row {
++		private final Node key;
++
++		InternalRow(final Node key) {
++			this.key = key;
++		}
++
++		@Override
++		public void setValue(Column column, Node value) {
++			if (value == null)
++				unSetX(key, column.getColumnKey());
++			else
++				setX(key, column.getColumnKey(), value);
++		}
++
++		@Override
++		public Node getValue(Column column) {
++			return getX(key, column.getColumnKey());
++		}
++		
++		@Override
++		public Node getValue(Node columnKey) {
++			return getX(key, columnKey);
++		}
++
++		@Override
++		public PropertyTable getTable() {
++			return PropertyTableHashMapImpl.this;
++		}
++
++		@Override
++		public Node getRowKey() {
++			return key;
++		}
++
++		@Override
++		public Collection<Column> getColumns() {
++			// TODO Auto-generated method stub
++			return PropertyTableHashMapImpl.this.getColumns();
++		}
++
++		@Override
++		public ExtendedIterator<Triple> getTripleIterator() {
++			ArrayList<Triple> triples = new ArrayList<Triple>();
++			for (Column column : getColumns()) {
++				Node value = this.getValue(column);
++				triples.add(Triple.create(key, column.getColumnKey(), value));
++			}
++			return WrappedIterator.create(triples.iterator());
++		}
++
++	}
++
++}

http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/main/java/org/apache/jena/propertytable/lang/LangCSV.java
----------------------------------------------------------------------
diff --cc jena-csv/src/main/java/org/apache/jena/propertytable/lang/LangCSV.java
index bd2ff29,bd2ff29..d816f46
--- a/jena-csv/src/main/java/org/apache/jena/propertytable/lang/LangCSV.java
+++ b/jena-csv/src/main/java/org/apache/jena/propertytable/lang/LangCSV.java
@@@ -1,154 -1,154 +1,154 @@@
--/**
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package org.apache.jena.propertytable.lang;
--
--import java.io.InputStream ;
--import java.io.Reader ;
--import java.util.ArrayList ;
--import java.util.List ;
--
--import org.apache.jena.atlas.csv.CSVParser ;
--import org.apache.jena.atlas.lib.IRILib ;
--import org.apache.jena.datatypes.xsd.XSDDatatype ;
--import org.apache.jena.graph.Node ;
--import org.apache.jena.graph.NodeFactory ;
--import org.apache.jena.riot.Lang ;
--import org.apache.jena.riot.RDFLanguages ;
--import org.apache.jena.riot.lang.LangRIOT ;
--import org.apache.jena.riot.system.* ;
--
--/**
-- * The LangRIOT implementation for CSV
-- *
-- */
--public class LangCSV implements LangRIOT {
--
--    /** @deprecated Use {@linkplain CSV2RDF#init} */
--    @Deprecated
--    public static void register() { CSV2RDF.init() ; }
--    
--	public static final String CSV_PREFIX = "http://w3c/future-csv-vocab/";
--	public static final String CSV_ROW = CSV_PREFIX + "row";
--
--	private InputStream input = null;
--	private Reader reader = null;
--	private String base;
--	private String filename;
--	private StreamRDF sink;
--	private ParserProfile profile; // Warning - we don't use all of this.
--
--	@Override
--	public Lang getLang() {
--		return RDFLanguages.CSV;
--	}
--
--	@Override
--	public ParserProfile getProfile() {
--		return profile;
--	}
--
--	@Override
--	public void setProfile(ParserProfile profile) {
--		this.profile = profile;
--	}
--
--	public LangCSV(Reader reader, String base, String filename, ErrorHandler errorHandler, StreamRDF sink) {
--		this.reader = reader;
--		this.base = base;
--		this.filename = filename;
--		this.sink = sink;
--		this.profile = RiotLib.profile(getLang(), base, errorHandler);
--	}
--
--	public LangCSV(InputStream in, String base, String filename, ErrorHandler errorHandler, StreamRDF sink) {
--		this.input = in;
--		this.base = base;
--		this.filename = filename;
--		this.sink = sink;
--		this.profile = RiotLib.profile(getLang(), base, errorHandler);
--	}
--
--	@Override
--	public void parse() {
--		sink.start();
--		CSVParser parser = (input != null) ? CSVParser.create(input) : CSVParser.create(reader);
--		List<String> row = null;
--		ArrayList<Node> predicates = new ArrayList<Node>();
--		int rowNum = 0;
--		while ((row = parser.parse1()) != null) {
--			
--			if (rowNum == 0) {
--				for (String column : row) {
--					String uri = IRIResolver.resolveString(filename) + "#"
--							+ toSafeLocalname(column);
--					Node predicate = this.profile.createURI(uri, rowNum, 0);
--					predicates.add(predicate);
--				}
--			} else {
--				//Node subject = this.profile.createBlankNode(null, -1, -1);
--				Node subject = caculateSubject(rowNum, filename);
--				Node predicateRow = this.profile.createURI(CSV_ROW, -1, -1);
--				Node objectRow = this.profile
--						.createTypedLiteral((rowNum + ""),
--								XSDDatatype.XSDinteger, rowNum, 0);
--				sink.triple(this.profile.createTriple(subject, predicateRow,
--						objectRow, rowNum, 0));
--				for (int col = 0; col < row.size() && col<predicates.size(); col++) {
--					Node predicate = predicates.get(col);
--					String columnValue = row.get(col).trim();
--					if("".equals(columnValue)){
--						continue;
--					}					
--					Node o;
--					try {
--						// Try for a double.
--						double d = Double.parseDouble(columnValue);
--						o = NodeFactory.createLiteral(columnValue,
--								XSDDatatype.XSDdouble);
--					} catch (Exception e) {
--						o = NodeFactory.createLiteral(columnValue);
--					}
--					sink.triple(this.profile.createTriple(subject, predicate,
--							o, rowNum, col));
--				}
--
--			}
--			rowNum++;
--		}
--		sink.finish();
--
--	}
--
--	public static String toSafeLocalname(String raw) {
--		String ret = raw.trim();
--		return encodeURIComponent(ret);
--		
--	}
--	
--	public static String encodeURIComponent(String s) {
--	    return IRILib.encodeUriComponent(s);
--	}
--	
--	public static Node caculateSubject(int rowNum, String filename){
--		Node subject = NodeFactory.createBlankNode();
--//		String uri = IRIResolver.resolveString(filename) + "#Row_" + rowNum; 
--//		Node subject =  NodeFactory.createURI(uri);
--		return subject;
--	}
--}
++/**
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package org.apache.jena.propertytable.lang;
++
++import java.io.InputStream ;
++import java.io.Reader ;
++import java.util.ArrayList ;
++import java.util.List ;
++
++import org.apache.jena.atlas.csv.CSVParser ;
++import org.apache.jena.atlas.lib.IRILib ;
++import org.apache.jena.datatypes.xsd.XSDDatatype ;
++import org.apache.jena.graph.Node ;
++import org.apache.jena.graph.NodeFactory ;
++import org.apache.jena.riot.Lang ;
++import org.apache.jena.riot.RDFLanguages ;
++import org.apache.jena.riot.lang.LangRIOT ;
++import org.apache.jena.riot.system.* ;
++
++/**
++ * The LangRIOT implementation for CSV
++ *
++ */
++public class LangCSV implements LangRIOT {
++
++    /** @deprecated Use {@linkplain CSV2RDF#init} */
++    @Deprecated
++    public static void register() { CSV2RDF.init() ; }
++    
++	public static final String CSV_PREFIX = "http://w3c/future-csv-vocab/";
++	public static final String CSV_ROW = CSV_PREFIX + "row";
++
++	private InputStream input = null;
++	private Reader reader = null;
++	private String base;
++	private String filename;
++	private StreamRDF sink;
++	private ParserProfile profile; // Warning - we don't use all of this.
++
++	@Override
++	public Lang getLang() {
++		return RDFLanguages.CSV;
++	}
++
++	@Override
++	public ParserProfile getProfile() {
++		return profile;
++	}
++
++	@Override
++	public void setProfile(ParserProfile profile) {
++		this.profile = profile;
++	}
++
++	public LangCSV(Reader reader, String base, String filename, ErrorHandler errorHandler, StreamRDF sink) {
++		this.reader = reader;
++		this.base = base;
++		this.filename = filename;
++		this.sink = sink;
++		this.profile = RiotLib.profile(getLang(), base, errorHandler);
++	}
++
++	public LangCSV(InputStream in, String base, String filename, ErrorHandler errorHandler, StreamRDF sink) {
++		this.input = in;
++		this.base = base;
++		this.filename = filename;
++		this.sink = sink;
++		this.profile = RiotLib.profile(getLang(), base, errorHandler);
++	}
++
++	@Override
++	public void parse() {
++		sink.start();
++		CSVParser parser = (input != null) ? CSVParser.create(input) : CSVParser.create(reader);
++		List<String> row = null;
++		ArrayList<Node> predicates = new ArrayList<Node>();
++		int rowNum = 0;
++		while ((row = parser.parse1()) != null) {
++			
++			if (rowNum == 0) {
++				for (String column : row) {
++					String uri = IRIResolver.resolveString(filename) + "#"
++							+ toSafeLocalname(column);
++					Node predicate = this.profile.createURI(uri, rowNum, 0);
++					predicates.add(predicate);
++				}
++			} else {
++				//Node subject = this.profile.createBlankNode(null, -1, -1);
++				Node subject = caculateSubject(rowNum, filename);
++				Node predicateRow = this.profile.createURI(CSV_ROW, -1, -1);
++				Node objectRow = this.profile
++						.createTypedLiteral((rowNum + ""),
++								XSDDatatype.XSDinteger, rowNum, 0);
++				sink.triple(this.profile.createTriple(subject, predicateRow,
++						objectRow, rowNum, 0));
++				for (int col = 0; col < row.size() && col<predicates.size(); col++) {
++					Node predicate = predicates.get(col);
++					String columnValue = row.get(col).trim();
++					if("".equals(columnValue)){
++						continue;
++					}					
++					Node o;
++					try {
++						// Try for a double.
++						double d = Double.parseDouble(columnValue);
++						o = NodeFactory.createLiteral(columnValue,
++								XSDDatatype.XSDdouble);
++					} catch (Exception e) {
++						o = NodeFactory.createLiteral(columnValue);
++					}
++					sink.triple(this.profile.createTriple(subject, predicate,
++							o, rowNum, col));
++				}
++
++			}
++			rowNum++;
++		}
++		sink.finish();
++
++	}
++
++	public static String toSafeLocalname(String raw) {
++		String ret = raw.trim();
++		return encodeURIComponent(ret);
++		
++	}
++	
++	public static String encodeURIComponent(String s) {
++	    return IRILib.encodeUriComponent(s);
++	}
++	
++	public static Node caculateSubject(int rowNum, String filename){
++		Node subject = NodeFactory.createBlankNode();
++//		String uri = IRIResolver.resolveString(filename) + "#Row_" + rowNum; 
++//		Node subject =  NodeFactory.createURI(uri);
++		return subject;
++	}
++}

http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/main/java/riotcmdx/csv2rdf.java
----------------------------------------------------------------------
diff --cc jena-csv/src/main/java/riotcmdx/csv2rdf.java
index eda3d8a,eda3d8a..cd8929d
--- a/jena-csv/src/main/java/riotcmdx/csv2rdf.java
+++ b/jena-csv/src/main/java/riotcmdx/csv2rdf.java
@@@ -1,52 -1,52 +1,52 @@@
--/*
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package riotcmdx;
--
--import org.apache.jena.atlas.lib.Lib ;
--import org.apache.jena.atlas.web.ContentType ;
--import org.apache.jena.riot.Lang ;
--import org.apache.jena.riot.RDFLanguages ;
--import riotcmd.CmdLangParse ;
--
--/**
-- * A command line tool for direct and scalable transforming from CSV to the formatted RDF syntax (i.e. N-Triples), 
-- * with no intermediary Graph or PropertyTable.
-- */
--public class csv2rdf extends CmdLangParse{
--	
--    public static void main(String... argv)
--    {
--        new csv2rdf(argv).mainRun() ;
--    }    
--    
--    protected csv2rdf(String[] argv)
--    {
--        super(argv) ;
--    }
--	
--	@Override
--	protected Lang selectLang(String filename, ContentType contentType, Lang dftLang) {
--		return RDFLanguages.CSV; 
--	}
--
--	@Override
--	protected String getCommandName() {
--		return Lib.classShortName(csv2rdf.class) ;
--	}
--}
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package riotcmdx;
++
++import org.apache.jena.atlas.lib.Lib ;
++import org.apache.jena.atlas.web.ContentType ;
++import org.apache.jena.riot.Lang ;
++import org.apache.jena.riot.RDFLanguages ;
++import riotcmd.CmdLangParse ;
++
++/**
++ * A command line tool for direct and scalable transforming from CSV to the formatted RDF syntax (i.e. N-Triples), 
++ * with no intermediary Graph or PropertyTable.
++ */
++public class csv2rdf extends CmdLangParse{
++	
++    public static void main(String... argv)
++    {
++        new csv2rdf(argv).mainRun() ;
++    }    
++    
++    protected csv2rdf(String[] argv)
++    {
++        super(argv) ;
++    }
++	
++	@Override
++	protected Lang selectLang(String filename, ContentType contentType, Lang dftLang) {
++		return RDFLanguages.CSV; 
++	}
++
++	@Override
++	protected String getCommandName() {
++		return Lib.classShortName(csv2rdf.class) ;
++	}
++}

http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/test/java/org/apache/jena/propertytable/AbstractColumnTest.java
----------------------------------------------------------------------
diff --cc jena-csv/src/test/java/org/apache/jena/propertytable/AbstractColumnTest.java
index a41161e,a41161e..fed4517
--- a/jena-csv/src/test/java/org/apache/jena/propertytable/AbstractColumnTest.java
+++ b/jena-csv/src/test/java/org/apache/jena/propertytable/AbstractColumnTest.java
@@@ -1,79 -1,79 +1,79 @@@
--/*
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package org.apache.jena.propertytable;
--
--import java.util.List;
--
--import org.apache.jena.graph.Node ;
--import org.apache.jena.graph.NodeFactory ;
--import org.junit.Assert;
--import org.junit.Test;
--
--/**
-- * Tests related to Column.
-- *
-- */
--public abstract class AbstractColumnTest extends BaseTest{
--
--
--	@Test(expected = NullPointerException.class)
--	public void testCreateColumnWithArgNull() {
--		table.createColumn(null);
--	}
--
--	@Test(expected = IllegalArgumentException.class)
--	public void testCreateListColumnWithAlreadyExistingCoulmnName() {
--		table.createColumn(URI("something"));
--		table.createColumn(URI("something"));
--	}
--	
--	@Test
--	public void testColumnCreate() {
--		table.createColumn(URI("something"));
--		Assert.assertEquals(1, table.getColumns().size());
--		Assert.assertTrue(collectionContains(table.getColumns(), URI("something")));
--	}
--	
--	@Test
--	public void testGetColumnValues() {
--		Column something = table.createColumn(URI("something"));
--		final Row row1 = table.createRow(NodeFactory.createBlankNode());
--		row1.setValue(something, URI("apple"));
--		final Row row2 = table.createRow(NodeFactory.createBlankNode());
--		row2.setValue(something, URI("orange"));
--		final List<Node> values = something.getValues();
--		Assert.assertTrue(values.size() == 2);
--		Assert.assertTrue(values.contains( URI("apple")));
--		Assert.assertTrue(values.contains(  URI("orange")));
--	}
--	
--	@Test
--	public void testGetColumn() {
--		table.createColumn(URI("something"));
--		Assert.assertNotNull(table.getColumn(URI("something")));
--		Assert.assertNull(table.getColumn( URI("nonExistentColumnName")));
--	}
--
--	@Test
--	public void testGetTable() {
--		Column something = table.createColumn(URI("something"));
--		Assert.assertEquals(table, something.getTable());
--	}
--
--}
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package org.apache.jena.propertytable;
++
++import java.util.List;
++
++import org.apache.jena.graph.Node ;
++import org.apache.jena.graph.NodeFactory ;
++import org.junit.Assert;
++import org.junit.Test;
++
++/**
++ * Tests related to Column.
++ *
++ */
++public abstract class AbstractColumnTest extends BaseTest{
++
++
++	@Test(expected = NullPointerException.class)
++	public void testCreateColumnWithArgNull() {
++		table.createColumn(null);
++	}
++
++	@Test(expected = IllegalArgumentException.class)
++	public void testCreateListColumnWithAlreadyExistingCoulmnName() {
++		table.createColumn(URI("something"));
++		table.createColumn(URI("something"));
++	}
++	
++	@Test
++	public void testColumnCreate() {
++		table.createColumn(URI("something"));
++		Assert.assertEquals(1, table.getColumns().size());
++		Assert.assertTrue(collectionContains(table.getColumns(), URI("something")));
++	}
++	
++	@Test
++	public void testGetColumnValues() {
++		Column something = table.createColumn(URI("something"));
++		final Row row1 = table.createRow(NodeFactory.createBlankNode());
++		row1.setValue(something, URI("apple"));
++		final Row row2 = table.createRow(NodeFactory.createBlankNode());
++		row2.setValue(something, URI("orange"));
++		final List<Node> values = something.getValues();
++		Assert.assertTrue(values.size() == 2);
++		Assert.assertTrue(values.contains( URI("apple")));
++		Assert.assertTrue(values.contains(  URI("orange")));
++	}
++	
++	@Test
++	public void testGetColumn() {
++		table.createColumn(URI("something"));
++		Assert.assertNotNull(table.getColumn(URI("something")));
++		Assert.assertNull(table.getColumn( URI("nonExistentColumnName")));
++	}
++
++	@Test
++	public void testGetTable() {
++		Column something = table.createColumn(URI("something"));
++		Assert.assertEquals(table, something.getTable());
++	}
++
++}

http://git-wip-us.apache.org/repos/asf/jena/blob/4b5cd267/jena-csv/src/test/java/org/apache/jena/propertytable/AbstractPropertyTableTest.java
----------------------------------------------------------------------
diff --cc jena-csv/src/test/java/org/apache/jena/propertytable/AbstractPropertyTableTest.java
index 5209361,5209361..a9544f9
--- a/jena-csv/src/test/java/org/apache/jena/propertytable/AbstractPropertyTableTest.java
+++ b/jena-csv/src/test/java/org/apache/jena/propertytable/AbstractPropertyTableTest.java
@@@ -1,56 -1,56 +1,56 @@@
--/*
-- * Licensed to the Apache Software Foundation (ASF) under one
-- * or more contributor license agreements.  See the NOTICE file
-- * distributed with this work for additional information
-- * regarding copyright ownership.  The ASF licenses this file
-- * to you under the Apache License, Version 2.0 (the
-- * "License"); you may not use this file except in compliance
-- * with the License.  You may obtain a copy of the License at
-- *
-- *     http://www.apache.org/licenses/LICENSE-2.0
-- *
-- * Unless required by applicable law or agreed to in writing, software
-- * distributed under the License is distributed on an "AS IS" BASIS,
-- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- * See the License for the specific language governing permissions and
-- * limitations under the License.
-- */
--
--package org.apache.jena.propertytable;
--
--import java.util.Collection;
--
--import org.apache.jena.graph.NodeFactory ;
--import org.junit.Assert;
--import org.junit.Test;
--
--/**
-- * Tests related to PropertyTable.
-- *
-- */
--public abstract class AbstractPropertyTableTest extends AbstractRowTest{
--
--	@Test
--	public void testGetMatchingColumns() {
--		Column something = table.createColumn(URI("something") );
--		final Row row1 = table.createRow(NodeFactory.createBlankNode());
--		row1.setValue(something, URI("apple"));
--		final Row row2 = table.createRow(NodeFactory.createBlankNode());
--		row2.setValue(something, URI("orange"));
--		Collection<Row> matchingRows = table.getMatchingRows(something, URI("apple"));
--		Assert.assertTrue(matchingRows.size() == 1);
--		matchingRows = table.getMatchingRows(something, URI("banana"));
--		Assert.assertTrue(matchingRows.isEmpty());
--	}
--	
--	@Test
--	public void testGetAllRows() {
--		Assert.assertTrue(table.getAllRows().size() == 1);
--		table.createRow(NodeFactory.createBlankNode());
--		Assert.assertTrue(table.getAllRows().size() == 2);
--		table.createRow(NodeFactory.createBlankNode());
--		Assert.assertTrue(table.getAllRows().size() == 3);
--	}
--
--
--}
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one
++ * or more contributor license agreements.  See the NOTICE file
++ * distributed with this work for additional information
++ * regarding copyright ownership.  The ASF licenses this file
++ * to you under the Apache License, Version 2.0 (the
++ * "License"); you may not use this file except in compliance
++ * with the License.  You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package org.apache.jena.propertytable;
++
++import java.util.Collection;
++
++import org.apache.jena.graph.NodeFactory ;
++import org.junit.Assert;
++import org.junit.Test;
++
++/**
++ * Tests related to PropertyTable.
++ *
++ */
++public abstract class AbstractPropertyTableTest extends AbstractRowTest{
++
++	@Test
++	public void testGetMatchingColumns() {
++		Column something = table.createColumn(URI("something") );
++		final Row row1 = table.createRow(NodeFactory.createBlankNode());
++		row1.setValue(something, URI("apple"));
++		final Row row2 = table.createRow(NodeFactory.createBlankNode());
++		row2.setValue(something, URI("orange"));
++		Collection<Row> matchingRows = table.getMatchingRows(something, URI("apple"));
++		Assert.assertTrue(matchingRows.size() == 1);
++		matchingRows = table.getMatchingRows(something, URI("banana"));
++		Assert.assertTrue(matchingRows.isEmpty());
++	}
++	
++	@Test
++	public void testGetAllRows() {
++		Assert.assertTrue(table.getAllRows().size() == 1);
++		table.createRow(NodeFactory.createBlankNode());
++		Assert.assertTrue(table.getAllRows().size() == 2);
++		table.createRow(NodeFactory.createBlankNode());
++		Assert.assertTrue(table.getAllRows().size() == 3);
++	}
++
++
++}


Mime
View raw message