org.apache.stanbol.entityhub.core.query.FieldQueryImpl Maven / Gradle / Ivy
/*
* 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.stanbol.entityhub.core.query;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.stanbol.entityhub.servicesapi.query.Constraint;
import org.apache.stanbol.entityhub.servicesapi.query.FieldQuery;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Default implementation of the FieldQuery interface. Note that the getter methods are defined as final. So
* implementations that need to overwrite some functionality need to use the sets provided by this
* implementation to store selected fields and field constraints.
*
* @author Rupert Westenthaler
*
*/
public class FieldQueryImpl implements Cloneable, FieldQuery {
@SuppressWarnings("unused")
private static final Logger log = LoggerFactory.getLogger(FieldQueryImpl.class);
private final Map queryConstraint = new HashMap();
private final Map unmodQueryElements = Collections.unmodifiableMap(queryConstraint);
private final Set selected = new HashSet();
private final Set unmodSelected = Collections.unmodifiableSet(selected);
private Integer limit;
private int offset;
public FieldQueryImpl() {
super();
}
public void addSelectedField(String field) {
if (field != null) {
selected.add(field);
}
}
public void addSelectedFields(Collection fields) {
if (fields != null) {
selected.addAll(fields);
}
}
public void removeSelectedField(String field) {
if (field != null) {
selected.remove(field);
}
}
public void removeSelectedFields(Collection fields) {
if (fields != null) {
selected.removeAll(fields);
}
}
public final Set getSelectedFields() {
return unmodSelected;
}
public void setConstraint(String field, Constraint constraint) {
if (null == field || field.isEmpty()) throw new IllegalArgumentException(
"Parameter Field MUST NOT be NULL nor empty!");
if (constraint == null) {
queryConstraint.remove(field);
} else {
queryConstraint.put(field, constraint);
}
}
/**
* Calls {@link #setConstraint(String, Constraint)} with null as {@link Constraint}. So
* overwrite the setConstraint Method if needed.
*
* @see org.apache.stanbol.entityhub.core.query.FieldConstraint#removeConstraint(java.lang.String)
*/
public final void removeConstraint(String field) {
setConstraint(field, null);
}
/*
* (non-Javadoc)
*
* @see org.apache.stanbol.entityhub.core.query.FieldQuery#isConstraint(java. lang.String)
*/
public final boolean isConstrained(String field) {
return queryConstraint.containsKey(field);
}
/*
* (non-Javadoc)
*
* @see org.apache.stanbol.entityhub.core.query.FieldQuery#getConstraint(java .lang.String)
*/
public final Constraint getConstraint(String field) {
return queryConstraint.get(field);
}
/*
* (non-Javadoc)
*
* @see org.apache.stanbol.entityhub.core.query.FieldQuery#getConstraints()
*/
@Override
public Set> getConstraints() {
return unmodQueryElements.entrySet();
}
@Override
public final Iterator> iterator() {
return unmodQueryElements.entrySet().iterator();
}
@Override
public String toString() {
StringBuilder query = new StringBuilder();
query.append(String.format("Query Constraints (%d)\n", this.queryConstraint.size()));
for (Entry entry : this.queryConstraint.entrySet()) {
query.append(String.format("[key:: %s][%s]\n", entry.getKey(), entry.getValue().toString()));
}
query.append(String.format("unmod Query Elements (%d)\n", this.unmodQueryElements.size()));
for (Entry entry : this.unmodQueryElements.entrySet()) {
query.append(String.format("[key:: %s][%s]\n", entry.getKey(), entry.getValue().toString()));
}
query.append(String.format("Selected (%d)\n", this.selected.size()));
for (String entry : this.selected) {
query.append(String.format("[%s]", entry));
}
query.append(String.format("unmod Selected (%d)\n", this.unmodSelected.size()));
for (String entry : this.unmodSelected) {
query.append(String.format("[%s]", entry));
}
query.append(String.format("[limit :: %d]\n", this.limit));
query.append(String.format("[offset :: %d]\n", this.offset));
return query.toString();
}
@Override
public FieldQuery clone() {
return copyTo(new FieldQueryImpl());
}
/**
* Uses the public API to clone the state of this instance to the instance provided as parameter.
*
* @param
* An implementation of the FieldQuery interface
* @param copyTo
* An instance to copy the state of this on.
* @return The parsed instance
*/
public C copyTo(C copyTo) {
copyTo.removeAllConstraints();
copyTo.removeAllSelectedFields();
for (Entry entry : queryConstraint.entrySet()) {
// we need not to copy keys or values, because everything is
// immutable
copyTo.setConstraint(entry.getKey(), entry.getValue());
}
copyTo.addSelectedFields(selected);
copyTo.setLimit(limit);
copyTo.setOffset(offset);
return copyTo;
}
@Override
public void removeAllConstraints() {
queryConstraint.clear();
}
@Override
public void removeAllSelectedFields() {
selected.clear();
}
@Override
public final String getQueryType() {
return FieldQuery.TYPE;
}
@Override
public final Integer getLimit() {
return limit;
}
@Override
public final int getOffset() {
return offset;
}
@Override
public final void setLimit(Integer limit) {
if (limit != null && limit.intValue() < 1) {
limit = null;
}
this.limit = limit;
}
@Override
public final void setOffset(int offset) {
if (offset < 0) {
offset = 0;
}
this.offset = offset;
}
@Override
public int hashCode() {
return queryConstraint.hashCode() + selected.hashCode() + offset + (limit != null ? limit : 0);
}
@Override
public boolean equals(Object obj) {
if (obj instanceof FieldQuery && ((FieldQuery) obj).getConstraints().equals(getConstraints())
&& ((FieldQuery) obj).getSelectedFields().equals(getSelectedFields())
&& ((FieldQuery) obj).getOffset() == getOffset()) {
if (limit != null) {
return limit.equals(((FieldQuery) obj).getLimit());
} else {
return ((FieldQuery) obj).getLimit() == null;
}
} else {
return false;
}
}
}