How to use

variables

method

in

com.apollographql.apollo.api.Operation

 @Nullable @Override public T execute(ReadableStore cache) {
  Record rootRecord = cache.read(CacheKeyResolver.rootKeyForOperation(operation).key(), CacheHeaders.NONE);
  if (rootRecord == null) {
   return null;
  }
  ResponseFieldMapper<D> responseFieldMapper = operation.responseFieldMapper();
  CacheFieldValueResolver fieldValueResolver = new CacheFieldValueResolver(cache, operation.variables(),
    cacheKeyResolver(), CacheHeaders.NONE, cacheKeyBuilder);
  //noinspection unchecked
  RealResponseReader<Record> responseReader = new RealResponseReader<>(operation.variables(), rootRecord,
    fieldValueResolver, scalarTypeAdapters, ResponseNormalizer.NO_OP_NORMALIZER);
  return operation.wrapData(responseFieldMapper.map(responseReader));
 }
});

@SuppressWarnings("unchecked")
public Response<W> parse(@NotNull Map<String, Object> payload) {
 checkNotNull(payload, "payload == null");
 D data = null;
 if (payload.containsKey("data")) {
  Map<String, Object> buffer = (Map<String, Object>) payload.get("data");
  RealResponseReader<Map<String, Object>> realResponseReader = new RealResponseReader<>(operation.variables(),
    buffer, new MapFieldValueResolver(), scalarTypeAdapters, responseNormalizer);
  data = (D) responseFieldMapper.map(realResponseReader);
 }
 List<Error> errors = null;
 if (payload.containsKey("errors")) {
  List<Map<String, Object>> errorPayloads = (List<Map<String, Object>>) payload.get("errors");
  if (errorPayloads != null) {
   errors = new ArrayList<>();
   for (Map<String, Object> errorPayload : errorPayloads) {
    errors.add(readError(errorPayload));
   }
  }
 }
 return Response.<W>builder(operation)
   .data(operation.wrapData(data))
   .errors(errors)
   .dependentKeys(responseNormalizer.dependentKeys())
   .build();
}

return new RealResponseReader<>(EMPTY_OPERATION.variables(), recordSet, new MapFieldValueResolver(),
  new ScalarTypeAdapters(customTypeAdapters), NO_OP_NORMALIZER);

 @Override public Set<String> execute(WriteableStore cache) {
  RealResponseWriter responseWriter = new RealResponseWriter(operation.variables(), scalarTypeAdapters);
  operationData.marshaller().marshal(responseWriter);
  ResponseNormalizer<Map<String, Object>> responseNormalizer = networkResponseNormalizer();
  responseNormalizer.willResolveRootQuery(operation);
  responseWriter.resolveFields(responseNormalizer);
  if (optimistic) {
   List<Record> updatedRecords = new ArrayList<>();
   for (Record record : responseNormalizer.records()) {
    updatedRecords.add(record.toBuilder().mutationId(mutationId).build());
   }
   return optimisticCache.mergeOptimisticUpdates(updatedRecords);
  } else {
   return optimisticCache.merge(responseNormalizer.records(), CacheHeaders.NONE);
  }
 }
});

 @NotNull @Override public Response<T> execute(ReadableStore cache) {
  Record rootRecord = cache.read(CacheKeyResolver.rootKeyForOperation(operation).key(), cacheHeaders);
  if (rootRecord == null) {
   return Response.<T>builder(operation).fromCache(true).build();
  }
  CacheFieldValueResolver fieldValueResolver = new CacheFieldValueResolver(cache, operation.variables(),
    cacheKeyResolver(), cacheHeaders, cacheKeyBuilder);
  RealResponseReader<Record> responseReader = new RealResponseReader<>(operation.variables(), rootRecord,
    fieldValueResolver, scalarTypeAdapters, responseNormalizer);
  try {
   responseNormalizer.willResolveRootQuery(operation);
   T data = operation.wrapData(responseFieldMapper.map(responseReader));
   return Response.<T>builder(operation)
     .data(data)
     .fromCache(true)
     .dependentKeys(responseNormalizer.dependentKeys())
     .build();
  } catch (Exception e) {
   logger.e(e, "Failed to read cache response");
   return Response.<T>builder(operation).fromCache(true).build();
  }
 }
});

 static ByteString httpRequestBody(Operation operation, ScalarTypeAdapters scalarTypeAdapters,
   boolean writeQueryDocument) throws IOException {
  Buffer buffer = new Buffer();
  JsonWriter jsonWriter = JsonWriter.of(buffer);
  jsonWriter.setSerializeNulls(true);
  jsonWriter.beginObject();
  jsonWriter.name("operationName").value(operation.name().name());
  jsonWriter.name("variables").beginObject();
  operation.variables().marshaller().marshal(new InputFieldJsonWriter(jsonWriter, scalarTypeAdapters));
  jsonWriter.endObject();
  jsonWriter.name("extensions")
    .beginObject()
    .name("persistedQuery")
    .beginObject()
    .name("version").value(1)
    .name("sha256Hash").value(operation.operationId())
    .endObject()
    .endObject();
  if (writeQueryDocument) {
   jsonWriter.name("query").value(operation.queryDocument().replaceAll("\\n", ""));
  }
  jsonWriter.endObject();
  jsonWriter.close();
  return buffer.readByteString();
 }
}

 @Nullable @Override public T execute(ReadableStore cache) {
  Record rootRecord = cache.read(CacheKeyResolver.rootKeyForOperation(operation).key(), CacheHeaders.NONE);
  if (rootRecord == null) {
   return null;
  }
  ResponseFieldMapper<D> responseFieldMapper = operation.responseFieldMapper();
  CacheFieldValueResolver fieldValueResolver = new CacheFieldValueResolver(cache, operation.variables(),
    cacheKeyResolver(), CacheHeaders.NONE);
  //noinspection unchecked
  RealResponseReader<Record> responseReader = new RealResponseReader<>(operation.variables(), rootRecord,
    fieldValueResolver, scalarTypeAdapters, ResponseNormalizer.NO_OP_NORMALIZER);
  return operation.wrapData(responseFieldMapper.map(responseReader));
 }
});

 @Nullable @Override public T execute(ReadableStore cache) {
  Record rootRecord = cache.read(CacheKeyResolver.rootKeyForOperation(operation).key(), CacheHeaders.NONE);
  if (rootRecord == null) {
   return null;
  }
  ResponseFieldMapper<D> responseFieldMapper = operation.responseFieldMapper();
  CacheFieldValueResolver fieldValueResolver = new CacheFieldValueResolver(cache, operation.variables(),
    cacheKeyResolver(), CacheHeaders.NONE);
  //noinspection unchecked
  RealResponseReader<Record> responseReader = new RealResponseReader<>(operation.variables(), rootRecord,
    fieldValueResolver, scalarTypeAdapters, ResponseNormalizer.NO_OP_NORMALIZER);
  return operation.wrapData(responseFieldMapper.map(responseReader));
 }
});

Log.v(TAG,"Thread:[" + Thread.currentThread().getId() +"]:  Added mutation[" + mutationObject.recordIdentifier + "] to inMemory Queue"  );
S3InputObjectInterface s3InputObjectInterface = S3ObjectManagerImplementation.getS3ComplexObject(mutationObject.request.operation.variables().valueMap());
if (s3InputObjectInterface == null) {
  persistentOfflineMutationManager.addPersistentMutationObject(

S3InputObjectInterface s3Object = S3ObjectManagerImplementation.getS3ComplexObject(request.operation.variables().valueMap());
if (s3Object == null ) {
  Log.v(TAG, "Thread:[" + Thread.currentThread().getId() +"]: No s3 Objects found. Proceeding with the chain");

@SuppressWarnings("unchecked")
public Response<W> parse(@Nonnull Map<String, Object> payload) {
 checkNotNull(payload, "payload == null");
 D data = null;
 if (payload.containsKey("data")) {
  Map<String, Object> buffer = (Map<String, Object>) payload.get("data");
  RealResponseReader<Map<String, Object>> realResponseReader = new RealResponseReader<>(operation.variables(),
      buffer, new MapFieldValueResolver(), scalarTypeAdapters, responseNormalizer);
  data = (D) responseFieldMapper.map(realResponseReader);
 }
 List<Error> errors = null;
 if (payload.containsKey("errors")) {
  List<Map<String, Object>> errorPayloads = (List<Map<String, Object>>) payload.get("errors");
  if (errorPayloads != null) {
   errors = new ArrayList<>();
   for (Map<String, Object> errorPayload : errorPayloads) {
    errors.add(readError(errorPayload));
   }
  }
 }
 return Response.<W>builder(operation)
     .data(operation.wrapData(data))
     .errors(errors)
     .dependentKeys(responseNormalizer.dependentKeys())
     .build();
}

@SuppressWarnings("unchecked")
public Response<W> parse(@Nonnull Map<String, Object> payload) {
 checkNotNull(payload, "payload == null");
 D data = null;
 if (payload.containsKey("data")) {
  Map<String, Object> buffer = (Map<String, Object>) payload.get("data");
  RealResponseReader<Map<String, Object>> realResponseReader = new RealResponseReader<>(operation.variables(),
      buffer, new MapFieldValueResolver(), scalarTypeAdapters, responseNormalizer);
  data = (D) responseFieldMapper.map(realResponseReader);
 }
 List<Error> errors = null;
 if (payload.containsKey("errors")) {
  List<Map<String, Object>> errorPayloads = (List<Map<String, Object>>) payload.get("errors");
  if (errorPayloads != null) {
   errors = new ArrayList<>();
   for (Map<String, Object> errorPayload : errorPayloads) {
    errors.add(readError(errorPayload));
   }
  }
 }
 return Response.<W>builder(operation)
     .data(operation.wrapData(data))
     .errors(errors)
     .dependentKeys(responseNormalizer.dependentKeys())
     .build();
}

 @Override public Set<String> execute(WriteableStore cache) {
  CacheResponseWriter cacheResponseWriter = new CacheResponseWriter(operation.variables(),
    scalarTypeAdapters);
  operationData.marshaller().marshal(cacheResponseWriter);
  ResponseNormalizer<Map<String, Object>> responseNormalizer = networkResponseNormalizer();
  responseNormalizer.willResolveRootQuery(operation);
  Collection<Record> records = cacheResponseWriter.normalize(responseNormalizer);
  if (optimistic) {
   List<Record> updatedRecords = new ArrayList<>();
   for (Record record : records) {
    updatedRecords.add(record.toBuilder().mutationId(mutationId).build());
   }
   return optimisticCache.mergeOptimisticUpdates(updatedRecords);
  } else {
   return optimisticCache.merge(records, CacheHeaders.NONE);
  }
 }
});

private String httpRequestBody(Operation operation) throws IOException {
  Buffer buffer = new Buffer();
  JsonWriter jsonWriter = JsonWriter.of(buffer);
  jsonWriter.beginObject();
  jsonWriter.name("query").value(operation.queryDocument().replaceAll("\\n", ""));
  jsonWriter.name("variables").beginObject();
  operation.variables().marshaller().marshal(new InputFieldJsonWriter(jsonWriter, scalarTypeAdapters));
  jsonWriter.endObject();
  jsonWriter.endObject();
  jsonWriter.close();
  return buffer.readUtf8();
}

 @Override public Set<String> execute(WriteableStore cache) {
  CacheResponseWriter cacheResponseWriter = new CacheResponseWriter(operation.variables(),
    scalarTypeAdapters);
  operationData.marshaller().marshal(cacheResponseWriter);
  ResponseNormalizer<Map<String, Object>> responseNormalizer = networkResponseNormalizer();
  responseNormalizer.willResolveRootQuery(operation);
  Collection<Record> records = cacheResponseWriter.normalize(responseNormalizer);
  if (optimistic) {
   List<Record> updatedRecords = new ArrayList<>();
   for (Record record : records) {
    updatedRecords.add(record.toBuilder().mutationId(mutationId).build());
   }
   return optimisticCache.mergeOptimisticUpdates(updatedRecords);
  } else {
   return optimisticCache.merge(records, CacheHeaders.NONE);
  }
 }
});

private RequestBody httpRequestBody(Operation operation) throws IOException {
 Buffer buffer = new Buffer();
 JsonWriter jsonWriter = JsonWriter.of(buffer);
 jsonWriter.beginObject();
 if (sendOperationIdentifiers) {
  jsonWriter.name("id").value(operation.operationId());
 } else {
  jsonWriter.name("query").value(operation.queryDocument().replaceAll("\\n", ""));
 }
 jsonWriter.name("variables").beginObject();
 operation.variables().marshaller().marshal(new InputFieldJsonWriter(jsonWriter, scalarTypeAdapters));
 jsonWriter.endObject();
 jsonWriter.endObject();
 jsonWriter.close();
 return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
}

private RequestBody httpRequestBody(Operation operation) throws IOException {
 Buffer buffer = new Buffer();
 JsonWriter jsonWriter = JsonWriter.of(buffer);
 jsonWriter.beginObject();
 if (sendOperationIdentifiers) {
  jsonWriter.name("id").value(operation.operationId());
 } else {
  jsonWriter.name("query").value(operation.queryDocument().replaceAll("\\n", ""));
 }
 jsonWriter.name("variables").beginObject();
 operation.variables().marshaller().marshal(new InputFieldJsonWriter(jsonWriter, scalarTypeAdapters));
 jsonWriter.endObject();
 jsonWriter.endObject();
 jsonWriter.close();
 return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
}

 @Nonnull @Override public Response<T> execute(ReadableStore cache) {
  Record rootRecord = cache.read(CacheKeyResolver.rootKeyForOperation(operation).key(), cacheHeaders);
  if (rootRecord == null) {
   return Response.<T>builder(operation).fromCache(true).build();
  }
  CacheFieldValueResolver fieldValueResolver = new CacheFieldValueResolver(cache, operation.variables(),
    cacheKeyResolver(), cacheHeaders);
  RealResponseReader<Record> responseReader = new RealResponseReader<>(operation.variables(), rootRecord,
    fieldValueResolver, scalarTypeAdapters, responseNormalizer);
  try {
   responseNormalizer.willResolveRootQuery(operation);
   T data = operation.wrapData(responseFieldMapper.map(responseReader));
   return Response.<T>builder(operation)
     .data(data)
     .fromCache(true)
     .dependentKeys(responseNormalizer.dependentKeys())
     .build();
  } catch (Exception e) {
   logger.e(e, "Failed to read cache response");
   return Response.<T>builder(operation).fromCache(true).build();
  }
 }
});

 @Nonnull @Override public Response<T> execute(ReadableStore cache) {
  Record rootRecord = cache.read(CacheKeyResolver.rootKeyForOperation(operation).key(), cacheHeaders);
  if (rootRecord == null) {
   return Response.<T>builder(operation).fromCache(true).build();
  }
  CacheFieldValueResolver fieldValueResolver = new CacheFieldValueResolver(cache, operation.variables(),
    cacheKeyResolver(), cacheHeaders);
  RealResponseReader<Record> responseReader = new RealResponseReader<>(operation.variables(), rootRecord,
    fieldValueResolver, scalarTypeAdapters, responseNormalizer);
  try {
   responseNormalizer.willResolveRootQuery(operation);
   T data = operation.wrapData(responseFieldMapper.map(responseReader));
   return Response.<T>builder(operation)
     .data(data)
     .fromCache(true)
     .dependentKeys(responseNormalizer.dependentKeys())
     .build();
  } catch (Exception e) {
   logger.e(e, "Failed to read cache response");
   return Response.<T>builder(operation).fromCache(true).build();
  }
 }
});