001/* 002 * Copyright 2015-2017 UnboundID Corp. 003 * All Rights Reserved. 004 */ 005/* 006 * Copyright (C) 2015-2017 UnboundID Corp. 007 * 008 * This program is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU General Public License (GPLv2 only) 010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 011 * as published by the Free Software Foundation. 012 * 013 * This program is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU General Public License for more details. 017 * 018 * You should have received a copy of the GNU General Public License 019 * along with this program; if not, see <http://www.gnu.org/licenses>. 020 */ 021package com.unboundid.util.args; 022 023 024 025import java.net.URI; 026import java.util.Collection; 027import java.util.Collections; 028import java.util.Iterator; 029import java.util.LinkedHashSet; 030import java.util.Set; 031 032import com.unboundid.util.Debug; 033import com.unboundid.util.NotMutable; 034import com.unboundid.util.StaticUtils; 035import com.unboundid.util.ThreadSafety; 036import com.unboundid.util.ThreadSafetyLevel; 037 038import static com.unboundid.util.args.ArgsMessages.*; 039 040 041 042/** 043 * This class provides an implementation of an argument value validator that is 044 * expected to be used with a string argument and ensures that all values for 045 * the argument are valid URLs. It can optionally restrict the URLs to a 046 * specified set of schemes. 047 */ 048@NotMutable() 049@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 050public final class URLArgumentValueValidator 051 extends ArgumentValueValidator 052{ 053 // The set of schemes allowed to be used in URLs. 054 private final Set<String> allowedSchemes; 055 056 057 058 /** 059 * Creates a new instance of this URL argument value validator that will 060 * accept values that are URLs with any of the specified schemes. 061 * 062 * @param allowedSchemes The names of the schemes for the URLs that will be 063 * accepted. It may be {@code null} or empty if any 064 * scheme will be accepted. 065 */ 066 public URLArgumentValueValidator(final String... allowedSchemes) 067 { 068 this(StaticUtils.toList(allowedSchemes)); 069 } 070 071 072 073 /** 074 * Creates a new instance of this URL argument value validator that will 075 * accept values that are URLs with any of the specified schemes. 076 * 077 * @param allowedSchemes The names of the schemes for the URLs that will be 078 * accepted. It may be {@code null} or empty if any 079 * scheme will be accepted. 080 */ 081 public URLArgumentValueValidator(final Collection<String> allowedSchemes) 082 { 083 if (allowedSchemes == null) 084 { 085 this.allowedSchemes = Collections.emptySet(); 086 } 087 else 088 { 089 this.allowedSchemes = Collections.unmodifiableSet( 090 new LinkedHashSet<String>(allowedSchemes)); 091 } 092 } 093 094 095 096 /** 097 * Retrieves the names of the schemes for the URLs that will be accepted. 098 * 099 * @return The names of the schemes for the URLs that will be accepted, or 100 * an empty set if URLs will be allowed to have any scheme. 101 */ 102 public Set<String> getAllowedSchemes() 103 { 104 return allowedSchemes; 105 } 106 107 108 109 /** 110 * {@inheritDoc} 111 */ 112 @Override() 113 public void validateArgumentValue(final Argument argument, 114 final String valueString) 115 throws ArgumentException 116 { 117 final URI uri; 118 try 119 { 120 uri = new URI(valueString); 121 } 122 catch (final Exception e) 123 { 124 Debug.debugException(e); 125 throw new ArgumentException( 126 ERR_URL_VALIDATOR_VALUE_NOT_URL.get(valueString, 127 argument.getIdentifierString(), 128 StaticUtils.getExceptionMessage(e)), 129 e); 130 } 131 132 if (uri.getScheme() == null) 133 { 134 throw new ArgumentException(ERR_URL_VALIDATOR_MISSING_SCHEME.get( 135 valueString, argument.getIdentifierString())); 136 } 137 138 if ((! allowedSchemes.isEmpty()) && 139 (! allowedSchemes.contains(uri.getScheme()))) 140 { 141 throw new ArgumentException( 142 ERR_URL_VALIDATOR_UNACCEPTABLE_SCHEME.get(valueString, 143 argument.getIdentifierString(), uri.getScheme())); 144 } 145 } 146 147 148 149 /** 150 * Retrieves a string representation of this argument value validator. 151 * 152 * @return A string representation of this argument value validator. 153 */ 154 @Override() 155 public String toString() 156 { 157 final StringBuilder buffer = new StringBuilder(); 158 toString(buffer); 159 return buffer.toString(); 160 } 161 162 163 164 /** 165 * Appends a string representation of this argument value validator to the 166 * provided buffer. 167 * 168 * @param buffer The buffer to which the string representation should be 169 * appended. 170 */ 171 public void toString(final StringBuilder buffer) 172 { 173 buffer.append("URLArgumentValueValidator("); 174 175 if (allowedSchemes != null) 176 { 177 buffer.append("allowedSchemes={"); 178 179 final Iterator<String> iterator = allowedSchemes.iterator(); 180 while (iterator.hasNext()) 181 { 182 buffer.append('\''); 183 buffer.append(iterator.next()); 184 buffer.append('\''); 185 186 if (iterator.hasNext()) 187 { 188 buffer.append(", "); 189 } 190 } 191 192 buffer.append('}'); 193 } 194 195 buffer.append(')'); 196 } 197}