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); ++ } ++ ++ ++}
