public ArrayList<TimeSeries> getAllEnabledSeries() {
   ArrayList<TimeSeries> list = new ArrayList<TimeSeries>();
   for (int i = 0; i < mSeries.size(); i++) {
     TimeSeries ts = mSeries.get(i);
     if (ts != null && ts.isEnabled()) list.add(ts);
   }
   return list;
 }
  private void generateSynthetics() {
    for (int i = 0; i < mSeries.size(); i++) {
      TimeSeries synth = mSeries.get(i);
      if (synth == null || synth.getDbRow().getSynthetic() == false || synth.isEnabled() == false)
        continue;

      generateSynthetic(synth);
    }
  }
  public void toggleSeriesEnabled(long catId) {
    waitForLock();
    TimeSeries ts = getSeriesByIdNonlocking(catId);

    if (ts.isEnabled()) ts.setEnabled(false);
    else ts.setEnabled(true);
    unlock();
    return;
  }
 public boolean isSeriesEnabled(long catId) {
   boolean b;
   waitForLock();
   TimeSeries ts = getSeriesByIdNonlocking(catId);
   if (ts == null) b = false;
   else b = ts.isEnabled();
   unlock();
   return b;
 }
 public void updateTimeSeriesData(long start, long end, boolean flushCache) {
   for (int i = 0; i < mSeries.size(); i++) {
     TimeSeries ts = mSeries.get(i);
     if (ts != null && ts.isEnabled() == true) {
       long catId = ts.getDbRow().getId();
       updateTimeSeriesDataLocking(catId, start, end, flushCache);
     }
   }
 }
  public synchronized void gatherSeries(long milliStart, long milliEnd) {
    ArrayList<Datapoint> pre, range, post;
    boolean has_data;
    long oldAggregationMs = mAggregationMs;

    mQueryStart = milliStart;
    mQueryEnd = milliEnd;

    setCollectionTimes(milliStart, milliEnd);
    for (int i = 0; i < mSeries.size(); i++) {
      has_data = false;

      TimeSeries ts = mSeries.get(i);
      if (ts == null || ts.getDbRow().getSynthetic()) continue;

      if (ts.isEnabled() == false) {
        boolean skip = true;
        for (int j = 0; j < ts.getDependees().size(); j++) {
          if (ts.getDependees().get(j).isEnabled() == true) {
            skip = false;
            break;
          }
        }
        if (skip == true) continue;
      }

      mDatapointCache.populateRange(
          ts.getDbRow().getId(), mCollectionStart, mCollectionEnd, mAggregationMs);

      pre = mDatapointCache.getDataBefore(ts.getDbRow().getId(), mHistory, mCollectionStart);
      if (pre != null && pre.size() > 0) has_data = true;

      range =
          mDatapointCache.getDataInRange(ts.getDbRow().getId(), mCollectionStart, mCollectionEnd);
      if (range != null && range.size() > 0) has_data = true;

      post = mDatapointCache.getDataAfter(ts.getDbRow().getId(), 1, mCollectionEnd);
      if (post != null && range.size() > 0) has_data = true;

      if (has_data == true) ts.setDatapoints(pre, range, post, true);
    }

    generateSynthetics();

    ArrayList<TimeSeries> enabledSeries = getAllEnabledSeries();
    for (int i = 0; i < enabledSeries.size(); i++) {
      aggregateDatapoints(enabledSeries.get(i));
    }

    mAggregationMs = oldAggregationMs;

    return;
  }
 public Datapoint getVisibleLastDatapointLocking() {
   Datapoint last = null;
   waitForLock();
   for (int i = 0; i < mSeries.size(); i++) {
     TimeSeries ts = mSeries.get(i);
     if (ts != null && ts.isEnabled() == true) {
       Datapoint d = ts.getLastVisible();
       if (last == null) last = d;
       else if (d.mMillis > last.mMillis) last = d;
     }
   }
   unlock();
   return last;
 }
 public boolean isSeriesEnabled(long catId) {
   TimeSeries ts = getSeriesByIdLocking(catId);
   if (ts == null) return false;
   return ts.isEnabled();
 }