/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package FunctionLayer.StanfordParser;

import com.google.common.collect.MapMaker;
import edu.stanford.nlp.ling.TaggedWord;
import edu.stanford.nlp.trees.GrammaticalStructure;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.trees.TypedDependency;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import org.ejml.simple.SimpleMatrix;

/**
 *
 * @author install1
 */
public class SentimentValueCache {

    private String sentence;
    private int counter;
    private List<List<TaggedWord>> taggedwordlist = new ArrayList();
    private final ConcurrentMap<Integer, String> tgwlistIndex = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, Tree> sentenceConstituencyParseList = new MapMaker().concurrencyLevel(2).makeMap();
    private final Collection<TypedDependency> allTypedDependencies = new ArrayList();
    private final ConcurrentMap<Integer, GrammaticalStructure> gsMap = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, SimpleMatrix> simpleSMXlist = new MapMaker().concurrencyLevel(3).makeMap();
    private final ConcurrentMap<Integer, SimpleMatrix> simpleSMXlistVector = new MapMaker().concurrencyLevel(3).makeMap();
    private final ConcurrentMap<Integer, Integer> rnnPredictClassMap = new MapMaker().concurrencyLevel(3).makeMap();
    private List classifyRaw;
    private int mainSentiment = 0;
    private int longest = 0;
    private int tokensCounter = 0;
    private int anotatorcounter = 0;
    private int inflectedCounterPositive = 0;
    private int inflectedCounterNegative = 0;
    private int MarkedContinuousCounter = 0;
    private int MarkedContiniousCounterEntries = 0;
    private int UnmarkedPatternCounter = 0;
    private int pairCounter = 0;
    private final ConcurrentMap<Integer, String> ITokenMapTag = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> strTokenStems = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> strTokenForm = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> strTokenGetEntry = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> strTokenGetiPart = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> strTokenEntryPOS = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, Integer> entryCounts = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> nerEntities1 = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> nerEntities2 = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> nerEntityTokenTags = new MapMaker().concurrencyLevel(3).makeMap();
    private final ConcurrentMap<Integer, String> stopwordTokens = new MapMaker().concurrencyLevel(2).makeMap();
    private final ConcurrentMap<Integer, String> stopWordLemma = new MapMaker().concurrencyLevel(2).makeMap();

    public int getPairCounter() {
        return pairCounter;
    }

    public void setPairCounter(int pairCounter) {
        this.pairCounter = pairCounter;
    }

    public void addStopWordLemma(String str) {
        stopWordLemma.put(stopWordLemma.size(), str);
    }

    public void addstopwordTokens(String str) {
        stopwordTokens.put(stopwordTokens.size(), str);
    }

    public ConcurrentMap<Integer, String> getStopwordTokens() {
        return stopwordTokens;
    }

    public ConcurrentMap<Integer, String> getStopWordLemma() {
        return stopWordLemma;
    }

    public void addnerEntityTokenTags(String str) {
        nerEntityTokenTags.put(nerEntityTokenTags.size(), str);
    }

    public ConcurrentMap<Integer, String> getnerEntityTokenTags() {
        return nerEntityTokenTags;
    }

    public ConcurrentMap<Integer, String> getnerEntities1() {
        return nerEntities1;
    }

    public ConcurrentMap<Integer, String> getnerEntities2() {
        return nerEntities2;
    }

    public void addNEREntities1(String str) {
        nerEntities1.put(nerEntities1.size(), str);
    }

    public void addNEREntities2(String str) {
        nerEntities2.put(nerEntities2.size(), str);
    }

    public void setTaggedwords(List<List<TaggedWord>> twlist) {
        taggedwordlist = twlist;
    }

    public List<List<TaggedWord>> getTaggedwordlist() {
        return taggedwordlist;
    }

    public void addEntryCounts(int counts) {
        entryCounts.put(entryCounts.size(), counts);
    }

    public ConcurrentMap<Integer, Integer> getEntryCounts() {
        return entryCounts;
    }

    public void addstrTokenEntryPOS(String str) {
        strTokenEntryPOS.put(strTokenEntryPOS.size(), str);
    }

    public ConcurrentMap<Integer, String> getstrTokenEntryPOS() {
        return strTokenEntryPOS;
    }

    public void addstrTokenGetiPart(String str) {
        strTokenGetiPart.put(strTokenGetiPart.size(), str);
    }

    public ConcurrentMap<Integer, String> getstrTokenGetiPart() {
        return strTokenGetiPart;
    }

    public ConcurrentMap<Integer, String> getstrTokenGetEntry() {
        return strTokenGetEntry;
    }

    public void addstrTokenGetEntry(String str) {
        strTokenGetEntry.put(strTokenGetEntry.size(), str);
    }

    public ConcurrentMap<Integer, String> getstrTokenForm() {
        return strTokenForm;
    }

    public void addstrTokenForm(String str) {
        strTokenForm.put(strTokenForm.size(), str);
    }

    public ConcurrentMap<Integer, String> getstrTokenStems() {
        return strTokenStems;
    }

    public void addstrTokenStems(String str) {
        strTokenStems.put(strTokenStems.size(), str);
    }

    public ConcurrentMap<Integer, String> getITokenMapTag() {
        return ITokenMapTag;
    }

    public void addITokenMapTag(String str) {
        ITokenMapTag.put(ITokenMapTag.size(), str);
    }

    public int getUnmarkedPatternCounter() {
        return UnmarkedPatternCounter;
    }

    public void setUnmarkedPatternCounter(int UnmarkedPatternCounter) {
        this.UnmarkedPatternCounter = UnmarkedPatternCounter;
    }

    public int getMarkedContiniousCounterEntries() {
        return MarkedContiniousCounterEntries;
    }

    public void setMarkedContiniousCounterEntries(int MarkedContiniousCounterEntries) {
        this.MarkedContiniousCounterEntries = MarkedContiniousCounterEntries;
    }

    public int getMarkedContinuousCounter() {
        return MarkedContinuousCounter;
    }

    public void setMarkedContinuousCounter(int MarkedContinuousCounter) {
        this.MarkedContinuousCounter = MarkedContinuousCounter;
    }

    public int getInflectedCounterNegative() {
        return inflectedCounterNegative;
    }

    public void setInflectedCounterNegative(int inflectedCounterNegative) {
        this.inflectedCounterNegative = inflectedCounterNegative;
    }

    public int getInflectedCounterPositive() {
        return inflectedCounterPositive;
    }

    public void setInflectedCounterPositive(int inflectedCounterPositive) {
        this.inflectedCounterPositive = inflectedCounterPositive;
    }

    public int getAnotatorcounter() {
        return anotatorcounter;
    }

    public void setAnotatorcounter(int anotatorcounter) {
        this.anotatorcounter = anotatorcounter;
    }

    public int getTokensCounter() {
        return tokensCounter;
    }

    public void setTokensCounter(int tokensCounter) {
        this.tokensCounter = tokensCounter;
    }

    public int getMainSentiment() {
        return mainSentiment;
    }

    public void setMainSentiment(int mainSentiment) {
        this.mainSentiment = mainSentiment;
    }

    public int getLongest() {
        return longest;
    }

    public void setLongest(int longest) {
        this.longest = longest;
    }

    public List getClassifyRaw() {
        return classifyRaw;
    }

    public void setClassifyRaw(List classifyRaw) {
        this.classifyRaw = classifyRaw;
    }

    public ConcurrentMap<Integer, Integer> getRnnPrediectClassMap() {
        return rnnPredictClassMap;
    }

    public void addRNNPredictClass(int rnnPrediction) {
        rnnPredictClassMap.put(rnnPredictClassMap.size(), rnnPrediction);
    }

    public void addSimpleMatrix(SimpleMatrix SMX) {
        simpleSMXlist.put(simpleSMXlist.size(), SMX);
    }

    public void addSimpleMatrixVector(SimpleMatrix SMX) {
        simpleSMXlistVector.put(simpleSMXlistVector.size(), SMX);
    }

    public ConcurrentMap<Integer, GrammaticalStructure> getGsMap() {
        return gsMap;
    }

    public ConcurrentMap<Integer, SimpleMatrix> getSimpleSMXlist() {
        return simpleSMXlist;
    }

    public ConcurrentMap<Integer, SimpleMatrix> getSimpleSMXlistVector() {
        return simpleSMXlistVector;
    }

    public ConcurrentMap<Integer, GrammaticalStructure> getGs() {
        return gsMap;
    }

    public int getCounter() {
        return counter;
    }

    public void addGS(GrammaticalStructure gs) {
        gsMap.put(gsMap.size(), gs);
    }

    public Collection<TypedDependency> getAllTypedDependencies() {
        return allTypedDependencies;
    }

    public void addTypedDependencies(Collection<TypedDependency> TDPlist) {
        for (TypedDependency TDP : TDPlist) {
            allTypedDependencies.add(TDP);
        }
    }

    public ConcurrentMap<Integer, Tree> getSentenceConstituencyParseList() {
        return sentenceConstituencyParseList;
    }

    public void addSentenceConstituencyParse(Tree tree) {
        sentenceConstituencyParseList.put(sentenceConstituencyParseList.size(), tree);
    }

    public void setCounter(int counter) {
        counter = counter;
    }

    public String getSentence() {
        return sentence;
    }

    public SentimentValueCache(String str, int counter) {
        this.sentence = str;
        this.counter = counter;
    }

    public ConcurrentMap<Integer, String> getTgwlistIndex() {
        return tgwlistIndex;
    }

    public void addTgwlistIndex(String str) {
        tgwlistIndex.put(tgwlistIndex.size(), str);
    }

    public SentimentValueCache(String str) {
        this.sentence = str;
    }
}