ixa.kaflib.Opinion Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of kaflib-naf Show documentation
Kaflib-naf is a java library to create and edit NAF documents.
The newest version!
package ixa.kaflib;

import ixa.kaflib.KAFDocument.AnnotationType;
import ixa.kaflib.KAFDocument.Utils;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

/** Class for representing opinions. */
public class Opinion extends IdentifiableAnnotation {

    public static class OpinionHolder extends Annotation {
	private String type;
	private Span span;

	OpinionHolder(Span span) {
	    this.span = span;
	}

	OpinionHolder(OpinionHolder oh, HashMap terms) {
	    /* Copy span */
	    Span span = oh.span;
	    List targets = span.getTargets();
	    List copiedTargets = new ArrayList();
	    for (Term term : targets) {
		Term copiedTerm = terms.get(term.getId());
		if (copiedTerm == null) {
		    throw new IllegalStateException(
			    "Term not found when copying opinion_holder");
		}
		copiedTargets.add(copiedTerm);
	    }
	    if (span.hasHead()) {
		Term copiedHead = terms.get(span.getHead().getId());
		this.span = new Span(copiedTargets, copiedHead);
	    } else {
		this.span = new Span(copiedTargets);
	    }
	}

	public boolean hasType() {
	    return type != null;
	}

	public String getType() {
	    return type;
	}

	public void setType(String type) {
	    this.type = type;
	}

	public List getTerms() {
	    return this.span.getTargets();
	}

	public void addTerm(Term term) {
	    this.span.addTarget(term);
	}

	public void addTerm(Term term, boolean isHead) {
	    this.span.addTarget(term, isHead);
	}

	public Span getSpan() {
	    return this.span;
	}

	public void setSpan(Span span) {
	    this.span = span;
	}

	Map> getReferencedAnnotations() {
	    Map> referenced = new HashMap>();
	    referenced.put(AnnotationType.TERM,
		    (List) (List) this.getSpan().getTargets());
	    return referenced;
	}
	
	/*
	@Override
	public boolean equals(Object o) {
	    if (this == o) return true;
	    if (!(o instanceof OpinionHolder)) return false;
	    OpinionHolder ann = (OpinionHolder) o;
	    return Utils.areEquals(this.type, ann.type) &&
		    Utils.areEquals(this.span, ann.span);
	}
	*/
    }

    public static class OpinionTarget extends Annotation {
	private Span span;

	OpinionTarget(Span span) {
	    this.span = span;
	}

	OpinionTarget(OpinionTarget ot, HashMap terms) {
	    /* Copy span */
	    Span span = ot.span;
	    List targets = span.getTargets();
	    List copiedTargets = new ArrayList();
	    for (Term term : targets) {
		Term copiedTerm = terms.get(term.getId());
		if (copiedTerm == null) {
		    throw new IllegalStateException(
			    "Term not found when copying opinion_target");
		}
		copiedTargets.add(copiedTerm);
	    }
	    if (span.hasHead()) {
		Term copiedHead = terms.get(span.getHead().getId());
		this.span = new Span(copiedTargets, copiedHead);
	    } else {
		this.span = new Span(copiedTargets);
	    }
	}

	public List getTerms() {
	    return this.span.getTargets();
	}

	public void addTerm(Term term) {
	    this.span.addTarget(term);
	}

	public void addTerm(Term term, boolean isHead) {
	    this.span.addTarget(term, isHead);
	}

	public Span getSpan() {
	    return this.span;
	}

	public void setSpan(Span span) {
	    this.span = span;
	}

	Map> getReferencedAnnotations() {
	    Map> referenced = new HashMap>();
	    referenced.put(AnnotationType.TERM,
		    (List) (List) this.getSpan().getTargets());
	    return referenced;
	}
	
	/*
	@Override
	public boolean equals(Object o) {
	    if (this == o) return true;
	    if (!(o instanceof OpinionTarget)) return false;
	    OpinionTarget ann = (OpinionTarget) o;
	    return Utils.areEquals(this.span, ann.span);
	}
	*/
    }

    public static class OpinionExpression extends Annotation {

	/* Polarity (optional) */
	private String polarity;

	/* Strength (optional) */
	private String strength;

	/* Subjectivity (optional) */
	private String subjectivity;

	/* Sentiment semantic type (optional) */
	private String sentimentSemanticType;

	/* Sentiment product feature (optional) */
	private String sentimentProductFeature;

	private Span span;

	OpinionExpression(Span span) {
	    this.span = span;
	}

	OpinionExpression(OpinionExpression oe, HashMap terms) {
	    this.polarity = oe.polarity;
	    this.strength = oe.strength;
	    this.subjectivity = oe.subjectivity;
	    this.sentimentSemanticType = oe.sentimentSemanticType;
	    this.sentimentProductFeature = oe.sentimentProductFeature;
	    /* Copy span */
	    Span span = oe.span;
	    List targets = span.getTargets();
	    List copiedTargets = new ArrayList();
	    for (Term term : targets) {
		Term copiedTerm = terms.get(term.getId());
		if (copiedTerm == null) {
		    throw new IllegalStateException(
			    "Term not found when copying opinion_expression");
		}
		copiedTargets.add(copiedTerm);
	    }
	    if (span.hasHead()) {
		Term copiedHead = terms.get(span.getHead().getId());
		this.span = new Span(copiedTargets, copiedHead);
	    } else {
		this.span = new Span(copiedTargets);
	    }
	}

	public boolean hasPolarity() {
	    return (this.polarity != null);
	}

	public String getPolarity() {
	    return polarity;
	}

	public void setPolarity(String polarity) {
	    this.polarity = polarity;
	}

	public boolean hasStrength() {
	    return (this.strength != null);
	}

	public String getStrength() {
	    return strength;
	}

	public void setStrength(String strength) {
	    this.strength = strength;
	}

	public boolean hasSubjectivity() {
	    return (this.subjectivity != null);
	}

	public String getSubjectivity() {
	    return subjectivity;
	}

	public void setSubjectivity(String subjectivity) {
	    this.subjectivity = subjectivity;
	}

	public boolean hasSentimentSemanticType() {
	    return (this.sentimentSemanticType != null);
	}

	public String getSentimentSemanticType() {
	    return sentimentSemanticType;
	}

	public void setSentimentSemanticType(String sentimentSemanticType) {
	    this.sentimentSemanticType = sentimentSemanticType;
	}

	public boolean hasSentimentProductFeature() {
	    return (this.sentimentProductFeature != null);
	}

	public String getSentimentProductFeature() {
	    return sentimentProductFeature;
	}

	public void setSentimentProductFeature(String sentimentProductFeature) {
	    this.sentimentProductFeature = sentimentProductFeature;
	}

	public List getTerms() {
	    return this.span.getTargets();
	}

	public void addTerm(Term term) {
	    this.span.addTarget(term);
	}

	public void addTerm(Term term, boolean isHead) {
	    this.span.addTarget(term, isHead);
	}

	public Span getSpan() {
	    return this.span;
	}

	public void setSpan(Span span) {
	    this.span = span;
	}

	Map> getReferencedAnnotations() {
	    Map> referenced = new HashMap>();
	    referenced.put(AnnotationType.TERM, (List) (List) this.getSpan().getTargets());
	    return referenced;
	}
	
	/*
	@Override
	public boolean equals(Object o) {
	    if (this == o) return true;
	    if (!(o instanceof OpinionExpression)) return false;
	    OpinionExpression ann = (OpinionExpression) o;
	    return Utils.areEquals(this.polarity, ann.polarity) &&
		    Utils.areEquals(this.strength, ann.strength) &&
		    Utils.areEquals(this.subjectivity, ann.subjectivity) &&
		    Utils.areEquals(this.sentimentSemanticType, ann.sentimentSemanticType) &&
		    Utils.areEquals(this.sentimentProductFeature, ann.sentimentProductFeature) &&
		    Utils.areEquals(this.span, ann.span);
	}
	*/
    }

    private OpinionHolder opinionHolder;
    private OpinionTarget opinionTarget;
    private OpinionExpression opinionExpression;

    Opinion(String id) {
	super(id);
    }

    Opinion(Opinion opinion, HashMap terms) {
	super(opinion.getId());
	if (opinion.opinionHolder != null) {
	    this.opinionHolder = new OpinionHolder(opinion.opinionHolder, terms);
	}
	if (opinion.opinionTarget != null) {
	    this.opinionTarget = new OpinionTarget(opinion.opinionTarget, terms);
	}
	if (opinion.opinionExpression != null) {
	    this.opinionExpression = new OpinionExpression(
		    opinion.opinionExpression, terms);
	}
    }

    public boolean hasOpinionHolder() {
	return opinionHolder != null;
    }

    public boolean hasOpinionTarget() {
	return opinionTarget != null;
    }

    public boolean hasOpinionExpression() {
	return opinionExpression != null;
    }

    public OpinionHolder getOpinionHolder() {
	return opinionHolder;
    }

    public OpinionTarget getOpinionTarget() {
	return opinionTarget;
    }

    public OpinionExpression getOpinionExpression() {
	return opinionExpression;
    }

    public OpinionHolder createOpinionHolder(Span span) {
	this.opinionHolder = new Opinion.OpinionHolder(span);
	return this.opinionHolder;
    }

    public OpinionTarget createOpinionTarget(Span span) {
	this.opinionTarget = new Opinion.OpinionTarget(span);
	return this.opinionTarget;
    }

    public OpinionExpression createOpinionExpression(Span span) {
	this.opinionExpression = new Opinion.OpinionExpression(span);
	return this.opinionExpression;
    }

    public String getSpanStr(Span span) {
	String str = "";
	for (Term term : span.getTargets()) {
	    if (!str.isEmpty()) {
		str += " ";
	    }
	    str += term.getStr();
	}
	return str;
    }

    public String getStr() {
	return getSpanStr(this.getOpinionExpression().getSpan());
    }

    Map> getReferencedAnnotations() {
	Map> referenced = new HashMap>();
	List referencedTerms = new ArrayList();
	
	if ((this.opinionExpression != null) && (this.opinionExpression.getSpan() != null))
	    referencedTerms.addAll(this.opinionExpression.getSpan().getTargets());
	if ((this.opinionHolder != null) && (this.opinionHolder.getSpan() != null)) referencedTerms.addAll(this.opinionHolder.getSpan().getTargets());
	if ((this.opinionTarget != null) && (this.opinionTarget.getSpan() != null)) referencedTerms.addAll(this.opinionTarget.getSpan().getTargets());
	referenced.put(AnnotationType.TERM, (List) (List) referencedTerms);
	return referenced;
    }
    
    /*
    @Override
    public boolean equals(Object o) {
	if (this == o) return true;
	if (!(o instanceof Opinion)) return false;
	Opinion ann = (Opinion) o;
	return Utils.areEquals(this.opinionHolder, ann.opinionHolder) &&
		Utils.areEquals(this.opinionTarget, ann.opinionTarget) &&
		Utils.areEquals(this.opinionExpression, ann.opinionExpression);
    }
    */
}