How to use

apply

method

in

org.apache.cassandra.db.lifecycle.Tracker

Throwable apply(Function<View, View> function, Throwable accumulate)
{
  try
  {
    apply(function);
  }
  catch (Throwable t)
  {
    accumulate = merge(accumulate, t);
  }
  return accumulate;
}

Throwable apply(Function<View, View> function, Throwable accumulate)
{
  try
  {
    apply(function);
  }
  catch (Throwable t)
  {
    accumulate = merge(accumulate, t);
  }
  return accumulate;
}

public void markFlushing(Memtable memtable)
{
  apply(View.markFlushing(memtable));
}

Throwable apply(Function<View, View> function, Throwable accumulate)
{
  try
  {
    apply(function);
  }
  catch (Throwable t)
  {
    accumulate = merge(accumulate, t);
  }
  return accumulate;
}

  @VisibleForTesting
  public void removeUnsafe(Set<SSTableReader> toRemove)
  {
    Pair<View, View> result = apply(view -> {
      return updateLiveSet(toRemove, emptySet()).apply(view);
    });
  }
}

  @VisibleForTesting
  public void removeUnsafe(Set<SSTableReader> toRemove)
  {
    Pair<View, View> result = apply(view -> {
      return updateLiveSet(toRemove, emptySet()).apply(view);
    });
  }
}

private Throwable unmarkCompacting(Set<SSTableReader> unmark, Throwable accumulate)
{
  accumulate = tracker.apply(updateCompacting(unmark, emptySet()), accumulate);
  // when the CFS is invalidated, it will call unreferenceSSTables().  However, unreferenceSSTables only deals
  // with sstables that aren't currently being compacted.  If there are ongoing compactions that finish or are
  // interrupted after the CFS is invalidated, those sstables need to be unreferenced as well, so we do that here.
  accumulate = tracker.dropSSTablesIfInvalid(accumulate);
  return accumulate;
}

private Throwable unmarkCompacting(Set<SSTableReader> unmark, Throwable accumulate)
{
  accumulate = tracker.apply(updateCompacting(unmark, emptySet()), accumulate);
  // when the CFS is invalidated, it will call unreferenceSSTables().  However, unreferenceSSTables only deals
  // with sstables that aren't currently being compacted.  If there are ongoing compactions that finish or are
  // interrupted after the CFS is invalidated, those sstables need to be unreferenced as well, so we do that here.
  accumulate = tracker.dropSSTablesIfInvalid(accumulate);
  return accumulate;
}

private Throwable unmarkCompacting(Set<SSTableReader> unmark, Throwable accumulate)
{
  accumulate = tracker.apply(updateCompacting(unmark, emptySet()), accumulate);
  // when the CFS is invalidated, it will call unreferenceSSTables().  However, unreferenceSSTables only deals
  // with sstables that aren't currently being compacted.  If there are ongoing compactions that finish or are
  // interrupted after the CFS is invalidated, those sstables need to be unreferenced as well, so we do that here.
  accumulate = tracker.dropSSTablesIfInvalid(accumulate);
  return accumulate;
}

/**
 * @return a Transaction over the provided sstables if we are able to mark the given @param sstables as compacted, before anyone else
 */
public LifecycleTransaction tryModify(Iterable<SSTableReader> sstables, OperationType operationType)
{
  if (Iterables.isEmpty(sstables))
    return new LifecycleTransaction(this, operationType, sstables);
  if (null == apply(permitCompacting(sstables), updateCompacting(emptySet(), sstables)))
    return null;
  return new LifecycleTransaction(this, operationType, sstables);
}

/**
 * @return a Transaction over the provided sstables if we are able to mark the given @param sstables as compacted, before anyone else
 */
public LifecycleTransaction tryModify(Iterable<SSTableReader> sstables, OperationType operationType)
{
  if (Iterables.isEmpty(sstables))
    return new LifecycleTransaction(this, operationType, sstables);
  if (null == apply(permitCompacting(sstables), updateCompacting(emptySet(), sstables)))
    return null;
  return new LifecycleTransaction(this, operationType, sstables);
}

/**
 * @return a Transaction over the provided sstables if we are able to mark the given @param sstables as compacted, before anyone else
 */
public LifecycleTransaction tryModify(Iterable<SSTableReader> sstables, OperationType operationType)
{
  if (Iterables.isEmpty(sstables))
    return new LifecycleTransaction(this, operationType, sstables);
  if (null == apply(permitCompacting(sstables), updateCompacting(emptySet(), sstables)))
    return null;
  return new LifecycleTransaction(this, operationType, sstables);
}

/**
 * construct a Transaction for use in an offline operation
 */
public static LifecycleTransaction offline(OperationType operationType, Iterable<SSTableReader> readers)
{
  // if offline, for simplicity we just use a dummy tracker
  Tracker dummy = new Tracker(null, false);
  dummy.addInitialSSTables(readers);
  dummy.apply(updateCompacting(emptySet(), readers));
  return new LifecycleTransaction(dummy, operationType, readers);
}

/**
 * construct a Transaction for use in an offline operation
 */
public static LifecycleTransaction offline(OperationType operationType, Iterable<SSTableReader> readers)
{
  // if offline, for simplicity we just use a dummy tracker
  Tracker dummy = new Tracker(false);
  dummy.addInitialSSTables(readers);
  dummy.apply(updateCompacting(emptySet(), readers));
  return new LifecycleTransaction(dummy, operationType, readers);
}

/**
 * construct a Transaction for use in an offline operation
 */
public static LifecycleTransaction offline(OperationType operationType, Iterable<SSTableReader> readers)
{
  // if offline, for simplicity we just use a dummy tracker
  Tracker dummy = new Tracker(null, false);
  dummy.addInitialSSTables(readers);
  dummy.apply(updateCompacting(emptySet(), readers));
  return new LifecycleTransaction(dummy, operationType, readers);
}

/**
 * construct a Transaction for use in an offline operation
 */
public static LifecycleTransaction offline(OperationType operationType, Iterable<SSTableReader> readers)
{
  // if offline, for simplicity we just use a dummy tracker
  Tracker dummy = new Tracker(null, false);
  dummy.addInitialSSTables(readers);
  dummy.apply(updateCompacting(emptySet(), readers));
  return new LifecycleTransaction(dummy, operationType, readers);
}

/**
 * @return a Transaction over the provided sstables if we are able to mark the given @param sstables as compacted, before anyone else
 */
public LifecycleTransaction tryModify(Iterable<SSTableReader> sstables, OperationType operationType)
{
  if (Iterables.isEmpty(sstables))
    return new LifecycleTransaction(this, operationType, sstables);
  if (null == apply(permitCompacting(sstables), updateCompacting(emptySet(), sstables)))
    return null;
  return new LifecycleTransaction(this, operationType, sstables);
}

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}