SecApiReqTypeDef.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: SecApiReqTypeDef.java
 * Description: Auxiliary class for creating of requested type definition 
 *              for SEC API
 */

package cz.vutbr.fit.knot.annotations.modules.suggestionManager;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

/**
 * Class for creating of requested type definition for SEC API
 * 
 * @brief Class for creating of requested type definition for SEC API
 */
public class SecApiReqTypeDef implements Cloneable {
  /** Name of suggestion type */
  private String typeName = null;
  /** Available attributes (what we can request) */
  private ArrayList<String> availableAttributes = null;
  /** Attributes which will be requested */
  private ArrayList<String> requestedAttributes = null;
  /** Priorities of attributes */
  private HashMap<String,Integer> priorities = null;
  /** Definition of alternative description */
  private String altDescDef = null;
  
  /**
   * Constructor
   *
   * @param name Type name
   */
  public SecApiReqTypeDef(String name) {
    typeName = name;
    availableAttributes = new ArrayList<String>();
    requestedAttributes = null;
    priorities = new HashMap<String, Integer>();
  }

  
  
  /**
   * Gets part of request with given type, for example: 
   * "visual_artist": ["full_name", "wikipedia_url"]
   * 
   * @return Returns part of request with given type
   */
  public String getRequestString() {
    StringBuilder result = new StringBuilder("\"" + typeName + "\": [");
    
    if (requestedAttributes != null) {
      Iterator<String> atIt = requestedAttributes.iterator();
      if (atIt.hasNext()) {  // first attribute
        String at = atIt.next();
        result.append("\"").append(at).append("\"");
      }
      while (atIt.hasNext()) {
        String at = atIt.next();
        result.append(", \"").append(at).append("\"");
      }
    } else {
      Iterator<String> atIt = availableAttributes.iterator();
      if (atIt.hasNext()) {  // first attribute
        String at = atIt.next();
        result.append("\"").append(at).append("\"");
      }
      while (atIt.hasNext()) {
        String at = atIt.next();
        result.append(", \"").append(at).append("\"");
      }
    }
    
    result.append("]");
    return result.toString();
  }  // getRequestString()
  
  /**
   * Gets part of request with given type, for example: 
   * "visual_artist": ["full_name", "wikipedia_url"]
   * 
   * @param filterAtt List of attributes which should be selected 
   * @return Returns part of request with given type
   */
  public String getRequestString(ArrayList<String> filterAtt) {
    StringBuilder result = new StringBuilder("\"" + typeName + "\": [");
    
    Iterator<String> atIt = availableAttributes.iterator();
    boolean firstFound = false;
    while (atIt.hasNext() && !firstFound) {  // first attribute
      String at = atIt.next();
      if (filterAtt.contains(at)) {
        result.append("\"").append(at).append("\"");
        firstFound = true;
      }
    }
    while (atIt.hasNext()) {
      String at = atIt.next();
      if (filterAtt.contains(at)) {
        result.append(", \"").append(at).append("\"");
      }
    }
    
    result.append("]");
    return result.toString();
  }  // getRequestString()
  
  /**
   * Prepares list of requested attributes
   * 
   * If desired attributes are available, they will be used. If they are not 
   * available, unnecessary attributes will be sorted out.
   * 
   * @param desiredAttributes Desired attributes (what do we want) 
   * @param unnecessaryAttributes Unnecessary attributes (what we do not want)
   */
  public void filterAttributes(ArrayList<String> desiredAttributes, ArrayList<String> unnecessaryAttributes) {
    if (desiredAttributes == null && availableAttributes == null) {
      requestedAttributes = new ArrayList<String>();
      return;
    }    
    if ((desiredAttributes == null || desiredAttributes.isEmpty()) && availableAttributes != null) {
      if (unnecessaryAttributes != null && !unnecessaryAttributes.isEmpty()) {
        requestedAttributes = new ArrayList<String>();
        Iterator<String> avIt = availableAttributes.iterator();
        while (avIt.hasNext()) {
          String a = avIt.next();
          if (!unnecessaryAttributes.contains(a)) {
            requestedAttributes.add(a);
          }
        }
      } else {
        requestedAttributes = new ArrayList<String>(availableAttributes);
      }
      return;
    }

    requestedAttributes = new ArrayList<String>();
    Iterator<String> desIt = desiredAttributes.iterator();
    while (desIt.hasNext()) {
      String d = desIt.next();
      if (availableAttributes.contains(d)) {
        requestedAttributes.add(d);
      }
    }
  }  // filterAttributes()

  /**
   * Prepares list of requested type definitions
   * 
   * If desired attributes are available, they will be used. If they are not 
   * available, unnecessary attributes will be sorted out.
   */
  public static void filterTypes() {
    ArrayList<SecApiReqTypeDef> availableTypes = AppBean.getAvTypeDefinitions();
    
    ArrayList<SecApiReqTypeDef> desiredTypes = AppBean.getDesTypeDefinitions();
    ArrayList<SecApiReqTypeDef> unnecessaryTypes = AppBean.getUnTypeDefinitions();
    ArrayList<SecApiReqTypeDef> unnecessaryAts = AppBean.getUnAtDefinitions();
    ArrayList<SecApiReqTypeDef> requestedTypes = new ArrayList<SecApiReqTypeDef>();
    
    ArrayList<SecApiReqTypeDef> desiredTypesEA = AppBean.getDesTypeDefinitionsEA();
    ArrayList<SecApiReqTypeDef> unnecessaryTypesEA = AppBean.getUnTypeDefinitionsEA();
    ArrayList<SecApiReqTypeDef> unnecessaryAtsEA = AppBean.getUnAtDefinitionsEA();
    ArrayList<SecApiReqTypeDef> requestedTypesEA = new ArrayList<SecApiReqTypeDef>();
    
    if (availableTypes == null) {
      AppBean.setReqTypeDefinitions(requestedTypes);
      AppBean.setReqTypeDefinitionsEA(requestedTypesEA);
      return;
    }
    
    if ((desiredTypes == null || desiredTypes.isEmpty())) {
      if (unnecessaryTypes != null && !unnecessaryTypes.isEmpty()) {
        if (unnecessaryAts == null) {  // effectively fix NullPointerException
          unnecessaryAts = new ArrayList<SecApiReqTypeDef>();
        }
        Iterator<SecApiReqTypeDef> avIt = availableTypes.iterator();
        while (avIt.hasNext()) {
          SecApiReqTypeDef a = avIt.next();
          if (!unnecessaryTypes.contains(a)) {
            SecApiReqTypeDef ca = a.clone();
            requestedTypes.add(ca);
            boolean uFound = false;
            Iterator<SecApiReqTypeDef> unIt = unnecessaryAts.iterator();
            while (unIt.hasNext() && !uFound) {
              SecApiReqTypeDef u = unIt.next();
              if (u.getTypeName().contentEquals(a.getTypeName())) {
                uFound = true;
                // sort out unnecessary attributes and initialise list of requested attributes
                ca.filterAttributes(null, u.getAvailableAttributes());
              }
            }
            if (!uFound) {
              ca.filterAttributes(null, null);  // initialise list of requested attributes
            }
          }
        }
      } else {
        requestedTypes = new ArrayList<SecApiReqTypeDef>();
        Iterator<SecApiReqTypeDef> avIt = availableTypes.iterator();
        while (avIt.hasNext()) {
          SecApiReqTypeDef a = avIt.next();
          SecApiReqTypeDef ca = a.clone();
          ca.filterAttributes(null, null);
          requestedTypes.add(ca);
        }
        
      }
    } else {
      Iterator<SecApiReqTypeDef> desIt = desiredTypes.iterator();
      while (desIt.hasNext()) {
        SecApiReqTypeDef d = desIt.next();
        Iterator<SecApiReqTypeDef> avIt = availableTypes.iterator();
        while (avIt.hasNext()) {
          SecApiReqTypeDef a = avIt.next();
          if (a.getTypeName().contentEquals(d.getTypeName())) {
            SecApiReqTypeDef ca = a.clone();
            requestedTypes.add(ca);
            ca.filterAttributes(d.getAvailableAttributes(), null);  // flter attributes
            break;
          }
        }
      }
    }
    
    if ((desiredTypesEA == null || desiredTypesEA.isEmpty())) {
      if (unnecessaryTypesEA != null && !unnecessaryTypesEA.isEmpty()) {
        if (unnecessaryAtsEA == null) {  // effectively fix NullPointerException
          unnecessaryAtsEA = new ArrayList<SecApiReqTypeDef>();
        }
        Iterator<SecApiReqTypeDef> avIt = availableTypes.iterator();
        while (avIt.hasNext()) {
          SecApiReqTypeDef a = avIt.next();
          if (!unnecessaryTypesEA.contains(a)) {
            SecApiReqTypeDef ca = a.clone();
            requestedTypesEA.add(ca);
            boolean uFound = false;
            Iterator<SecApiReqTypeDef> unIt = unnecessaryAtsEA.iterator();
            while (unIt.hasNext() && !uFound) {
              SecApiReqTypeDef u = unIt.next();
              if (u.getTypeName().contentEquals(a.getTypeName())) {
                uFound = true;
                // sort out unnecessary attributes and initialise list of requested attributes
                ca.filterAttributes(null, u.getAvailableAttributes());
              }
            }
            if (!uFound) {
              ca.filterAttributes(null, null);  // initialise list of requested attributes
            }
          }
        }
      } else {
        requestedTypesEA = new ArrayList<SecApiReqTypeDef>();
        Iterator<SecApiReqTypeDef> avIt = availableTypes.iterator();
        while (avIt.hasNext()) {
          SecApiReqTypeDef a = avIt.next();
          SecApiReqTypeDef ca = a.clone();
          ca.filterAttributes(null, null);
        }
        
      }
    } else {
      Iterator<SecApiReqTypeDef> desIt = desiredTypesEA.iterator();
      while (desIt.hasNext()) {
        SecApiReqTypeDef d = desIt.next();
        Iterator<SecApiReqTypeDef> avIt = availableTypes.iterator();
        while (avIt.hasNext()) {
          SecApiReqTypeDef a = avIt.next();
          if (a.getTypeName().contentEquals(d.getTypeName())) {
            SecApiReqTypeDef ca = a.clone();
            requestedTypesEA.add(ca);
            ca.filterAttributes(d.getAvailableAttributes(), null);  // flter attributes
            break;
          }
        }
      }
    }
    
    AppBean.setReqTypeDefinitions(requestedTypes);
    AppBean.setReqTypeDefinitionsEA(requestedTypesEA);
  }  // filterTypes()
  
  /**
   * Gets available attributes
   * 
   * @return Returns available attributes
   */
  public ArrayList<String> getAvailableAttributes() {
    return availableAttributes;
  }

  /**
   * Sets available attributes
   * 
   * @param availableAttributes Available attributes
   */
  public void setAvailableAttributes(ArrayList<String> availableAttributes) {
    this.availableAttributes = availableAttributes;
  }
  
  /**
   * Adds available attribute
   * 
   * @param availableAttribute Available attribute
   */
  public void addAvailableAttribute(String availableAttribute) {
    this.availableAttributes.add(availableAttribute);
  }

  /**
   * Gets type name
   * 
   * @return Returns type name
   */
  public String getTypeName() {
    return typeName;
  }

  /**
   * Sets type name
   * 
   * @param typeName Type name
   */
  public void setTypeName(String typeName) {
    this.typeName = typeName;
  }

  /**
   * Gets map with attribute priorities
   * 
   * @return Returns map with attribute priorities
   */
  public HashMap<String, Integer> getPriorities() {
    return priorities;
  }

  /**
   * Sets map with attribute priorities
   * 
   * @param priorities Map with attribute priorities
   */
  public void setPriorities(HashMap<String, Integer> priorities) {
    this.priorities = priorities;
  }
  
  /**
   * Gets priority for given attribute
   * 
   * @param name Name of attribute
   * @return Returns priority of attribute with given name
   */
  public Integer getPriority(String name) {
    return priorities.get(name);
  }
  
  /**
   * Sets priority for given attribute
   * 
   * @param name Name of attribute
   * @param priority Priority of attribute
   */
  public void setPriority(String name, Integer priority) {
    priorities.put(name, priority);
  }

  /**
   * Sets entity type description
   *
   * @param desc Description of entity type
   */
  public void setAltDescDef(String desc){
    this.altDescDef = desc;
  }

  /**
   * Return entity type description
   *
   * @return Returns description of entity type
   */
  public String getAltDescDef(){
    return altDescDef;
  }

  /**
   * Clones object (creates deep copy)
   * 
   * @return Returns clone (deep copy) of the object
   */
  @Override
  public SecApiReqTypeDef clone() {
    SecApiReqTypeDef result = new SecApiReqTypeDef(this.typeName);
    if (this.availableAttributes != null) {
      result.setAvailableAttributes(new ArrayList<String>(this.availableAttributes));
    }
    if (this.requestedAttributes != null) {
      result.setRequestedAttributes(new ArrayList<String>(this.requestedAttributes));
    }
    if (this.priorities != null) {
      result.setPriorities(new HashMap<String, Integer>(this.priorities));
    }
    result.setAltDescDef(this.altDescDef);
  
    return result;
  }

  /**
   * Gets requested attributes
   * 
   * @return Returns requested attributes
   */
  public ArrayList<String> getRequestedAttributes() {
    return requestedAttributes;
  }

  /**
   * Sets requested attributes
   * 
   * @param requestedAttributes Requested attributes
   */
  public void setRequestedAttributes(ArrayList<String> requestedAttributes) {
    this.requestedAttributes = requestedAttributes;
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same type name.
   *
   * @param obj Object to compare with
   * @return If object is same type and have same type name, returns true, false otherwise
   */
  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final SecApiReqTypeDef other = (SecApiReqTypeDef) obj;
    if ((this.typeName == null) ? (other.typeName != null) : !this.typeName.equals(other.typeName)) {
      return false;
    }
    return true;
  }

  @Override
  public int hashCode() {
    int hash = 5;
    hash = 67 * hash + (this.typeName != null ? this.typeName.hashCode() : 0);
    return hash;
  }
  
}  // class SecApiReqTypeDef()