Returns a new data set containing the original data points that were
loaded with this loader.

@return an appropriate data set for this loader
972452
public DataSet getDataSet()
    {
        if(!noMoreAdding)
        {
            initialLoad();
            finishAdding();
        }
        
        List<DataPoint> dataPoints= new ArrayList<DataPoint>(vectors.size());
        
        for(SparseVector vec : vectors)
            dataPoints.add(new DataPoint(vec, new int[0], new CategoricalData[0]));
        
        return new SimpleDataSet(dataPoints);
    }
    
    /**
     * To be called after all original texts have been loaded. 
     * 
     * @param text the text of the document to create a document vector from
     * @return the sparce vector representing this document 
     */
    @Override
    public Vec newText(String text)
    {
        if(!noMoreAdding)
            throw new RuntimeException("Initial documents have not yet loaded");
        return getTextVectorCreator().newText(text);
    }

    @Override
    public Vec newText(String input, StringBuilder workSpace, List<String> storageSpace)
    {
        if(!noMoreAdding)
            throw new RuntimeException("Initial documents have not yet loaded");
        return getTextVectorCreator().newText(input, workSpace, storageSpace);
    }
    
    /**
     * Returns the {@link TextVectorCreator} used by this data loader to convert
     * documents into vectors. 
     * 
     * @return the text vector creator used by this class
     */
    public TextVectorCreator getTextVectorCreator()
    {
        if(!noMoreAdding)
            throw new RuntimeException("Initial documents have not yet loaded");
        else if(tvc == null)
            tvc = new BasicTextVectorCreator(tokenizer, wordIndex, weighting);
        return tvc;
    }
    
    /**
     * Returns the original token for the given index in the data set
     * @param index the numeric feature index
     * @return the word token associated with the index
     */
    public String getWordForIndex(int index)
    {
        //lazy population of allWords array
        if(allWords.size() != wordIndex.size())//we added since this was done
        {
            while(allWords.size() < wordIndex.size())
                allWords.add("");
            for(Map.Entry<String, Integer> entry : wordIndex.entrySet())
                allWords.set(entry.getValue(), entry.getKey());
        }
        if(index >= 0 && index < allWords.size())
            return allWords.get(index);
        else
            return null;
    }
    
    /**
     * Return the number of times a token has been seen in the document
     * @param index the numeric feature index 
     * @return the total occurrence count for the feature
     */
    public int getTermFrequency(int index)
    {
        return termDocumentFrequencys.get(index).get();
    }
    
    /**
     * Creates a new transform factory to remove all features for tokens that 
     * did not occur a certain number of times
     * @param minCount the minimum number of occurrences to be kept as a feature
     * @return a transform factory for removing features that did not occur 
     * often enough
     */
    @SuppressWarnings("unchecked")
    public RemoveAttributeTransform getMinimumOccurrenceDTF(int minCount)
    {
        
        final Set<Integer> numericToRemove = new IntSet();
        for(int i = 0; i < termDocumentFrequencys.size(); i++)
            if(termDocumentFrequencys.get(i).get() < minCount)
                numericToRemove.add(i);
        
        return new RemoveAttributeTransform(Collections.EMPTY_SET, numericToRemove);
    }
}
68968
public Data getData() {
        if (data == null) {
            JSONObject o = getJSONObject();
            if (o != null) {
                data = new Data(o);
            }
        }
        return data;
    }
1197718
public List<File> getFiles() {
        List<File> result = new LinkedList<File>();
        for (DataFile dataFile : dataFiles.values()) {
            result.add(dataFile.getFile());
        }
        return result;
    }
811204
public Collection<String> getActualDatasourceNames() {
        Collection<String> result = new LinkedHashSet<>(actualDataNodes.size());
        for (DataNode each : actualDataNodes) {
            result.add(each.getDataSourceName());
        }
        return result;
    }
743000
public TableData getTableData() {
		if (TABLE_FORMAT.equals(format)) {
			TableExporter tableExporter = (TableExporter) exporter;
			return tableExporter.getTableData();
		} else {
			return new TableData();
		}
	}
676860
public List<Data> getAsDataList() {
        List<Data> dataList = new ArrayList<Data>(getItemQueue().size());
        for (QueueItem item : getItemQueue()) {
            if (store.isEnabled() && item.getData() == null) {
                try {
                    load(item);
                } catch (Exception e) {
                    throw new HazelcastException(e);
                }
            }
            dataList.add(item.getData());
        }
        return dataList;
    }
878410
def datasets(self):
        """"""
        if self._datasets is None:
            self._datasets = self._fetch_datasets()
        return self._datasets
52724
private List<BrowserUsageData> getBrowserData() {
    List<BrowserUsageData> browserData = new ArrayList<BrowserUsageData>();
    browserData
        .add(getMSIEUsageData());
    browserData
        .add(getFirefoxUsageData());
    browserData
        .add(getChromeUsageData());
    browserData
        .add(getSafariUsageData());
    browserData
        .add(getOperaUsageData());
    return browserData;
  }
1310840
public byte[] getDataBytes() throws IOException {
        byte[] retVal = new byte[length];
        synchronized (data) {
            data.reset();
            data.getBytes(retVal);
        }
        return retVal;
    }
545051
protected Set<String> getPrevExpandedRows() {
		Set<String> prev = getComponentModel().prevExpandedRows;
		if (prev == null) {
			return Collections.emptySet();
		} else {
			return Collections.unmodifiableSet(prev);
		}
	}
982773
public DataObject[] getDataObjectArray(){
        DataObject[] res = new DataObject[this.dataList.size()];
        return this.dataList.toArray(res);
    }
1085876
public List<ChildData> getCurrentData()
    {
        return ImmutableList.copyOf(Sets.<ChildData>newTreeSet(currentData.values()));
    }
1012759
@Override
    public Set<Stream> getResultStreams() {
    	Set<Stream> streams = ImmutableSet.of(this.resultStream);
		return streams;
    }
1264266
public HashMap<String, String> getData() {
        HashMap<String, String> hash = new HashMap<>();
        HashMap p = new HashMap<String, String>();
        int nameskip = getName().length() + 1;

        extractValues(hash);

        hash.forEach((key, value) -> {
            p.put(key.substring(nameskip), value);
        });

        return p;
    }
1364443
public Map<String, Object> getData() {
        TypeToken<Map<String, Object>> typeToken = new TypeToken<Map<String, Object>>() {};
        return GSON.fromJson(data, typeToken.getType());
    }
229234
Result getSamplesAsArrays() {
    if ((r_ + h_) == 0) {
      return null;
    }

    final int validIndex = (h_ == 0 ? 1 : 0);
    final Class<?> clazz = data_.get(validIndex).getClass();
    return getSamplesAsArrays(clazz);
  }
1071916
public Object doGetData()
    {
        String data = (String)super.doGetData();
        FileListener listener = this.getRecord().getListener(PropertiesStringFileListener.class);
        if (this.getComponent(0) == null)   // Don't convert if this is linked to a screen
            if (enableConversion)
                if (listener != null)
                    if (listener.isEnabled())
                        data = Utility.replaceResources(data, null, null, this.getRecord().getRecordOwner(), true);
        return data;
    }