Coverage Report

Coverage Report - org.apache.any23.rdf.Prefixes

Classes in this File

Line Coverage

Branch Coverage

Complexity

Prefixes

0/81

0/44

2.25

 /*
  * 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.any23.rdf;
 
 import org.openrdf.model.URI;
 import org.openrdf.model.impl.ValueFactoryImpl;
 
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 
 /**
  * A mapping from prefixes to namespace URIs. Supports "volatile mappings",
  * which will be overwritten without notice when mappings are merged,
  * while for normal mappings this causes an exception. This allows
  * combining "hard" mappings (which must be retained or something breaks)
  * and "soft" mappings (which might be read from input RDF files and
  * should be retained only if they are not in conflict with the hard ones).
  *
  * @author Richard Cyganiak (richard@cyganiak.de)
  */
 public class Prefixes {
 
     public static Prefixes create1(String prefix, String namespaceURI) {
         Prefixes result = new Prefixes();
         result.add(prefix, namespaceURI);
         return result;
     }
 
     public static Prefixes createFromMap(Map<String, String> prefixesToNamespaceURIs, boolean areVolatile) {
         Prefixes result = new Prefixes();
         for (Entry<String, String> entry : prefixesToNamespaceURIs.entrySet()) {
             if (areVolatile) {
                 result.addVolatile(entry.getKey(), entry.getValue());
             } else {
                 result.add(entry.getKey(), entry.getValue());
             }
         }
         return result;
     }
 
     public static Prefixes EMPTY = new Prefixes(Collections.<String, String>emptyMap());
 
     private final Map<String, String> mappings;
     private final Set<String> volatilePrefixes = new HashSet<String>();
 
     public Prefixes() {
         this(new HashMap<String, String>());
     }
 
     public Prefixes(Prefixes initial) {
         this();
         add(initial);
     }
 
     private Prefixes(Map<String, String> mappings) {
         this.mappings = mappings;
     }
 
     public URI expand(String curie) {
         String prefix = parsePrefix(curie);
         if (prefix == null || !hasPrefix(prefix)) {
             return null;
         }
         return ValueFactoryImpl.getInstance().createURI(
                 getNamespaceURIFor(prefix) + parseLocalName(curie));
     }
 
     public String abbreviate(String uri) {
         for (Entry<String, String> namespace : mappings.entrySet()) {
             if (uri.startsWith(namespace.getValue())) {
                 return namespace.getKey() + ":" +
                         uri.substring(namespace.getValue().length());
             }
         }
         return null;
     }
 
     public boolean canExpand(String curie) {
         String prefix = parsePrefix(curie);
         return prefix != null && hasPrefix(prefix);
     }
 
     public boolean canAbbreviate(String uri) {
         for (Entry<String, String> namespace : mappings.entrySet()) {
             if (uri.startsWith(namespace.getValue())) {
                 return true;
             }
         }
         return false;
     }
 
     public String getNamespaceURIFor(String prefix) {
         return mappings.get(prefix);
     }
 
     public boolean hasNamespaceURI(String uri) {
         return mappings.containsValue(uri);
     }
 
     public boolean hasPrefix(String prefix) {
         return mappings.containsKey(prefix);
     }
 
     public Set<String> allPrefixes() {
         return mappings.keySet();
     }
 
     public boolean isEmpty() {
         return mappings.isEmpty();
     }
 
     public void add(String prefix, String namespaceURI) {
         if (isVolatile(prefix)) {
             volatilePrefixes.remove(prefix);
         } else {
             if (hasPrefix(prefix)) {
                 if (getNamespaceURIFor(prefix).equals(namespaceURI)) {
                     return;    // re-assigned same prefix to same URI, let's just ignore it
                 }
                 throw new IllegalStateException("Attempted to re-assign prefix '" + prefix +
                         "'; clashing values '" + getNamespaceURIFor(prefix) + "' and '" +
                         namespaceURI);
             }
         }
         mappings.put(prefix, namespaceURI);
     }
 
     public void add(Prefixes other) {
         for (String otherPrefix : other.allPrefixes()) {
             if (other.isVolatile(otherPrefix)) {
                 addVolatile(otherPrefix, other.getNamespaceURIFor(otherPrefix));
             } else {
                 add(otherPrefix, other.getNamespaceURIFor(otherPrefix));
             }
         }
     }
 
     public void removePrefix(String prefix) {
         mappings.remove(prefix);
         volatilePrefixes.remove(prefix);
     }
 
     public Prefixes createSubset(String... prefixes) {
         Prefixes result = new Prefixes();
         for (String prefix : prefixes) {
             if (!hasPrefix(prefix)) {
                 throw new IllegalArgumentException("No namespace URI declared for prefix " + prefix);
             }
             result.add(prefix, getNamespaceURIFor(prefix));
         }
         return result;
     }
 
     public void addVolatile(String prefix, String namespaceURI) {
         if (hasPrefix(prefix)) {
             return;    // new prefix is volatile, so we don't overwrite the old one
         }
         mappings.put(prefix, namespaceURI);
         volatilePrefixes.add(prefix);
     }
 
     public void addVolatile(Prefixes other) {
         for (String otherPrefix : other.allPrefixes()) {
             addVolatile(otherPrefix, other.getNamespaceURIFor(otherPrefix));
         }
     }
 
     public boolean isVolatile(String prefix) {
         return volatilePrefixes.contains(prefix);
     }
 
     private Map<String, String> mapUnmodifiable = null;
 
     public Map<String, String> asMap() {
         // Optimization: Create the unmodifiable map only once, lazily
         if (mapUnmodifiable == null) {
             mapUnmodifiable = Collections.unmodifiableMap(mappings);
         }
         return mapUnmodifiable;
     }
 
     private String parsePrefix(String curie) {
         int index = curie.indexOf(':');
         if (index == -1) {
             throw new IllegalArgumentException("Not a CURIE: '" + curie + "'");
         }
         return curie.substring(0, index);
     }
 
     private String parseLocalName(String curie) {
         int index = curie.indexOf(':');
         if (index == -1) {
             throw new IllegalArgumentException("Not a CURIE: '" + curie + "'");
         }
         return curie.substring(index + 1);
     }
     
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		package org.apache.any23.rdf;
19
20		import org.openrdf.model.URI;
21		import org.openrdf.model.impl.ValueFactoryImpl;
22
23		import java.util.Collections;
24		import java.util.HashMap;
25		import java.util.HashSet;
26		import java.util.Map;
27		import java.util.Map.Entry;
28		import java.util.Set;
29
30		/**
31		* A mapping from prefixes to namespace URIs. Supports "volatile mappings",
32		* which will be overwritten without notice when mappings are merged,
33		* while for normal mappings this causes an exception. This allows
34		* combining "hard" mappings (which must be retained or something breaks)
35		* and "soft" mappings (which might be read from input RDF files and
36		* should be retained only if they are not in conflict with the hard ones).
37		*
38		* @author Richard Cyganiak (richard@cyganiak.de)
39		*/
40		public class Prefixes {
41
42		public static Prefixes create1(String prefix, String namespaceURI) {
43	0	Prefixes result = new Prefixes();
44	0	result.add(prefix, namespaceURI);
45	0	return result;
46		}
47
48		public static Prefixes createFromMap(Map<String, String> prefixesToNamespaceURIs, boolean areVolatile) {
49	0	Prefixes result = new Prefixes();
50	0	for (Entry<String, String> entry : prefixesToNamespaceURIs.entrySet()) {
51	0	if (areVolatile) {
52	0	result.addVolatile(entry.getKey(), entry.getValue());
53		} else {
54	0	result.add(entry.getKey(), entry.getValue());
55		}
56		}
57	0	return result;
58		}
59
60	0	public static Prefixes EMPTY = new Prefixes(Collections.<String, String>emptyMap());
61
62		private final Map<String, String> mappings;
63	0	private final Set<String> volatilePrefixes = new HashSet<String>();
64
65		public Prefixes() {
66	0	this(new HashMap<String, String>());
67	0	}
68
69		public Prefixes(Prefixes initial) {
70	0	this();
71	0	add(initial);
72	0	}
73
74	0	private Prefixes(Map<String, String> mappings) {
75	0	this.mappings = mappings;
76	0	}
77
78		public URI expand(String curie) {
79	0	String prefix = parsePrefix(curie);
80	0	if (prefix == null \|\| !hasPrefix(prefix)) {
81	0	return null;
82		}
83	0	return ValueFactoryImpl.getInstance().createURI(
84		getNamespaceURIFor(prefix) + parseLocalName(curie));
85		}
86
87		public String abbreviate(String uri) {
88	0	for (Entry<String, String> namespace : mappings.entrySet()) {
89	0	if (uri.startsWith(namespace.getValue())) {
90	0	return namespace.getKey() + ":" +
91		uri.substring(namespace.getValue().length());
92		}
93		}
94	0	return null;
95		}
96
97		public boolean canExpand(String curie) {
98	0	String prefix = parsePrefix(curie);
99	0	return prefix != null && hasPrefix(prefix);
100		}
101
102		public boolean canAbbreviate(String uri) {
103	0	for (Entry<String, String> namespace : mappings.entrySet()) {
104	0	if (uri.startsWith(namespace.getValue())) {
105	0	return true;
106		}
107		}
108	0	return false;
109		}
110
111		public String getNamespaceURIFor(String prefix) {
112	0	return mappings.get(prefix);
113		}
114
115		public boolean hasNamespaceURI(String uri) {
116	0	return mappings.containsValue(uri);
117		}
118
119		public boolean hasPrefix(String prefix) {
120	0	return mappings.containsKey(prefix);
121		}
122
123		public Set<String> allPrefixes() {
124	0	return mappings.keySet();
125		}
126
127		public boolean isEmpty() {
128	0	return mappings.isEmpty();
129		}
130
131		public void add(String prefix, String namespaceURI) {
132	0	if (isVolatile(prefix)) {
133	0	volatilePrefixes.remove(prefix);
134		} else {
135	0	if (hasPrefix(prefix)) {
136	0	if (getNamespaceURIFor(prefix).equals(namespaceURI)) {
137	0	return; // re-assigned same prefix to same URI, let's just ignore it
138		}
139	0	throw new IllegalStateException("Attempted to re-assign prefix '" + prefix +
140		"'; clashing values '" + getNamespaceURIFor(prefix) + "' and '" +
141		namespaceURI);
142		}
143		}
144	0	mappings.put(prefix, namespaceURI);
145	0	}
146
147		public void add(Prefixes other) {
148	0	for (String otherPrefix : other.allPrefixes()) {
149	0	if (other.isVolatile(otherPrefix)) {
150	0	addVolatile(otherPrefix, other.getNamespaceURIFor(otherPrefix));
151		} else {
152	0	add(otherPrefix, other.getNamespaceURIFor(otherPrefix));
153		}
154		}
155	0	}
156
157		public void removePrefix(String prefix) {
158	0	mappings.remove(prefix);
159	0	volatilePrefixes.remove(prefix);
160	0	}
161
162		public Prefixes createSubset(String... prefixes) {
163	0	Prefixes result = new Prefixes();
164	0	for (String prefix : prefixes) {
165	0	if (!hasPrefix(prefix)) {
166	0	throw new IllegalArgumentException("No namespace URI declared for prefix " + prefix);
167		}
168	0	result.add(prefix, getNamespaceURIFor(prefix));
169		}
170	0	return result;
171		}
172
173		public void addVolatile(String prefix, String namespaceURI) {
174	0	if (hasPrefix(prefix)) {
175	0	return; // new prefix is volatile, so we don't overwrite the old one
176		}
177	0	mappings.put(prefix, namespaceURI);
178	0	volatilePrefixes.add(prefix);
179	0	}
180
181		public void addVolatile(Prefixes other) {
182	0	for (String otherPrefix : other.allPrefixes()) {
183	0	addVolatile(otherPrefix, other.getNamespaceURIFor(otherPrefix));
184		}
185	0	}
186
187		public boolean isVolatile(String prefix) {
188	0	return volatilePrefixes.contains(prefix);
189		}
190
191	0	private Map<String, String> mapUnmodifiable = null;
192
193		public Map<String, String> asMap() {
194		// Optimization: Create the unmodifiable map only once, lazily
195	0	if (mapUnmodifiable == null) {
196	0	mapUnmodifiable = Collections.unmodifiableMap(mappings);
197		}
198	0	return mapUnmodifiable;
199		}
200
201		private String parsePrefix(String curie) {
202	0	int index = curie.indexOf(':');
203	0	if (index == -1) {
204	0	throw new IllegalArgumentException("Not a CURIE: '" + curie + "'");
205		}
206	0	return curie.substring(0, index);
207		}
208
209		private String parseLocalName(String curie) {
210	0	int index = curie.indexOf(':');
211	0	if (index == -1) {
212	0	throw new IllegalArgumentException("Not a CURIE: '" + curie + "'");
213		}
214	0	return curie.substring(index + 1);
215		}
216
217		}