code: public Observable<Indexable> invokeTaskAsync(boolean ignoreCachedResult, final TaskGroup.InvocationContext context) {
          if (hasFaultedDescentDependencyTasks) {
              return Observable.error(new ErroredDependencyTaskException());
          }
          final TaskT taskItem = this.taskItem();
          if (!ignoreCachedResult && hasCachedResult()) {
              return Observable.just(taskItem.result());
          }
          if (taskItem.isHot()) {
              // Convert hot task to cold to delay it's execution until subscription.
              return Observable.defer(new Func0<Observable<Indexable>>() {
                  @Override
                  public Observable<Indexable> call() {
                      return taskItem.invokeAsync(context);
                  }
              });
          } else {
              return taskItem.invokeAsync(context);
          }
      }
docs: Invokes the task this entry holds.
  if the task cannot be invoked due to faulted dependencies then an observable that emit
  {@link ErroredDependencyTaskException} will be returned.
  
  @param ignoreCachedResult if the task is already invoked and has result cached then a value false for this
  parameter indicates the cached result can be returned without invoking task again,
  if true then cached result will be ignored and task will be invoked
  @param context the context object shared across all the entries in the group that this entry belongs to,
  this will be passed to {@link TaskItem#invokeAsync(TaskGroup.InvocationContext)}
  method of the task item
  
  @return a cold Observable upon subscription invokes the task this entry hold, which produces a result of
  type {@link Indexable}.