/*
 * 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 final class SentimentValueCache {

    private final String sentence;
    private static int counter;
    private static 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 static List classifyRaw;
    private static int mainSentiment = 0;
    private static int longest = 0;
    private static int tokensCounter = 0;
    private static int anotatorcounter = 0;
    private static int inflectedCounterPositive = 0;
    private static int inflectedCounterNegative = 0;
    private static int MarkedContinuousCounter = 0;
    private static int MarkedContiniousCounterEntries = 0;
    private static int UnmarkedPatternCounter = 0;
    private static 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 final int getPairCounter() {
        return pairCounter;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    public final int getUnmarkedPatternCounter() {
        return UnmarkedPatternCounter;
    }

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

    public final int getMarkedContiniousCounterEntries() {
        return MarkedContiniousCounterEntries;
    }

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

    public final int getMarkedContinuousCounter() {
        return MarkedContinuousCounter;
    }

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

    public final int getInflectedCounterNegative() {
        return inflectedCounterNegative;
    }

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

    public final int getInflectedCounterPositive() {
        return inflectedCounterPositive;
    }

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

    public final int getAnotatorcounter() {
        return anotatorcounter;
    }

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

    public final int getTokensCounter() {
        return tokensCounter;
    }

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

    public final int getMainSentiment() {
        return mainSentiment;
    }

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

    public final int getLongest() {
        return longest;
    }

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

    public final List getClassifyRaw() {
        return classifyRaw;
    }

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

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

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

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

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

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

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

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

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

    public final int getCounter() {
        return counter;
    }

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

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

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

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

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

    public final void setCounter(int counter) {
        SentimentValueCache.counter = counter;
    }

    public final String getSentence() {
        return sentence;
    }

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

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

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

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