annis.ql.parser.LogicClause.java Source code

Introduction

Here is the source code for annis.ql.parser.LogicClause.java

Source

/*
 * Copyright 2013 SFB 632.
 *
 * Licensed 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 annis.ql.parser;

import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.antlr.v4.runtime.Token;

/**
 *
 * @author Thomas Krause <krauseto@hu-berlin.de>
 */
public class LogicClause {
    public enum Operator {
        AND, OR, LEAF;

        @Override
        public String toString() {
            return super.toString();
        }
    }

    private Operator op;
    private List<LogicClause> children;
    private List<? extends Token> content;
    private LogicClause parent;

    /**
     * Default constructor. Will create a LogicClause which is a leaf and has
     * no content 
     */
    public LogicClause() {
        this.op = Operator.LEAF;
        this.children = new ArrayList<>();
        this.content = null;
        this.parent = null;
    }

    public LogicClause(Operator op) {
        this();
        this.op = op;
    }

    /**
     * Copy constructor
     * @param other 
     */
    public LogicClause(LogicClause other) {
        this();
        this.op = other.op;
        this.parent = other.parent;
        this.content = new ArrayList<>(other.content);
        this.children.addAll(other.children);
    }

    public Operator getOp() {
        return op;
    }

    public void setOp(Operator op) {
        this.op = op;
    }

    public ImmutableList<LogicClause> getChildren() {
        return ImmutableList.copyOf(children);
    }

    public void addAllChildren(Collection<LogicClause> children) {
        if (children != null) {
            for (LogicClause c : children) {
                addChild(c);
            }
        }
    }

    public void addChild(LogicClause child) {
        Preconditions.checkArgument(child != this, "Cannot add itself as children");
        child.parent = this;
        children.add(child);
    }

    public void addChild(int idx, LogicClause child) {
        Preconditions.checkArgument(child != this, "Cannot add itself as children");
        child.parent = this;
        children.add(idx, child);
    }

    public LogicClause removeChild(int idx) {
        LogicClause result = children.remove(idx);
        if (result != null && result.parent == this) {
            result.parent = null;
        }
        return result;
    }

    public void clearChildren() {
        for (LogicClause c : children) {
            if (c.parent == this) {
                c.parent = null;
            }
        }
        children.clear();
    }

    public List<? extends Token> getContent() {
        return content;
    }

    public void setContent(List<? extends Token> content) {
        this.content = content;
    }

    public List<Token> getCoveredToken() {
        List<Token> result = new LinkedList<>();

        if (content != null && !content.isEmpty() && (op == Operator.AND || op == Operator.OR)) {
            // add children and put our own operator between them

            Iterator<LogicClause> itChild = children.iterator();
            while (itChild.hasNext()) {
                result.addAll(itChild.next().getCoveredToken());
                if (itChild.hasNext()) {
                    result.addAll(content);
                }
            }
        } else if (op == Operator.LEAF && content != null) {
            result.addAll(content);
        } else {
            // fallback: this node has no own token but it's children might have
            for (LogicClause child : children) {
                result.addAll(child.getCoveredToken());
            }
        }

        return result;
    }

    public LogicClause getParent() {
        return parent;
    }

    @Override
    public String toString() {
        if (op == Operator.AND) {
            return "(" + Joiner.on(" & ").join(children) + ")";
        } else if (op == Operator.OR) {
            return "(" + Joiner.on(" \n| \n").join(children) + ")";
        }

        LinkedList<String> texts = new LinkedList<>();
        if (content != null) {
            for (Token t : content) {
                texts.add(t.getText());
            }
        }
        return Joiner.on(" ").join(texts);
    }

}