-- non-null, non-String object
177429
private void object(Class<?> type, Object obj, int limit) {
        Class<?>[] types;
        Object[] objects;
        int i;
        CustomCompiler decl;
        int oldSize;
        int used;  // number of instructions actually generated
        int localLimit;

        int initialSize;
        int initialLimit;

        initialSize = dest.getSize();
        initialLimit = limit;

        decl = findDecl(obj.getClass());
        types = decl.getFieldTypes();
        objects = decl.getFieldObjects(obj);
        if (limit < MIN_INSTRUCTIONS + types.length * 1 + MIN_INSTRUCTIONS) {
            // I need the static type, not the dynamic type of the object
            pushMethod(type);
            object(type, obj, MAX_INSTRUCTIONS);
            popMethod();
            return;
        }

        oldSize = dest.getSize();
        decl.beginTranslation(obj, dest);
        used = dest.getSize() - oldSize;
        if (used > MIN_INSTRUCTIONS) {
            throw new IllegalStateException();
        }
        limit -= used;
        for (i = 0; i < types.length; i++) {
            localLimit = limit - (types.length - i - 1) - MIN_INSTRUCTIONS;
            oldSize = dest.getSize();
            run(types[i], objects[i], localLimit);
            used = dest.getSize() - oldSize;
            if (used > localLimit) {
                throw new IllegalStateException("used:" + used + " localLimit:" + localLimit
                                        + " ele:" + objects[i]);
            }
            limit -= used;
        }
        if (limit < MIN_INSTRUCTIONS) {
            throw new IllegalStateException();
        }
        oldSize = dest.getSize();
        decl.endTranslation(obj, dest);
        if (dest.getSize() - oldSize > MIN_INSTRUCTIONS) {
            throw new IllegalStateException();
        }

        if (dest.getSize() - initialSize > initialLimit) {
            throw new IllegalStateException();
        }
    }
948029
@Nonnull
  public static <T> T checkNotNull(@Nullable T obj) {
    return checkNotNull(obj, NPE_DEFAULT_MSG);
  }
452352
@Trivial
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        GetField fields = in.readFields();
        domain = (String) fields.get(DOMAIN, null);
        id = (String) fields.get(ID, null);
    }
1051863
public static void notNull(final Object object, final String objectName) {
        if (object == null) {
            throw new IllegalArgumentException("expecting non-null value for " + maskNullArgument(objectName));
        }
    }
1054108
@SuppressWarnings("unchecked")
	public JSONNavi<T> object() {
		if (failure)
			return this;
		if (current == null && readonly)
			failure("Can not create Object child in readonly", null);
		if (current != null) {
			if (isObject())
				return this;
			if (isArray())
				failure("can not use Object feature on Array.", null);
			failure("Can not use current possition as Object", null);
		} else {
			current = mapper.createObject();
		}
		if (root == null)
			root = (T) current;
		else
			store();
		return this;
	}
618560
function(object) {
    if (!this.stringify) return JSON.stringify(object);

    return this.stringify(object, function(key, value) {
      return (this[key] instanceof Array) ? this[key] : value;
    });
  }
334327
public <T> T notNull(final T object, final String message) {
        if (object == null) {
            failNull(message);
        }
        return object;
    }
205285
public static void dumpNonNull(String name, Object obj, StringPrinter printer) {
		dumpIf(name, obj, Predicates.alwaysTrue(), entry -> entry.getValue() != null, printer);
	}
801199
public static void notNull(Object object, String message) {
        if (object == null)
            throw new IllegalArgumentException(message);
        /*
        * 如果是字符串，我不希望你的字符串是一个空字符串，那样没有任何意义，
        * 但是你仍然坚持要为空，那你可以添加一个空格(" ")试试
        * */
        if (object instanceof String)
            if (StringUtils.isEmpty((String) object))
                throw new IllegalArgumentException(message);
    }
3122
function(object) {
            // three special objects that we want to treat differently
            if(object == null) {
                return "null";
            }
            if(object.constructor == Date) {
                return this.serialize.date.apply(this, [object]);
            }
            if(object.constructor == Array) {
                return this.serialize.array.apply(this, [object]);
            }
            var pieces = ['{'];
            this.level += 1;
            var key, keyJSON, valueJSON;
            
            var addComma = false;
            for(key in object) {
                if(object.hasOwnProperty(key)) {
                    // recursive calls need to allow for sub-classing
                    keyJSON = OpenLayers.Format.JSON.prototype.write.apply(this,
                                                    [key, this.pretty]);
                    valueJSON = OpenLayers.Format.JSON.prototype.write.apply(this,
                                                    [object[key], this.pretty]);
                    if(keyJSON != null && valueJSON != null) {
                        if(addComma) {
                            pieces.push(',');
                        }
                        pieces.push(this.writeNewline(), this.writeIndent(),
                                    keyJSON, ':', this.writeSpace(), valueJSON);
                        addComma = true;
                    }
                }
            }
            
            this.level -= 1;
            pieces.push(this.writeNewline(), this.writeIndent(), '}');
            return pieces.join('');
        }
951536
private static Optional<ICondition> asNot( JsonObject json)
    {
    return
      json.containsKey( NOT_KEY)
      ? Optional.of( new Not( asCondition( json.getJsonObject( NOT_KEY))))
      : Optional.empty();
    }
905305
void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
        // when deserializing, parse the json string
        try {
            int length = in.readInt();
            byte[] buf = new byte[length];
            in.readFully(buf);
            if (parser == null) {
                // create it lazily, static so won't increase object size
                parser = new JsonParser();
            }
            JsonElement o = parser.parse(new String(buf, StandardCharsets.UTF_8));
            Field f = getClass().getDeclaredField("intMap");
            f.setAccessible(true);
            f.set(this, new SimpleIntKeyMap<>());

            for (Entry<String, JsonElement> e : o.asObject().entrySet()) {
                put(e.getKey(), e.getValue());
            }
        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
            throw new IllegalStateException(e);
        }
    }
243578
function(a){
// Not plain objects:
// - Any object or value whose internal [[Class]] property is not "[object Object]"
// - DOM nodes
// - window
// Not plain objects:
// - Any object or value whose internal [[Class]] property is not "[object Object]"
// - DOM nodes
// - window
return!("object"!=typeof a||a.nodeType||null!==a&&a===a.window)&&!(a.constructor&&!Object.prototype.hasOwnProperty.call(a.constructor.prototype,"isPrototypeOf"))}
623236
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();
		final N me = toN();
		if (this.nNorthEast != null) {
			this.nNorthEast.setParentNodeReference(me, false);
		}
		if (this.nNorthWest != null) {
			this.nNorthWest.setParentNodeReference(me, false);
		}
		if (this.nSouthEast != null) {
			this.nSouthEast.setParentNodeReference(me, false);
		}
		if (this.nSouthWest != null) {
			this.nSouthWest.setParentNodeReference(me, false);
		}
	}
949558
public static <T> T notNull(final T object, final String message) {
        return INSTANCE.notNull(object, message);
    }
753775
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        java.io.ObjectInputStream.GetField fields = s.readFields();
        char[] value = (char[])fields.get("value", null);
        int count = fields.get("count", 0);
        append(value, 0, count);
    }
26028
public static boolean isNull(Object object) {
    // don't call nullOf because will throw IllegalArgumentException if cannot create instance
    return object != null && object == NULL_CACHE.get(object.getClass());
  }