001 /* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2006-2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.tools.makeldif; 028 029 030 031 import java.util.ArrayList; 032 import java.util.LinkedHashMap; 033 import java.util.LinkedHashSet; 034 import java.util.List; 035 036 import org.opends.server.core.DirectoryServer; 037 import org.opends.server.types.Attribute; 038 import org.opends.server.types.AttributeType; 039 import org.opends.server.types.AttributeValue; 040 import org.opends.server.types.DN; 041 import org.opends.server.types.Entry; 042 import org.opends.server.types.ObjectClass; 043 import org.opends.server.types.RDN; 044 045 import static org.opends.server.util.StaticUtils.*; 046 047 048 049 /** 050 * This class defines an entry that is generated using a MakeLDIF branch or 051 * template. 052 */ 053 public class TemplateEntry 054 { 055 // The branch used to generate this entry (if it is associated with a branch). 056 private Branch branch; 057 058 // The DN for this template entry, if it is known. 059 private DN dn; 060 061 // The DN of the parent entry for this template entry, if it is available. 062 private DN parentDN; 063 064 // The set of attributes associated with this template entry, mapped from the 065 // lowercase name of the attribute to the list of generated values. 066 private LinkedHashMap<AttributeType,ArrayList<TemplateValue>> attributes; 067 068 // The template used to generate this entry (if it is associated with a 069 // template). 070 private Template template; 071 072 073 074 /** 075 * Creates a new template entry that will be associated with the provided 076 * branch. 077 * 078 * @param branch The branch to use when creating this template entry. 079 */ 080 public TemplateEntry(Branch branch) 081 { 082 this.branch = branch; 083 084 dn = branch.getBranchDN(); 085 template = null; 086 parentDN = null; 087 attributes = new LinkedHashMap<AttributeType,ArrayList<TemplateValue>>(); 088 } 089 090 091 092 /** 093 * Creates a new template entry that will be associated with the provided 094 * template. 095 * 096 * @param template The template used to generate this entry. 097 * @param parentDN The DN of the parent entry for this template entry. 098 */ 099 public TemplateEntry(Template template, DN parentDN) 100 { 101 this.template = template; 102 this.parentDN = parentDN; 103 104 dn = null; 105 branch = null; 106 attributes = new LinkedHashMap<AttributeType,ArrayList<TemplateValue>>(); 107 } 108 109 110 111 /** 112 * Retrieves the branch used to generate this entry. 113 * 114 * @return The branch used to generate this entry, or <CODE>null</CODE> if it 115 * is associated with a template instead of a branch. 116 */ 117 public Branch getBranch() 118 { 119 return branch; 120 } 121 122 123 124 /** 125 * Retrieves the template used to generate this entry. 126 * 127 * @return The template used to generate this entry, or <CODE>null</CODE> if 128 * it is associated with a branch instead of a template. 129 */ 130 public Template getTemplate() 131 { 132 return template; 133 } 134 135 136 137 /** 138 * Retrieves the DN of the parent entry for this template entry. 139 * 140 * @return The DN of the parent entry for this template entry, or 141 * <CODE>null</CODE> if there is no parent DN. 142 */ 143 public DN getParentDN() 144 { 145 return parentDN; 146 } 147 148 149 150 /** 151 * Retrieves the DN for this template entry, if it is known. 152 * 153 * @return The DN for this template entry if it is known, or 154 * <CODE>null</CODE> if it cannot yet be determined. 155 */ 156 public DN getDN() 157 { 158 if (dn == null) 159 { 160 RDN rdn; 161 AttributeType[] rdnAttrs = template.getRDNAttributes(); 162 if (rdnAttrs.length == 1) 163 { 164 AttributeType t = rdnAttrs[0]; 165 TemplateValue v = getValue(t); 166 if (v == null) 167 { 168 return null; 169 } 170 171 AttributeValue value = new AttributeValue(t, v.getValue().toString()); 172 rdn = new RDN(t, value); 173 } 174 else 175 { 176 String[] names = new String[rdnAttrs.length]; 177 AttributeValue[] values = new AttributeValue[rdnAttrs.length]; 178 for (int i=0; i < rdnAttrs.length; i++) 179 { 180 AttributeType t = rdnAttrs[i]; 181 TemplateValue v = getValue(t); 182 if (v == null) 183 { 184 return null; 185 } 186 187 names[i] = t.getPrimaryName(); 188 values[i] = new AttributeValue(t, v.getValue().toString()); 189 } 190 191 rdn = new RDN(rdnAttrs, names, values); 192 } 193 194 dn = parentDN.concat(rdn); 195 } 196 197 return dn; 198 } 199 200 201 202 /** 203 * Indicates whether this entry contains one or more values for the specified 204 * attribute type. 205 * 206 * @param attributeType The attribute type for which to make the 207 * determination. 208 * 209 * @return <CODE>true</CODE> if this entry contains one or more values for 210 * the specified attribute type, or <CODE>false</CODE> if not. 211 */ 212 public boolean hasAttribute(AttributeType attributeType) 213 { 214 return attributes.containsKey(attributeType); 215 } 216 217 218 219 /** 220 * Retrieves the value for the specified attribute, if defined. If the 221 * specified attribute has multiple values, then the first will be returned. 222 * 223 * @param attributeType The attribute type for which to retrieve the value. 224 * 225 * @return The value for the specified attribute, or <CODE>null</CODE> if 226 * there are no values for that attribute type. 227 */ 228 public TemplateValue getValue(AttributeType attributeType) 229 { 230 ArrayList<TemplateValue> valueList = attributes.get(attributeType); 231 if ((valueList == null) || valueList.isEmpty()) 232 { 233 return null; 234 } 235 else 236 { 237 return valueList.get(0); 238 } 239 } 240 241 242 243 /** 244 * Retrieves the set of values for the specified attribute, if defined. 245 * 246 * @param attributeType The attribute type for which to retrieve the set of 247 * values. 248 * 249 * @return The set of values for the specified attribute, or 250 * <CODE>null</CODE> if there are no values for that attribute type. 251 */ 252 public List<TemplateValue> getValues(AttributeType attributeType) 253 { 254 ArrayList<TemplateValue> valueList = attributes.get(attributeType); 255 return valueList; 256 } 257 258 259 260 /** 261 * Adds the provided template value to this entry. 262 * 263 * @param value The value to add to this entry. 264 */ 265 public void addValue(TemplateValue value) 266 { 267 ArrayList<TemplateValue> valueList = 268 attributes.get(value.getAttributeType()); 269 if (valueList == null) 270 { 271 valueList = new ArrayList<TemplateValue>(); 272 valueList.add(value); 273 attributes.put(value.getAttributeType(), valueList); 274 } 275 else 276 { 277 valueList.add(value); 278 } 279 } 280 281 282 283 /** 284 * Retrieves this template entry as an <CODE>Entry</CODE> object. 285 * 286 * @return The <CODE>Entry</CODE> object for this template entry. 287 */ 288 public Entry toEntry() 289 { 290 // Process all of the attributes for this entry. 291 LinkedHashMap<ObjectClass,String> objectClasses = 292 new LinkedHashMap<ObjectClass,String>(); 293 LinkedHashMap<AttributeType,List<Attribute>> userAttributes = 294 new LinkedHashMap<AttributeType,List<Attribute>>(); 295 LinkedHashMap<AttributeType,List<Attribute>> operationalAttributes = 296 new LinkedHashMap<AttributeType,List<Attribute>>(); 297 298 for (AttributeType t : attributes.keySet()) 299 { 300 ArrayList<TemplateValue> valueList = attributes.get(t); 301 if (t.isObjectClassType()) 302 { 303 for (TemplateValue v : valueList) 304 { 305 String ocName = toLowerCase(v.getValue().toString()); 306 ObjectClass oc = DirectoryServer.getObjectClass(ocName, true); 307 objectClasses.put(oc, ocName); 308 } 309 } 310 else if (t.isOperational()) 311 { 312 LinkedHashSet<AttributeValue> values = 313 new LinkedHashSet<AttributeValue>(); 314 for (TemplateValue v : valueList) 315 { 316 values.add(new AttributeValue(t, v.getValue().toString())); 317 } 318 319 ArrayList<Attribute> attrList = new ArrayList<Attribute>(1); 320 attrList.add(new Attribute(t, t.getNameOrOID(), values)); 321 operationalAttributes.put(t, attrList); 322 } 323 else 324 { 325 LinkedHashSet<AttributeValue> values = 326 new LinkedHashSet<AttributeValue>(); 327 for (TemplateValue v : valueList) 328 { 329 values.add(new AttributeValue(t, v.getValue().toString())); 330 } 331 332 ArrayList<Attribute> attrList = new ArrayList<Attribute>(1); 333 attrList.add(new Attribute(t, t.getNameOrOID(), values)); 334 userAttributes.put(t, attrList); 335 } 336 } 337 338 return new Entry(getDN(), objectClasses, userAttributes, 339 operationalAttributes); 340 } 341 } 342