• Home
• gov.nasa.pds
• pds3-product-tools
• 4.4.0
• source code
• ObjectStatement.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

gov.nasa.pds.tools.label.ObjectStatement Maven / Gradle / Ivy

// Copyright 2019, California Institute of Technology ("Caltech").
// U.S. Government sponsorship acknowledged.
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions must reproduce the above copyright notice, this list of
// conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
// • Neither the name of Caltech nor its operating division, the Jet Propulsion
// Laboratory, nor the names of its contributors may be used to endorse or
// promote products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

package gov.nasa.pds.tools.label;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;

import gov.nasa.pds.tools.dict.DictIdentifier;
import gov.nasa.pds.tools.dict.parser.DictIDFactory;

/**
 * @author pramirez
 * @author jagander
 * @version $Revision$
 * 
 */
public class ObjectStatement extends Statement {

  private LinkedHashMap> statements;

  /**
   * Constructs a new object statement with no attributes or nested objects
   * 
   * @param lineNumber
   *          Line number of the statement.
   * @param identifier
   *          Identifier for the statement.
   */
  public ObjectStatement(final Label sourceLabel, int lineNumber,
      String identifier) {
    this(sourceLabel, lineNumber, identifier,
        new LinkedHashMap>());
  }

  /**
   * Constructs an ObjectStatement with only an identifier
   * 
   * @param identifier
   *          Identifier of the statement
   */
  public ObjectStatement(final Label sourceLabel, String identifier) {
    this(sourceLabel, -1, identifier);
  }

  /**
   * Constructs an ObjectStatement
   * 
   * @param lineNumber
   *          Line number of statement
   * @param identifier
   *          Identifier of statement
   * @param statements
   *          Map of {@link Statement} associated with this object
   */
  public ObjectStatement(final Label sourceLabel, int lineNumber,
      String identifier,
      LinkedHashMap> statements) {
    super(sourceLabel, lineNumber, DictIDFactory.createObjectDefId(identifier));
    this.statements = statements;
  }

  private List getElements(final DictIdentifier key) {
    List returnStatements = this.statements.get(key);
    if (returnStatements == null) {
      returnStatements = new ArrayList();
    }
    return returnStatements;
  }

  private List getElements(final Class classType) {
    final List returnStatements = new ArrayList();
    for (List stmts : this.statements.values()) {
      for (Statement statement : stmts) {
        if (statement.getClass().equals(classType)) {
          returnStatements.add(statement);
        }
      }
    }
    return returnStatements;
  }

  /**
   * Retrieves the list of attributes associated with the ObjectStatement
   * 
   * @return The list of AttributeStatement
   */
  @SuppressWarnings("unchecked")
  public List getAttributes() {
    return (List) getElements(AttributeStatement.class);
  }

  /**
   * Retrieves pointers associated with this object
   * 
   * @return list of {@link PointerStatement}
   */
  public List getPointers() {
    List returnPointers = new ArrayList();
    for (List stmts : this.statements.values()) {
      for (Statement statement : stmts) {
        if (statement instanceof PointerStatement) {
          returnPointers.add((PointerStatement) statement);
        }
      }
    }
    return returnPointers;
  }

  /**
   * Retrieves groups associated with this object
   * 
   * @return list of {@link GroupStatement}
   */
  @SuppressWarnings("unchecked")
  public List getGroups() {
    return (List) getElements(GroupStatement.class);
  }

  /**
   * Looks to see if this object contains a pointer with the given identifier
   * 
   * @param id
   *          of pointer statement to look for
   * @return flag indicating whether or not the pointer was found
   */
  public boolean hasPointer(DictIdentifier id) {
    validatePointerType(id);
    return this.statements.get(id) != null;
  }

  /**
   * Retrieves the named attribute
   * 
   * @param id
   * @return The named AttributeStatement or null if not found
   */
  @SuppressWarnings("unchecked")
  public AttributeStatement getAttribute(DictIdentifier id) {
    validateElementType(id);
    List attribs = (List) getElements(
        id);
    if (attribs.size() > 0) {
      return attribs.get(0);
    }
    return null;
  }

  /**
   * Retrieves the named pointer
   * 
   * @param id
   * @return The named PointerStatement or null if not found
   */
  @SuppressWarnings("unchecked")
  public PointerStatement getPointer(DictIdentifier id) {
    validatePointerType(id);
    List pointers = (List) getElements(id);
    if (pointers.size() > 0) {
      return pointers.get(0);
    }
    return null;
  }

  // convenience method - to be used sparingly
  public AttributeStatement getAttribute(String id) {
    return getAttribute(DictIDFactory.createElementDefId(id));
  }

  /**
   * Retrieves the list of objects associated with this object
   * 
   * @return The list of ObjectStatement
   */
  @SuppressWarnings("unchecked")
  public List getObjects() {
    return (List) getElements(ObjectStatement.class);
  }

  /**
   * Retrieves the named object
   * 
   * @param id
   * @return The {@link List} of named objects
   */
  @SuppressWarnings("unchecked")
  public List getObjects(DictIdentifier id) {
    validateObjectType(id);
    return (List) getElements(id);
  }

  // convenience method, use sparingly
  @SuppressWarnings("unchecked")
  public List getObjects(String id) {
    return (List) getElements(
        DictIDFactory.createObjectDefId(id));
  }

  /**
   * Retrieves the named group
   * 
   * @param id
   *          of the group
   * @return the {@link List} of named groups
   */
  @SuppressWarnings("unchecked")
  public List getGroups(DictIdentifier id) {
    validateGroupType(id);
    return (List) getElements(id);
  }

  // convenience method, use sparingly
  @SuppressWarnings("unchecked")
  public List getGroups(String id) {
    return (List) getElements(
        DictIDFactory.createGroupDefId(id));
  }

  /**
   * Associates a statement with this object
   * 
   * @param statement
   *          to be added to object
   */
  public void addStatement(Statement statement) {
    DictIdentifier id = statement.getIdentifier();
    List stmnts = this.statements.get(id);
    if (stmnts == null) {
      stmnts = new ArrayList();
      this.statements.put(id, stmnts);
    }
    if (statement instanceof IncludePointer) {
      stmnts.add(statement);
      for (Statement stmt : ((IncludePointer) statement).getStatements()) {
        addStatement(stmt);
      }
    } else {
      stmnts.add(statement);
    }
  }

  public boolean hasAttribute(DictIdentifier id) {
    validateElementType(id);
    return (getAttribute(id) == null) ? false : true;
  }

  public boolean hasObject(DictIdentifier id) {
    validateObjectType(id);
    return (getObjects(id).size() == 0) ? false : true;
  }

  public boolean hasGroup(DictIdentifier id) {
    validateGroupType(id);
    return (getGroups(id).size() == 0) ? false : true;
  }

  public List getStatements() {
    List results = new ArrayList();
    for (List stmts : this.statements.values()) {
      results.addAll(stmts);
    }
    return results;
  }

  public boolean equals(Object object) {
    if (this == object) {
      return true;
    }
    if ((object == null) || (object.getClass() != this.getClass())) {
      return false;
    }
    ObjectStatement thatObject = (ObjectStatement) object;
    List thoseAttributes = thatObject.getAttributes();
    for (AttributeStatement thisAttribute : getAttributes()) {
      AttributeStatement thatAttribute = thatObject
          .getAttribute(thisAttribute.getIdentifier());
      if (thatAttribute == null) {
        return false;
      } else {
        if (!thisAttribute.equals(thatAttribute)) {
          return false;
        } else {
          thoseAttributes.remove(thatAttribute);
        }
      }
    }
    if (!thoseAttributes.isEmpty()) {
      return false;
    }
    List thosePointers = thatObject.getPointers();
    for (PointerStatement thisPointer : getPointers()) {
      boolean foundMatch = false;
      for (PointerStatement thatPointer : thosePointers) {
        if ((foundMatch = thisPointer.equals(thatPointer))) {
          thosePointers.remove(thatPointer);
          break;
        }
      }
      if (foundMatch == false) {
        return false;
      }
    }
    // Check if the object passed in has any left over pointers
    if (!thosePointers.isEmpty()) {
      return false;
    }
    List thoseObjects = thatObject.getObjects();
    for (ObjectStatement thisObject : getObjects()) {
      boolean foundMatch = false;
      for (ObjectStatement o : thoseObjects) {
        if ((foundMatch = thisObject.equals(o))) {
          thoseObjects.remove(o);
          break;
        }
      }
      if (foundMatch == false) {
        return false;
      }
    }
    if (!thoseObjects.isEmpty()) {
      return false;
    }
    List thoseGroups = thatObject.getGroups();
    for (GroupStatement thisGroup : getGroups()) {
      boolean foundMatch = false;
      for (GroupStatement thatGroup : thoseGroups) {
        if ((foundMatch = thisGroup.equals(thatGroup))) {
          thoseGroups.remove(thatGroup);
          break;
        }
      }
      if (foundMatch == false) {
        return false;
      }
    }
    if (!thoseGroups.isEmpty()) {
      return false;
    }
    return true;
  }

  public int hashcode() {
    int hash = 7;

    hash = 31 * hash
        + (null == getAttributes() ? 0 : getAttributes().hashCode());
    hash = 31 * hash + (null == getPointers() ? 0 : getPointers().hashCode());
    hash = 31 * hash + (null == getObjects() ? 0 : getObjects().hashCode());
    hash = 31 * hash + (null == getGroups() ? 0 : getGroups().hashCode());

    return hash;
  }

}