com.google.firebase.database.snapshot.NodeUtilities Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of firebase-admin Show documentation
This is the official Firebase Admin Java SDK. Build extraordinary native JVM apps in minutes with Firebase. The Firebase platform can power your app’s backend, user authentication, static hosting, and more.
There is a newer version: 9.4.1
Show newest version
/*
 * Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.firebase.database.snapshot;

import com.google.firebase.database.DatabaseException;
import com.google.firebase.database.collection.ImmutableSortedMap;
import com.google.firebase.database.core.ServerValues;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/** Utility functions to convert Node data to and from JSON. */
public class NodeUtilities {

  // CSOFF: MethodName
  public static Node NodeFromJSON(Object value) throws DatabaseException {
    return NodeFromJSON(value, PriorityUtilities.NullPriority());
  }

  public static Node NodeFromJSON(Object value, Node priority) throws DatabaseException {
    try {
      if (value instanceof Map) {
        Map mapValue = (Map) value;
        if (mapValue.containsKey(".priority")) {
          priority = PriorityUtilities.parsePriority(mapValue.get(".priority"));
        }

        if (mapValue.containsKey(".value")) {
          value = mapValue.get(".value");
        }
      }

      if (value == null) {
        return EmptyNode.Empty();
      } else if (value instanceof String) {
        return new StringNode((String) value, priority);
      } else if (value instanceof Long) {
        return new LongNode((Long) value, priority);
      } else if (value instanceof Integer) {
        return new LongNode((long) (Integer) value, priority);
      } else if (value instanceof Double) {
        return new DoubleNode((Double) value, priority);
      } else if (value instanceof Boolean) {
        return new BooleanNode((Boolean) value, priority);
      } else if (value instanceof Map || value instanceof List) {
        Map childData;
        // TODO: refine this and use same code to iterate over array and map by building
        // List
        if (value instanceof Map) {
          Map mapValue = (Map) value;
          if (mapValue.containsKey(ServerValues.NAME_SUBKEY_SERVERVALUE)) {
            @SuppressWarnings("unchecked")
            Node node = new DeferredValueNode(mapValue, priority);
            return node;
          } else {
            childData = new HashMap<>(mapValue.size());
            @SuppressWarnings("unchecked")
            Iterator keyIter = mapValue.keySet().iterator();
            while (keyIter.hasNext()) {
              String key = keyIter.next();
              if (!key.startsWith(".")) {
                Node childNode = NodeFromJSON(mapValue.get(key));
                if (!childNode.isEmpty()) {
                  ChildKey childKey = ChildKey.fromString(key);
                  childData.put(childKey, childNode);
                }
              }
            }
          }
        } else { // List
          List listValue = (List) value;
          childData = new HashMap<>(listValue.size());
          for (int i = 0; i < listValue.size(); ++i) {
            String key = "" + i;
            Node childNode = NodeFromJSON(listValue.get(i));
            if (!childNode.isEmpty()) {
              ChildKey childKey = ChildKey.fromString(key);
              childData.put(childKey, childNode);
            }
          }
        }

        if (childData.isEmpty()) {
          return EmptyNode.Empty();
        } else {
          ImmutableSortedMap childSet =
              ImmutableSortedMap.Builder.fromMap(childData, ChildrenNode.NAME_ONLY_COMPARATOR);
          return new ChildrenNode(childSet, priority);
        }
      } else {
        throw new DatabaseException(
            "Failed to parse node with class " + value.getClass().toString());
      }
    } catch (ClassCastException e) {
      throw new DatabaseException("Failed to parse node", e);
    }
  }
  // CSON: MethodName

  public static int nameAndPriorityCompare(
      ChildKey key1, Node priority1, ChildKey key2, Node priority2) {

    int priCmp = priority1.compareTo(priority2);
    if (priCmp != 0) {
      return priCmp;
    } else {
      return key1.compareTo(key2);
    }
  }
}