Skip to content

Refactor ParseFieldOperations and give its own class #676

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jun 1, 2017
Merged

Refactor ParseFieldOperations and give its own class #676

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
481a86f
Refactor ParseFieldOperations
natario1 Jun 1, 2017
e5a7764
Merge branch 'master' into parsefieldoperations-class
natario1 Jun 1, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
233 changes: 0 additions & 233 deletions Parse/src/main/java/com/parse/ParseFieldOperation.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -81,236 +81,3 @@
Object apply(Object oldValue, String key);
}

final class ParseFieldOperations {
private ParseFieldOperations() {
}

/**
* A function that creates a ParseFieldOperation from a JSONObject or a Parcel.
*/
private interface ParseFieldOperationFactory {
ParseFieldOperation decode(JSONObject object, ParseDecoder decoder) throws JSONException;
ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder);
}

// A map of all known decoders.
private static Map<String, ParseFieldOperationFactory> opDecoderMap = new HashMap<>();

/**
* Registers a single factory for a given __op field value.
*/
private static void registerDecoder(String opName, ParseFieldOperationFactory factory) {
opDecoderMap.put(opName, factory);
}

/**
* Registers a list of default decoder functions that convert a JSONObject with an __op field,
* or a Parcel with a op name string, into a ParseFieldOperation.
*/
static void registerDefaultDecoders() {
registerDecoder(ParseRelationOperation.OP_NAME_BATCH, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
ParseFieldOperation op = null;
JSONArray ops = object.getJSONArray("ops");
for (int i = 0; i < ops.length(); ++i) {
ParseFieldOperation nextOp = ParseFieldOperations.decode(ops.getJSONObject(i), decoder);
op = nextOp.mergeWithPrevious(op);
}
return op;
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
// Decode AddRelation and then RemoveRelation
ParseFieldOperation add = ParseFieldOperations.decode(source, decoder);
ParseFieldOperation remove = ParseFieldOperations.decode(source, decoder);
return remove.mergeWithPrevious(add);
}
});

registerDecoder(ParseDeleteOperation.OP_NAME, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
return ParseDeleteOperation.getInstance();
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
return ParseDeleteOperation.getInstance();
}
});

registerDecoder(ParseIncrementOperation.OP_NAME, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
return new ParseIncrementOperation((Number) decoder.decode(object.opt("amount")));
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
return new ParseIncrementOperation((Number) decoder.decode(source));
}
});

registerDecoder(ParseAddOperation.OP_NAME, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
return new ParseAddOperation((Collection) decoder.decode(object.opt("objects")));
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
int size = source.readInt();
List<Object> list = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
list.set(i, decoder.decode(source));
}
return new ParseAddOperation(list);
}
});

registerDecoder(ParseAddUniqueOperation.OP_NAME, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
return new ParseAddUniqueOperation((Collection) decoder.decode(object.opt("objects")));
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
int size = source.readInt();
List<Object> list = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
list.set(i, decoder.decode(source));
}
return new ParseAddUniqueOperation(list);
}
});

registerDecoder(ParseRemoveOperation.OP_NAME, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
return new ParseRemoveOperation((Collection) decoder.decode(object.opt("objects")));
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
int size = source.readInt();
List<Object> list = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
list.set(i, decoder.decode(source));
}
return new ParseRemoveOperation(list);
}
});

registerDecoder(ParseRelationOperation.OP_NAME_ADD, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
JSONArray objectsArray = object.optJSONArray("objects");
List<ParseObject> objectsList = (List<ParseObject>) decoder.decode(objectsArray);
return new ParseRelationOperation<>(new HashSet<>(objectsList), null);
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
int size = source.readInt();
Set<ParseObject> set = new HashSet<>(size);
for (int i = 0; i < size; i++) {
set.add((ParseObject) decoder.decode(source));
}
return new ParseRelationOperation<>(set, null);
}
});

registerDecoder(ParseRelationOperation.OP_NAME_REMOVE, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder)
throws JSONException {
JSONArray objectsArray = object.optJSONArray("objects");
List<ParseObject> objectsList = (List<ParseObject>) decoder.decode(objectsArray);
return new ParseRelationOperation<>(null, new HashSet<>(objectsList));
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
int size = source.readInt();
Set<ParseObject> set = new HashSet<>(size);
for (int i = 0; i < size; i++) {
set.add((ParseObject) decoder.decode(source));
}
return new ParseRelationOperation<>(null, set);
}
});

registerDecoder(ParseSetOperation.OP_NAME, new ParseFieldOperationFactory() {
@Override
public ParseFieldOperation decode(JSONObject object, ParseDecoder decoder) throws JSONException {
return null; // Not called.
}

@Override
public ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
return new ParseSetOperation(decoder.decode(source));
}
});
}

/**
* Converts a parsed JSON object into a ParseFieldOperation.
*
* @param encoded
* A JSONObject containing an __op field.
* @return A ParseFieldOperation.
*/
static ParseFieldOperation decode(JSONObject encoded, ParseDecoder decoder) throws JSONException {
String op = encoded.optString("__op");
ParseFieldOperationFactory factory = opDecoderMap.get(op);
if (factory == null) {
throw new RuntimeException("Unable to decode operation of type " + op);
}
return factory.decode(encoded, decoder);
}

/**
* Reads a ParseFieldOperation out of the given Parcel.
*
* @param source
* The source Parcel.
* @param decoder
* The given ParseParcelableDecoder.
*
* @return A ParseFieldOperation.
*/
static ParseFieldOperation decode(Parcel source, ParseParcelDecoder decoder) {
String op = source.readString();
ParseFieldOperationFactory factory = opDecoderMap.get(op);
if (factory == null) {
throw new RuntimeException("Unable to decode operation of type " + op);
}
return factory.decode(source, decoder);
}

/**
* Converts a JSONArray into an ArrayList.
*/
static ArrayList<Object> jsonArrayAsArrayList(JSONArray array) {
ArrayList<Object> result = new ArrayList<>(array.length());
for (int i = 0; i < array.length(); ++i) {
try {
result.add(array.get(i));
} catch (JSONException e) {
// This can't actually happen.
throw new RuntimeException(e);
}
}
return result;
}
}
Loading