| /** |
| * 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.atlas.typesystem.types; |
| |
| import org.apache.atlas.AtlasException; |
| import org.codehaus.jettison.json.JSONException; |
| import org.codehaus.jettison.json.JSONObject; |
| |
| import java.io.IOException; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| |
| public class AttributeInfo { |
| public final String name; |
| public final Multiplicity multiplicity; |
| //A composite is the one whose lifecycle is dependent on the enclosing type and is not just a reference |
| public final boolean isComposite; |
| public final boolean isUnique; |
| public final boolean isIndexable; |
| /** |
| * If this is a reference attribute, then the name of the attribute on the Class |
| * that this refers to. |
| */ |
| public final String reverseAttributeName; |
| private IDataType dataType; |
| |
| public AttributeInfo(TypeSystem t, AttributeDefinition def, Map<String, IDataType> tempTypes) throws AtlasException { |
| this.name = def.name; |
| this.dataType = |
| (tempTypes != null && tempTypes.containsKey(def.dataTypeName)) ? tempTypes.get(def.dataTypeName) : |
| t.getDataType(IDataType.class, def.dataTypeName); |
| this.multiplicity = def.multiplicity; |
| this.isComposite = def.isComposite; |
| this.isUnique = def.isUnique; |
| this.isIndexable = def.isIndexable; |
| this.reverseAttributeName = def.reverseAttributeName; |
| } |
| |
| public IDataType dataType() { |
| return dataType; |
| } |
| |
| void setDataType(IDataType dT) { |
| dataType = dT; |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder buf = new StringBuilder(); |
| try { |
| output(buf, new HashSet<String>()); |
| } catch (AtlasException e) { |
| throw new RuntimeException(e); |
| } |
| return buf.toString(); |
| } |
| |
| public void output(Appendable buf, Set<String> typesInProcess) throws AtlasException { |
| try { |
| buf.append("{name=").append(name); |
| buf.append(", dataType="); |
| dataType.output(buf, typesInProcess); |
| buf.append(", multiplicity=").append(multiplicity.toString()); |
| buf.append(", isComposite=").append(Boolean.toString(isComposite)); |
| buf.append(", isUnique=").append(Boolean.toString(isUnique)); |
| buf.append(", isIndexable=").append(Boolean.toString(isIndexable)); |
| buf.append(", reverseAttributeName=").append(reverseAttributeName); |
| buf.append('}'); |
| } |
| catch(IOException e) { |
| throw new AtlasException(e); |
| } |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) { |
| return true; |
| } |
| if (o == null || getClass() != o.getClass()) { |
| return false; |
| } |
| |
| AttributeInfo that = (AttributeInfo) o; |
| |
| if (isComposite != that.isComposite) { |
| return false; |
| } |
| if (isUnique != that.isUnique) { |
| return false; |
| } |
| if (isIndexable != that.isIndexable) { |
| return false; |
| } |
| if (!dataType.getName().equals(that.dataType.getName())) { |
| return false; |
| } |
| if (!multiplicity.equals(that.multiplicity)) { |
| return false; |
| } |
| if (!name.equals(that.name)) { |
| return false; |
| } |
| if (reverseAttributeName != null ? !reverseAttributeName.equals(that.reverseAttributeName) : |
| that.reverseAttributeName != null) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| public String toJson() throws JSONException { |
| JSONObject json = new JSONObject(); |
| json.put("name", name); |
| json.put("multiplicity", multiplicity.toJson()); |
| json.put("isComposite", isComposite); |
| json.put("isUnique", isUnique); |
| json.put("isIndexable", isIndexable); |
| json.put("dataType", dataType.getName()); |
| json.put("reverseAttributeName", reverseAttributeName); |
| return json.toString(); |
| } |
| |
| public static AttributeDefinition fromJson(String jsonStr) throws JSONException { |
| JSONObject json = new JSONObject(jsonStr); |
| String reverseAttr = null; |
| if (json.has("reverseAttributeName")) { |
| reverseAttr = json.getString("reverseAttributeName"); |
| } |
| return new AttributeDefinition(json.getString("name"), json.getString("dataType"), |
| Multiplicity.fromJson(json.getString("multiplicity")), json.getBoolean("isComposite"), |
| json.getBoolean("isUnique"), json.getBoolean("isIndexable"), reverseAttr); |
| } |
| } |