/** * {@inheritDoc} * * @see org.modeshape.graph.property.NamespaceRegistry#register(java.lang.Iterable) */ public void register( Iterable<Namespace> namespaces ) { // Let the delegate registry handle this, including cases where an aliased namespace is changed ... delegate.register(namespaces); }
/** * {@inheritDoc} * * @see org.modeshape.graph.property.NamespaceRegistry#getNamespaces() */ public Set<Namespace> getNamespaces() { // Do not include the aliases in the namespaces ... return delegate.getNamespaces(); }
/** * {@inheritDoc} * * @see org.modeshape.graph.property.NamespaceRegistry#getDefaultNamespaceUri() */ public String getDefaultNamespaceUri() { // Just delegate ... return delegate.getDefaultNamespaceUri(); }
/** * {@inheritDoc} * * @see org.xml.sax.helpers.DefaultHandler#endPrefixMapping(java.lang.String) */ @Override public void endPrefixMapping( String prefix ) { assert prefix != null; // Get the current URI for this prefix ... String uri = namespaceRegistry.getNamespaceForPrefix(prefix); assert uri != null; // Get the previous prefix from the stack ... LinkedList<String> prefixStack = this.prefixStackByUri.get(uri); assert prefixStack != null; assert !prefixStack.isEmpty(); String existingPrefix = prefixStack.removeFirst(); assert prefix.equals(existingPrefix); // If there are no previous prefixes, then remove the mapping ... if (prefixStack.isEmpty()) { namespaceRegistry.unregister(uri); prefixStackByUri.remove(uri); } else { String previous = prefixStack.getFirst(); namespaceRegistry.register(previous, uri); } }
if (!namespaceRegistry.isRegisteredNamespaceUri(uri)) { if (contextRegistry.getNamespaceForPrefix(prefix) != null) { context.getNamespaceRegistry().getPrefixForNamespaceUri(uri, true); namespaceRegistry.register(prefix, uri); } else { context.getNamespaceRegistry().register(prefix, uri); namespaceRegistry.register(prefix, uri);
@Test public void shouldReturnNonNullDefaultNamespaceUriWhenThereAreNamespacesRegisteredIncludineOneWithZeroLengthPrefix() { namespaceRegistry.register(validPrefix1, validNamespaceUri1); namespaceRegistry.register("", validNamespaceUri2); assertThat(namespaceRegistry.getDefaultNamespaceUri(), is(validNamespaceUri2)); assertThat(namespaceRegistry.getNamespaceForPrefix(""), is(validNamespaceUri2)); assertThat(namespaceRegistry.getRegisteredNamespaceUris(), hasItem(validNamespaceUri2)); assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri2, false), is("")); }
for (NamespaceRegistry.Namespace actual : registry.getNamespaces()) { String expectedUri = expected.remove(actual.getPrefix()); assertThat("namespace URIs differ", actual.getNamespaceUri(), is(expectedUri)); String prefix = actual.getPrefix(); String uri = actual.getNamespaceUri(); assertThat(registry.isRegisteredNamespaceUri(uri), is(true)); assertThat(registry.getPrefixForNamespaceUri(uri, false), is(prefix)); assertThat(registry.getNamespaceForPrefix(prefix), is(uri)); msg.append(entry.getKey()).append("=").append(entry.getValue()); assertThat(msg.toString(), registry.getNamespaces().isEmpty(), is(true));
protected void initializeCacheFromStore( NamespaceRegistry cache ) { Set<Namespace> toRegister = new HashSet<Namespace>(store.getContext().getNamespaceRegistry().getNamespaces()); if (uri != null) { String prefix = getPrefixFor(nsLocation.getPath()); cache.register(prefix, uri); cache.register("", ""); toRegister.remove(cache.getNamespaceForPrefix("")); Path pathToNamespaceNode = pathFactory.create(parentOfNamespaceNodes, prefix); batch.create(pathToNamespaceNode).with(namespaceProperties).and(uriPropertyName, uri).and(); cache.register(prefix, uri);
@Test public void shouldReturnPrefixForNamespaceUriThatIsRegistered() { namespaceRegistry.register(validPrefix1, validNamespaceUri1); namespaceRegistry.register(validPrefix2, validNamespaceUri2); assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri1, false), is(validPrefix1)); assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri2, false), is(validPrefix2)); }
@Test public void shouldReturnNamespaceUriForPrefixThatIsRegistered() { namespaceRegistry.register(validPrefix1, validNamespaceUri1); namespaceRegistry.register(validPrefix2, validNamespaceUri2); assertThat(namespaceRegistry.getNamespaceForPrefix(validPrefix1), is(validNamespaceUri1)); assertThat(namespaceRegistry.getNamespaceForPrefix(validPrefix2), is(validNamespaceUri2)); }
@Test public void shouldFindRegisteredNamespace() { namespaceRegistry.register(validPrefix1, validNamespaceUri1); namespaceRegistry.register(validPrefix2, validNamespaceUri2); assertThat(namespaceRegistry.isRegisteredNamespaceUri(validNamespaceUri1), is(true)); assertThat(namespaceRegistry.isRegisteredNamespaceUri(validNamespaceUri2), is(true)); }
@Test public void shouldAlwaysHaveDefaultNamespaceRegistered() { assertThat(namespaceRegistry.getDefaultNamespaceUri(), is(notNullValue())); namespaceRegistry.register(validPrefix1, validNamespaceUri1); namespaceRegistry.register(validPrefix2, validNamespaceUri2); assertThat(namespaceRegistry.getDefaultNamespaceUri(), is(notNullValue())); }
@Test public void shouldParseXmlDocumentWithNamespacesThatAreNotYetInRegistry() throws IOException, SAXException { NamespaceRegistry reg = context.getNamespaceRegistry(); reg.unregister(JcrLexicon.Namespace.URI); reg.unregister(NT_NAMESPACE_URI); assertThat(reg.getPrefixForNamespaceUri(JcrLexicon.Namespace.URI, false), is(nullValue())); assertThat(reg.getPrefixForNamespaceUri(NT_NAMESPACE_URI, false), is(nullValue())); assertThat(reg.getPrefixForNamespaceUri("http://default.namespace.com", false), is(nullValue())); String c = reg.getPrefixForNamespaceUri("http://default.namespace.com", false); String i = reg.getPrefixForNamespaceUri("http://attributes.com", false); String d = reg.getPrefixForNamespaceUri(reg.getDefaultNamespaceUri(), false); assertThat("Namespace not properly registered in primary registry", c, is(notNullValue())); assertThat("Namespace not properly registered in primary registry", d, is(notNullValue()));
/** * {@inheritDoc} * * @see org.modeshape.graph.property.NamespaceRegistry#getPrefixForNamespaceUri(java.lang.String, boolean) */ public String getPrefixForNamespaceUri( String namespaceUri, boolean generateIfMissing ) { // Before we do anything, see if the supplied namespace is an aliased namespace ... String originalNamespaceUri = namespaceUrisByAlias.get(namespaceUri); if (originalNamespaceUri != null) { namespaceUri = originalNamespaceUri; } return delegate.getPrefixForNamespaceUri(namespaceUri, generateIfMissing); }
/** * {@inheritDoc} */ public String getNamespaceForPrefix( String prefix ) { CheckArg.isNotNull(prefix, "prefix"); Lock lock = this.registryLock.readLock(); try { lock.lock(); return this.delegate.getNamespaceForPrefix(prefix); } finally { lock.unlock(); } }
/** * {@inheritDoc} * * @see org.modeshape.graph.property.NamespaceRegistry#isRegisteredNamespaceUri(java.lang.String) */ public boolean isRegisteredNamespaceUri( String namespaceUri ) { return delegate.isRegisteredNamespaceUri(namespaceUri); }
/** * {@inheritDoc} * * @see org.modeshape.graph.property.NamespaceRegistry#getRegisteredNamespaceUris() */ public Set<String> getRegisteredNamespaceUris() { // Do not include the aliases in the namespace URIs ... return delegate.getRegisteredNamespaceUris(); }
/** * {@inheritDoc} * * @see org.modeshape.graph.property.NamespaceRegistry#unregister(java.lang.String) */ public boolean unregister( String namespaceUri ) { // We cannot unregister an alias, so we only need to try unregistering with the delegate registry ... return delegate.unregister(namespaceUri); }
@Test public void shouldBeAbleToCopyNamespacesToAnotherRegistry() { namespaceRegistry.register(validPrefix1, validNamespaceUri1); namespaceRegistry.register(validPrefix2, validNamespaceUri2); namespaceRegistry.register("", validNamespaceUri3); assertThat(namespaceRegistry.isRegisteredNamespaceUri(validNamespaceUri1), is(true)); assertThat(namespaceRegistry.isRegisteredNamespaceUri(validNamespaceUri2), is(true)); assertThat(namespaceRegistry.isRegisteredNamespaceUri(validNamespaceUri3), is(true)); assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri1, false), is(validPrefix1)); assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri2, false), is(validPrefix2)); assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri3, false), is("")); assertThat(namespaceRegistry.getNamespaceForPrefix(validPrefix1), is(validNamespaceUri1)); assertThat(namespaceRegistry.getNamespaceForPrefix(validPrefix2), is(validNamespaceUri2)); assertThat(namespaceRegistry.getNamespaceForPrefix(""), is(validNamespaceUri3)); NamespaceRegistry newRegistry = new SimpleNamespaceRegistry(); for (String uri : this.namespaceRegistry.getRegisteredNamespaceUris()) { String prefix = this.namespaceRegistry.getPrefixForNamespaceUri(uri, false); newRegistry.register(prefix, uri); } assertThat(newRegistry.isRegisteredNamespaceUri(validNamespaceUri1), is(true)); assertThat(newRegistry.isRegisteredNamespaceUri(validNamespaceUri2), is(true)); assertThat(newRegistry.isRegisteredNamespaceUri(validNamespaceUri3), is(true)); assertThat(newRegistry.getPrefixForNamespaceUri(validNamespaceUri1, false), is(validPrefix1)); assertThat(newRegistry.getPrefixForNamespaceUri(validNamespaceUri2, false), is(validPrefix2)); assertThat(newRegistry.getPrefixForNamespaceUri(validNamespaceUri3, false), is("")); assertThat(newRegistry.getNamespaceForPrefix(validPrefix1), is(validNamespaceUri1)); assertThat(newRegistry.getNamespaceForPrefix(validPrefix2), is(validNamespaceUri2)); assertThat(newRegistry.getNamespaceForPrefix(""), is(validNamespaceUri3)); }
@Test public void shouldReturnNullForPrefixIfNamespaceUriIsNotRegistered() { assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri3, false), is(nullValue())); // now register some namespaces ... namespaceRegistry.register(validPrefix1, validNamespaceUri1); namespaceRegistry.register(validPrefix2, validNamespaceUri2); assertThat(namespaceRegistry.getPrefixForNamespaceUri(validNamespaceUri3, false), is(nullValue())); }