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 com.unboundid.ldap.sdk.Attribute; 026import com.unboundid.ldap.sdk.persist.PersistUtils; 027import com.unboundid.ldap.sdk.schema.Schema; 028import com.unboundid.util.NotMutable; 029import com.unboundid.util.ThreadSafety; 030import com.unboundid.util.ThreadSafetyLevel; 031 032import static com.unboundid.util.args.ArgsMessages.*; 033 034 035 036/** 037 * This class provides an implementation of an argument value validator that is 038 * expected to be used with a string argument and ensures that all values for 039 * the argument are valid attribute type names (or numeric OIDs) or attribute 040 * descriptions (a name or OID with attribute options). It can optionally use a 041 * provided schema to verify that the specified attribute type is defined. 042 */ 043@NotMutable() 044@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 045public final class AttributeNameArgumentValueValidator 046 extends ArgumentValueValidator 047{ 048 // Indicates whether to allow values to include attribute options. 049 private final boolean allowOptions; 050 051 // An optional schema to use to verify that the specified attribute type is 052 // defined. 053 private final Schema schema; 054 055 056 057 /** 058 * Creates a new instance of this attribute name argument value validator that 059 * will not permit attribute options and will not attempt to verify that the 060 * specified attribute type is defined in a schema. 061 */ 062 public AttributeNameArgumentValueValidator() 063 { 064 this(false, null); 065 } 066 067 068 069 /** 070 * Creates a new instance of this attribute name argument value validator with 071 * the provided information. 072 * 073 * @param allowOptions Indicates whether to allow values that include one or 074 * more attribute options. 075 * @param schema An optional schema that can be used to verify that 076 * the specified attribute type is defined. 077 */ 078 public AttributeNameArgumentValueValidator(final boolean allowOptions, 079 final Schema schema) 080 { 081 this.allowOptions = allowOptions; 082 this.schema = schema; 083 } 084 085 086 087 /** 088 * Indicates whether to allow values that include one or more attribute 089 * options. 090 * 091 * @return {@code true} if values will be allowed to include attribute 092 * options, or {@code false} if not. 093 */ 094 public boolean allowOptions() 095 { 096 return allowOptions; 097 } 098 099 100 101 /** 102 * Retrieves the schema that will be used to verify that attribute types 103 * specified in argument values are defined, if any. 104 * 105 * @return The schema that will be used to verify that attribute types 106 * specified in argument values are defined, or {@code null} if no 107 * such validation will be performed. 108 */ 109 public Schema getSchema() 110 { 111 return schema; 112 } 113 114 115 116 /** 117 * {@inheritDoc} 118 */ 119 @Override() 120 public void validateArgumentValue(final Argument argument, 121 final String valueString) 122 throws ArgumentException 123 { 124 final StringBuilder errorMessage = new StringBuilder(); 125 if (! PersistUtils.isValidLDAPName(valueString, allowOptions, errorMessage)) 126 { 127 throw new ArgumentException(ERR_ATTR_NAME_VALIDATOR_INVALID_VALUE.get( 128 valueString, argument.getIdentifierString(), 129 String.valueOf(errorMessage))); 130 } 131 132 if (schema != null) 133 { 134 final String baseName = Attribute.getBaseName(valueString); 135 if (schema.getAttributeType(baseName) == null) 136 { 137 throw new ArgumentException( 138 ERR_ATTR_NAME_VALIDATOR_TYPE_NOT_DEFINED.get(valueString, 139 argument.getIdentifierString(), baseName)); 140 } 141 } 142 } 143 144 145 146 /** 147 * Retrieves a string representation of this argument value validator. 148 * 149 * @return A string representation of this argument value validator. 150 */ 151 @Override() 152 public String toString() 153 { 154 final StringBuilder buffer = new StringBuilder(); 155 toString(buffer); 156 return buffer.toString(); 157 } 158 159 160 161 /** 162 * Appends a string representation of this argument value validator to the 163 * provided buffer. 164 * 165 * @param buffer The buffer to which the string representation should be 166 * appended. 167 */ 168 public void toString(final StringBuilder buffer) 169 { 170 buffer.append("AttributeNameArgumentValueValidator(allowOptions="); 171 buffer.append(allowOptions); 172 buffer.append(", hasSchema="); 173 buffer.append(schema != null); 174 buffer.append(')'); 175 } 176}