Java Code Examples for com.google.common.base.Objects#equal()

protected JvmOperation findOperation(final String name, final boolean mustBeArray) {
  final JvmOperation result = this.findOperation(name);
  JvmTypeReference _returnType = result.getReturnType();
  JvmType _type = null;
  if (_returnType!=null) {
    _type=_returnType.getType();
  }
  final JvmType returnType = _type;
  boolean _and = false;
  if (!mustBeArray) {
    _and = false;
  } else {
    EClass _eClass = null;
    if (returnType!=null) {
      _eClass=returnType.eClass();
    }
    boolean _notEquals = (!Objects.equal(_eClass, TypesPackage.Literals.JVM_ARRAY_TYPE));
    _and = _notEquals;
  }
  if (_and) {
    throw new IllegalArgumentException("Cannot assign array value to simple annotation property");
  }
  return result;
}
 

@Override
public boolean equals(Object o)
{
    if (this == o) {
        return true;
    }
    if (o == null || getClass() != o.getClass()) {
        return false;
    }

    GetSplitsRequest that = (GetSplitsRequest) o;

    Objects.equal(this.tableName, that.tableName);
    Objects.equal(this.partitions, that.partitions);
    CollectionsUtils.equals(this.partitionCols, that.partitionCols);
    Objects.equal(this.continuationToken, that.continuationToken);
    Objects.equal(this.getRequestType(), that.getRequestType());
    Objects.equal(this.getCatalogName(), that.getCatalogName());

    return Objects.equal(this.tableName, that.tableName) &&
            Objects.equal(this.partitions, that.partitions) &&
            CollectionsUtils.equals(this.partitionCols, that.partitionCols) &&
            Objects.equal(this.continuationToken, that.continuationToken) &&
            Objects.equal(this.getRequestType(), that.getRequestType()) &&
            Objects.equal(this.getCatalogName(), that.getCatalogName());
}
 

@Override
public boolean equals(Object other) {
  if (this == other) {
    return true;
  }

  if (!(other instanceof AspectKey)) {
    return false;
  }

  AspectKey that = (AspectKey) other;
  return Objects.equal(baseKeys, that.baseKeys)
      && Objects.equal(aspectConfigurationKey, that.aspectConfigurationKey)
      && Objects.equal(baseConfiguredTargetKey, that.baseConfiguredTargetKey)
      && Objects.equal(aspectDescriptor, that.aspectDescriptor);
}
 

@Override
public boolean equals(final Object other) {
  // use class identity since we don't allow capability inheritance beyond this to its direct children.
  if (!(other.getClass().equals(this.getClass()))) {
    return false;
  }
  Capability<?> castOther = (Capability<?>) other;
  return Objects.equal(name, castOther.name) && Objects.equal(defaultValue, castOther.defaultValue)
      && Objects.equal(usedInExecution, castOther.usedInExecution);
}
 

@Override
public boolean equals(Object object) {
    if (this == object) {
        return true;
    }
    if (object instanceof TeNodeEventSubject) {
        TeNodeEventSubject that = (TeNodeEventSubject) object;
        return Objects.equal(key, that.key) &&
                Objects.equal(teNode, that.teNode);
    }
    return false;
}
 

protected List<ILeafNode> findPreviousHiddenLeafs(final INode node) {
  List<ILeafNode> _xblockexpression = null;
  {
    INode current = node;
    while ((current instanceof ICompositeNode)) {
      current = ((ICompositeNode)current).getLastChild();
    }
    final ArrayList<ILeafNode> result = CollectionLiterals.<ILeafNode>newArrayList();
    if ((current != null)) {
      final NodeIterator ni = new NodeIterator(current);
      while (ni.hasPrevious()) {
        {
          final INode previous = ni.previous();
          if (((!Objects.equal(previous, current)) && (previous instanceof ILeafNode))) {
            boolean _isHidden = ((ILeafNode) previous).isHidden();
            if (_isHidden) {
              result.add(((ILeafNode) previous));
            } else {
              return ListExtensions.<ILeafNode>reverse(result);
            }
          }
        }
      }
    }
    _xblockexpression = ListExtensions.<ILeafNode>reverse(result);
  }
  return _xblockexpression;
}
 

@Override
public boolean equals(Object o) {
    if (o instanceof Configuration) {
        Configuration that = (Configuration) o;
        return Objects.equal(endpoint, that.endpoint) &&
            Objects.equal(identity, that.identity) &&
            Objects.equal(region, that.region) &&
            Objects.equal(credentials, that.credentials);
    }
    return false;
}
 

/**
 * A sensible, albeit inefficient, definition of {@link #remove} in terms of
 * the {@code iterator} method of {@link #entrySet}. If you override {@link
 * #entrySet}, you may wish to override {@link #remove} to forward to this
 * implementation.
 *
 * <p>Alternately, you may wish to override {@link #remove} with {@code
 * keySet().remove}, assuming that approach would not lead to an infinite
 * loop.
 *
 * @since 7.0
 */

@Beta
protected V standardRemove(@Nullable Object key) {
  Iterator<Entry<K, V>> entryIterator = entrySet().iterator();
  while (entryIterator.hasNext()) {
    Entry<K, V> entry = entryIterator.next();
    if (Objects.equal(entry.getKey(), key)) {
      V value = entry.getValue();
      entryIterator.remove();
      return value;
    }
  }
  return null;
}
 

@Override
protected boolean equalsAs(PossibleAction pa, boolean asOption) {
    // identity always true
    if (pa == this) return true;
    //  super checks both class identity and super class attributes
    if (!super.equalsAs(pa, asOption)) return false;

    // check asOption attributes
    ExchangeTokens action = (ExchangeTokens)pa;
    return Objects.equal(this.tokensToExchange, action.tokensToExchange)
            && Objects.equal(this.minNumberToExchange, action.minNumberToExchange)
            && Objects.equal(this.maxNumberToExchange, action.maxNumberToExchange)
    ;
    // no asAction attributes to be checked
}
 

@Override
public boolean equals(Object o) {
  if (this == o) {
    return true;
  }
  if (o == null || getClass() != o.getClass()) {
    return false;
  }
  IncorrectEqualsAndHash foo = (IncorrectEqualsAndHash) o;
  return Objects.equal(name, foo.name);
}
 

@Override
public boolean equals(Object obj) {
  if (!(obj instanceof EdsConfig)) {
    return false;
  }
  EdsConfig that = (EdsConfig) obj;
  return Objects.equal(this.clusterName, that.clusterName)
      && Objects.equal(this.edsServiceName, that.edsServiceName)
      && Objects.equal(this.lrsServerName, that.lrsServerName)
      && Objects.equal(this.endpointPickingPolicy, that.endpointPickingPolicy);
}
 

@Override
@edu.umd.cs.findbugs.annotations.SuppressWarnings(
    value="NP_METHOD_PARAMETER_TIGHTENS_ANNOTATION",
    justification="Default annotation is not correct for equals")
public boolean equals(@Nullable Object o) {
  if (this == o) return true;
  if (o == null || getClass() != o.getClass()) return false;
  ColumnMapping that = (ColumnMapping) o;
  return Objects.equal(fieldMappings, that.fieldMappings);
}
 

@Override
public boolean equals(Object obj) {
  if (obj instanceof ReportQuery) {
    ReportQuery other = (ReportQuery) obj;
    return Objects.equal(this.awqlQuery, other.awqlQuery);
  }
  return false;
}
 

@Override public boolean equals(Object o) {
  if (this == o) return true;
  if (o instanceof CreateGroupRequest) {
    CreateGroupRequest that = (CreateGroupRequest) o;
    if (Objects.equal(this.name, that.name) &&
        Objects.equal(this.description, that.description) &&
        Objects.equal(this.metadata, that.metadata)) {
      return true;
    }
  }
  return false;
}
 

@Override   
public boolean add( Integer selection ) {        
    if( mode == SelectionMode.Single ) {
        if( Objects.equal(selection, lastAdd) && size() == 1 )
            return false; 
        clear();
    }
    lastAdd = selection;
    return super.add(selection);
}
 

/**
 * Indicates whether an object equals this entry, following the behavior
 * specified in {@link Multiset.Entry#equals}.
 */
@Override
public boolean equals(@Nullable Object object) {
  if (object instanceof Multiset.Entry) {
    Multiset.Entry<?> that = (Multiset.Entry<?>) object;
    return this.getCount() == that.getCount()
        && Objects.equal(this.getElement(), that.getElement());
  }
  return false;
}
 

private V put(@Nullable K key, @Nullable V value, boolean force) {
  int keyHash = smearedHash(key);
  int valueHash = smearedHash(value);
  BiEntry<K, V> oldEntryForKey = seekByKey(key, keyHash);
  if (oldEntryForKey != null && valueHash == oldEntryForKey.valueHash
      && Objects.equal(value, oldEntryForKey.value)) {
    return value;
  }
  BiEntry<K, V> oldEntryForValue = seekByValue(value, valueHash);
  if (oldEntryForValue != null) {
    if (force) {
      delete(oldEntryForValue);
    } else {
      throw new IllegalArgumentException("value already present: " + value);
    }
  }
  BiEntry<K, V> newEntry = new BiEntry<K, V>(key, keyHash, value, valueHash);
  if (oldEntryForKey != null) {
    delete(oldEntryForKey);
    insert(newEntry, oldEntryForKey);
    oldEntryForKey.prevInKeyInsertionOrder = null;
    oldEntryForKey.nextInKeyInsertionOrder = null;
    rehashIfNecessary();
    return oldEntryForKey.value;
  } else {
    insert(newEntry, null);
    rehashIfNecessary();
    return null;
  }
}
 

@Override
public boolean equals(Object object) {
    if (this == object) {
        return true;
    }
    if (object instanceof CommonNodeData) {
        CommonNodeData that = (CommonNodeData) object;
        return Objects.equal(name, that.name) &&
                Objects.equal(adminStatus, that.adminStatus) &&
                Objects.equal(opStatus, that.opStatus) &&
                Objects.equal(flags, that.flags);
    }
    return false;
}
 

@Override
public boolean equals(Object o) {
  if (this == o) return true;
  if (!(o instanceof ValidateableAttestation)) return false;
  ValidateableAttestation that = (ValidateableAttestation) o;
  return Objects.equal(getAttestation(), that.getAttestation())
      && Objects.equal(maybeAggregate, that.maybeAggregate);
}
 

@Override public boolean equals(Object obj) {
  return (obj instanceof ConstantProvider)
      && Objects.equal(instance, ((ConstantProvider<?>) obj).instance);
}