Checks if given group property is defined within given Hazelcast properties. Logs a warning when the property is defied.

@return {@code true} when the property is defined
327057
public static boolean checkAndLogPropertyDeprecated(HazelcastProperties properties, HazelcastProperty hazelcastProperty) {
        if (properties.containsKey(hazelcastProperty)) {
            LOGGER.warning(
                    "Property " + hazelcastProperty.getName() + " is deprecated. Use configuration object/element instead.");
            return properties.getBoolean(hazelcastProperty);
        }
        return false;
    }
518518
function groupExists(group) {
  if (isPlatform('windows')) {
    throw new Error('Don\'t know how to check for group existence on Windows');
  } else {
    if (_.isEmpty(findGroup(group, {refresh: true, throwIfNotFound: false}))) {
      return false;
    } else {
      return true;
    }
  }
}
953322
public final boolean hasProperty(final String property) {
    final String val = properties.get(property);
    if (val == null)
      return false;
    if (val.isEmpty())
      return false;
    return true;
  }
970768
private static boolean propertyIsImplicitCast(ObjectType type, String prop) {
    for (; type != null; type = type.getImplicitPrototype()) {
      JSDocInfo docInfo = type.getOwnPropertyJSDocInfo(prop);
      if (docInfo != null && docInfo.isImplicitCast()) {
        return true;
      }
    }
    return false;
  }
882653
private function isPropertyRequired(\ReflectionProperty $property, array $groups)
    {
        if (!$this->validator) {
            // Can not check...
            return true;
        }

        $metadata = $this->validator->getMetadataFor($property->getDeclaringClass()->getName());

        if (!$metadata instanceof ClassMetadata) {
            return true;
        }

        $propertyMetadata = $metadata->getPropertyMetadata($property->getName());

        if ($propertyMetadata) {
            // @todo: merge all metadata?
            $propertyMetadata = array_pop($propertyMetadata);

            foreach ($groups as $group) {
                $constraints = $propertyMetadata->findConstraints($group);

                foreach ($constraints as $constraint) {
                    if ($constraint instanceof NotBlank) {
                        return true;
                    }
                }
            }
        }

        return false;
    }
191056
function checkConsistency(node, checkRedundancy) {

            // We are excluding getters/setters and spread properties as they are considered neither longform nor shorthand.
            const properties = node.properties.filter(canHaveShorthand);

            // Do we still have properties left after filtering the getters and setters?
            if (properties.length > 0) {
                const shorthandProperties = properties.filter(isShorthand);

                /*
                 * If we do not have an equal number of longform properties as
                 * shorthand properties, we are using the annotations inconsistently
                 */
                if (shorthandProperties.length !== properties.length) {

                    // We have at least 1 shorthand property
                    if (shorthandProperties.length > 0) {
                        context.report({ node, message: "Unexpected mix of shorthand and non-shorthand properties." });
                    } else if (checkRedundancy) {

                        /*
                         * If all properties of the object contain a method or value with a name matching it's key,
                         * all the keys are redundant.
                         */
                        const canAlwaysUseShorthand = properties.every(isRedundant);

                        if (canAlwaysUseShorthand) {
                            context.report({ node, message: "Expected shorthand for all properties." });
                        }
                    }
                }
            }
        }
706320
public boolean containsValue(String group, String value) {
		group = StrUtil.nullToEmpty(group).trim();
		readLock.lock();
		try {
			final LinkedHashMap<String, String> valueMap = this.get(group);
			if (MapUtil.isNotEmpty(valueMap)) {
				return valueMap.containsValue(value);
			}
		} finally {
			readLock.unlock();
		}
		return false;
	}
1116405
public final boolean isPropertyTypeDeclared(String propertyName) {
    StaticTypedSlot slot = getSlot(propertyName);
    return slot == null ? false : !slot.isTypeInferred();
  }
969547
private boolean isNewGroup(final OptGroup currentOptGroup)
	{
		return (last == null) || !currentOptGroup.getLabel().equals(last.getLabel());
	}
1060961
public static boolean isStringSet(PrefsProperty property) {
		boolean isStringSet = false;

		TypeName typeName;
		if (property.hasTypeAdapter()) {
			typeName = TypeUtility.typeName(property.typeAdapter.dataType);
		} else {
			typeName = TypeUtility.typeName(property.getElement().asType());
		}

		// it is parameterized type name for sure

		if (typeName instanceof ParameterizedTypeName && TypeUtility.isSet(typeName)) {
			ParameterizedTypeName parameterizedTypeName = (ParameterizedTypeName) typeName;
			if (TypeUtility.isEquals(parameterizedTypeName.typeArguments.get(0), String.class.getCanonicalName())) {
				isStringSet = true;
			}
		}

		return isStringSet;
	}
1259822
public boolean isSupported(TypeDesc propertyType) {
        if (propertyType.toPrimitiveType() != null) {
            return true;
        }
        if (propertyType == TypeDesc.STRING || propertyType == TypeDesc.forClass(byte[].class)) {
            return true;
        }
        Class clazz = propertyType.toClass();
        if (clazz != null) {
            return Lob.class.isAssignableFrom(clazz) ||
                BigInteger.class.isAssignableFrom(clazz) ||
                BigDecimal.class.isAssignableFrom(clazz);
        }
        return false;
    }
1186307
public final boolean defineSynthesizedProperty(String propertyName,
      JSType type, Node propertyNode) {
    return defineProperty(propertyName, type, false, propertyNode);
  }
668446
public static boolean isIndexedProperty(String propertyName) {
       return propertyName.indexOf(PropertyAccessor.PROPERTY_KEY_PREFIX_CHAR) != -1
           && propertyName.charAt(propertyName.length() - 1) == PropertyAccessor.PROPERTY_KEY_SUFFIX_CHAR;
   }
362805
public boolean containsPropertySet(Class<? extends Annotation> propertySet)
    {
        //
        // Defer to any delegate map
        //
        if (_delegateMap != null)
            return _delegateMap.containsPropertySet(propertySet);

        return false;
    }
449287
@Override
    public boolean isChannelDeepMemberOf(String fname, String groupKey) {
        final IEntityGroup distinguishedGroup = GroupService.findGroup(groupKey);
        if (distinguishedGroup == null) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("No group found for key '" + groupKey + "'");
            }

            return false;
        }

        final IPortletDefinition portletDefinition;
        try {
            portletDefinition = this.portletDefinitionRegistry.getPortletDefinitionByFname(fname);
        } catch (Exception e) {
            this.logger.warn(
                    "Caught exception while retrieving portlet definition for fname '"
                            + fname
                            + "'",
                    e);
            return false;
        }

        if (portletDefinition == null) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("No portlet found for key '" + fname + "'");
            }

            return false;
        }

        final String portletId = portletDefinition.getPortletDefinitionId().getStringId();
        final IEntity entity = GroupService.getEntity(portletId, IPortletDefinition.class);
        if (entity == null) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("No portlet found for id '" + portletId + "'");
            }

            return false;
        }

        return distinguishedGroup.deepContains(entity);
    }
40702
private boolean verifyDefine(NodeTraversal t, Node parent, Node methodName, Node args) {
    // Calls to goog.define must be in the global hoist scope.  This is copied from
    // validate(Un)aliasablePrimitiveCall.
    // TODO(sdh): loosen this restriction if the results are assigned?
    if (!compiler.getOptions().shouldPreserveGoogModule() && !t.inGlobalHoistScope()) {
      compiler.report(JSError.make(methodName.getParent(), INVALID_CLOSURE_CALL_SCOPE_ERROR));
      return false;
    }

    // It is an error for goog.define to show up anywhere except on its own or immediately after =.
    if (parent.isAssign() && parent.getParent().isExprResult()) {
      parent = parent.getParent();
    } else if (parent.isName() && NodeUtil.isNameDeclaration(parent.getParent())) {
      parent = parent.getParent();
    } else if (!parent.isExprResult()) {
      compiler.report(JSError.make(methodName.getParent(), INVALID_CLOSURE_CALL_SCOPE_ERROR));
      return false;
    }

    // Verify first arg
    Node arg = args;
    if (!verifyNotNull(methodName, arg) || !verifyOfType(methodName, arg, Token.STRING)) {
      return false;
    }

    // Verify second arg
    arg = arg.getNext();
    if (!args.isFromExterns()
        && (!verifyNotNull(methodName, arg) || !verifyIsLast(methodName, arg))) {
      return false;
    }

    String name = args.getString();
    if (!NodeUtil.isValidQualifiedName(
        compiler.getOptions().getLanguageIn().toFeatureSet(), name)) {
      compiler.report(JSError.make(args, INVALID_DEFINE_NAME_ERROR, name));
      return false;
    }

    JSDocInfo info = (parent.isExprResult() ? parent.getFirstChild() : parent).getJSDocInfo();
    if (info == null || !info.isDefine()) {
      compiler.report(JSError.make(parent, MISSING_DEFINE_ANNOTATION));
      return false;
    }
    return true;
  }
546231
public boolean isExact(Group group) {
    if (isAnyAgent() && group.isAnyAgent()) return true;
    if ((isAnyAgent() && !group.isAnyAgent() || (!isAnyAgent() && group.isAnyAgent()))) return false;

    return group.userAgents.stream().anyMatch(sectionUserAgent->userAgents.stream().anyMatch(userAgent->userAgent.equalsIgnoreCase(sectionUserAgent)));
  }