returns false when a condition is present for which {@link StylingCondition#shouldStyle(java.lang.Object, java.lang.Object)
}
is false

@param data
@param element the value of element
@return
434575
@Override
   public boolean shouldStyle(Object data, Object element) {
      for (StylingCondition sc : conditions) {
         if (!sc.shouldStyle(data, null)) {
            return false;
         }
      }
      return true;
   }
250140
function elementMatchesStyle( element, style ) {
		var def = style.getDefinition(),
			defAttrs = def.attributes,
			defStyles = def.styles,
			attrName, styleName,
			classes, classPattern, cl;

		if ( element.name != def.element )
			return false;

		for ( attrName in defAttrs ) {
			if ( attrName == 'class' ) {
				classes = defAttrs[ attrName ].split( /\s+/ );
				classPattern = element.classes.join( '|' );
				while ( ( cl = classes.pop() ) ) {
					if ( classPattern.indexOf( cl ) == -1 )
						return false;
				}
			} else {
				if ( element.attributes[ attrName ] != defAttrs[ attrName ] )
					return false;
			}
		}

		for ( styleName in defStyles ) {
			if ( element.styles[ styleName ] != defStyles[ styleName ] )
				return false;
		}

		return true;
	}
1292800
public boolean hasAncestor(ElementBase element) {
        ElementBase child = this;
        
        while (child != null) {
            if (element.hasChild(child)) {
                return true;
            }
            child = child.getParent();
        }
        
        return false;
    }
1267300
public static void toggle(HTMLElement element, String css, boolean condition) {
        if (element != null) {
            if (condition) {
                element.classList.add(css);
            } else {
                element.classList.remove(css);
            }
        }
    }
209496
function (element) {
            // Begin with checking the validate
            var elementAsArray = [ element ],
                validationType = element.getAttribute("data-validate") || null;
                invalidElement = [];
            if (validationType !== null) {
                validationType = this.splitStringByComma(validationType);
                for (var i = 0; i < validationType.length; i++) {
                    invalidElement = this.getElementsByPattern(elementAsArray, this.patterns[validationType[i]], validationType[i]);
                    if (invalidElement.length > 0) {
                        this.currentValidationType = validationType[i];
                        return false;
                    }
                }
            }
            // As data-validate="length" has already been checked,
            // only check the elements with data-length set.
            if (element.getAttribute("data-length") === null ||
                validationType !== null && validationType.indexOf("length") !== -1)
                return true;
            validationType = "length";
            invalidElement = this.getElementsByPattern(elementAsArray, this.patterns[validationType], validationType);
            if (invalidElement.length > 0)
                return false;

            return true;
        }
542336
public boolean isEndedBy(final T element) {
        if (element == null) {
            return false;
        }

        return upperEndpoint.isClosed && upperEndpoint.compareTo(element) == 0;
    }
1077587
public static boolean isOverlay(Element element) {

        for (String overlayClass : Arrays.asList(
            I_CmsLayoutBundle.INSTANCE.containerpageCss().expiredOverlay(),
            CmsElementOptionBar.CSS_CLASS)) {
            if (element.hasClassName(overlayClass)) {
                return true;
            }
        }
        return false;

    }
657693
private boolean isValidElement(String element) {

        boolean validateNewElement = Boolean.valueOf(getParamValidateNewElement()).booleanValue();
        if (ALL.equals(getParamTemplate()) || !validateNewElement) {
            return true;
        }

        return isValidTemplateElement(getParamTemplate(), element);
    }
240510
public <E extends Element> E createElementByStyler(Collection<? extends BaseStyler> stylers, Object data, Class<E> clazz) throws VectorPrintException {

      // pdfptable, Section and others do not have a default constructor, a styler creates it
      E e = null;
      return styleHelper.style(e, data, stylers);
   }
1061096
@SuppressWarnings({"unchecked"})
    public final boolean matches(Object item) {
        return item != null
                && expectedType.isInstance(item)
                && matchesSafely((T) item);
    }
165383
private boolean processElementAttributes(Element element) {
    Attributes attributes = element.getAttributes();
    if (attributes == null) {
      return false;
    }

    boolean shouldPopContext = false;
    registerMandatoryAttributes(attributes);

    Attribute vForAttribute = attributes.get("v-for");
    Attribute slotScopeAttribute = attributes.get("slot-scope");
    if (vForAttribute != null || slotScopeAttribute != null) {
      // Add a context layer
      shouldPopContext = true;
      context.addContextLayer(vForAttribute != null);
    }

    if (vForAttribute != null) {
      String processedVForValue = processVForValue(vForAttribute.getValue());
      outputDocument.replace(vForAttribute.getValueSegment(), processedVForValue);
    }

    if (slotScopeAttribute != null) {
      String processedScopedSlotValue = processSlotScopeValue(slotScopeAttribute.getValue());
      outputDocument.replace(slotScopeAttribute.getValueSegment(), processedScopedSlotValue);
    }

    Optional<LocalComponent> localComponent = getLocalComponentForElement(element);

    Attribute refAttribute = attributes.get("ref");
    if (refAttribute != null) {
      result.addRef(
          refAttribute.getValue(),
          localComponent.map(LocalComponent::getComponentType)
              .orElse(getTypeFromDOMElement(element)),
          context.isInVFor()
      );
    }

    Map<String, Class<?>> elementPropertiesType = getPropertiesForDOMElement(element)
        .orElse(new HashMap<>());

    // Iterate on element attributes
    Set<LocalComponentProp> foundProps = new HashSet<>();
    for (Attribute attribute : element.getAttributes()) {
      String key = attribute.getKey();
      if ("v-for".equals(key) || "slot-scope".equals(key)) {
        continue;
      }

      if ("v-model".equals(key)) {
        processVModel(attribute);
        continue;
      }

      Optional<LocalComponentProp> optionalProp =
          localComponent.flatMap(lc -> lc.getPropForAttribute(attribute.getName()));
      optionalProp.ifPresent(foundProps::add);

      if (!VUE_ATTR_PATTERN.matcher(key).matches()) {
        optionalProp.ifPresent(this::validateStringPropBinding);
        continue;
      }

      context.setCurrentSegment(attribute);

      currentAttribute = attribute;
      currentProp = optionalProp.orElse(null);
      currentExpressionReturnType = getExpressionReturnTypeForAttribute(attribute,
          elementPropertiesType);
      String processedExpression = processExpression(attribute.getValue());

      if (attribute.getValueSegment() != null) {
        outputDocument.replace(attribute.getValueSegment(), processedExpression);
      }
    }

    localComponent.ifPresent(lc -> validateRequiredProps(lc, foundProps));

    return shouldPopContext;
  }
54694
public static boolean containsValue(Map<?, ?> data, Object what) {
        return data != null && data.containsValue(what);
    }
57249
public static void applyStyle(Element element, Style style) {
		if (style != null && element != null) {
			if (style instanceof ShapeStyle) {
				applyShapeStyle(element, (ShapeStyle) style);
			} else if (style instanceof FontStyle) {
				FontStyle fontStyle = (FontStyle) style;
				element.getStyle().setProperty("fontSize", "" + fontStyle.getFontSize());
				element.getStyle().setProperty("color", fontStyle.getFillColor());
				element.getStyle().setProperty("fontFamily", fontStyle.getFontFamily());
				element.getStyle().setProperty("fontWeight", fontStyle.getFontWeight());
				element.getStyle().setProperty("fontStyle", fontStyle.getFontStyle());
			} else if (style instanceof PictureStyle) {
				PictureStyle picturStyle = (PictureStyle) style;
				if (SC.isIE()) { //TODO: it's a VML decoder, why make this check?
					element.getStyle().setProperty("filter", "alpha(opacity=" + 100 * picturStyle.getOpacity() + ")");
				} else {
					element.setAttribute("style", "opacity:" + picturStyle.getOpacity() + ";");
				}
			}
		}
	}
648752
public static boolean isPrimitiveWrapper(Element element) {
		if (element == null) {
			return false;
		} else if (element.toString().equals(Boolean.class.getCanonicalName())) {
			return true;
		} else if (element.toString().equals(Integer.class.getCanonicalName())) {
			return true;
		} else if (element.toString().equals(Long.class.getCanonicalName())) {
			return true;
		} else if (element.toString().equals(Byte.class.getCanonicalName())) {
			return true;
		} else if (element.toString().equals(Short.class.getCanonicalName())) {
			return true;
		} else if (element.toString().equals(Character.class.getCanonicalName())) {
			return true;
		} else if (element.toString().equals(Double.class.getCanonicalName())) {
			return true;
		} else if (element.toString().equals(Float.class.getCanonicalName())) {
			return true;
		} else {
			return false;
		}
	}
683162
public static boolean isMainElement( Element element ){
        switch( element.getType() ) {
            case START:
            case END:
            case VALUE:
            case CALL:
            case CALL_ASYNC:
            case HUMAN_TASK:
            case WAIT_SIGNAL:
            case WAIT_TIMER:
            case WAIT_UNTIL_DATE:
            case CREATE_INSTANCE:
            case WHILE_DO_BEGIN:
            case WHILE_DO_END:
            case DO_WHILE_BEGIN:
            case DO_WHILE_END:
            case IF:
            case ELSE_IF:
            case ELSE:
            case END_IF:
            case SPLIT:
            case BRANCH:
            case JOIN_FIRST:
            case JOIN_ALL:
            case ESCALATE:
            case VALIDATE_INPUT_VARIABLE:
                return true;
            default :
                return false;
        }
    }
670767
function(type, data) {
		var test = 'HTML' + (type || '').replace(
			/^[a-z]/,
			function(m) {
				return m.toUpperCase();
			}

		) + 'Element';

		if (!data) {
			return false;
		}

		if (window[test]) {
			return data instanceof window[test];
		}
		else if (window.Element) {
			return data instanceof window.Element && (!type || (data.tagName && data.tagName.toLowerCase() === type));
		}
		else {
			return (!(data instanceof Object || data instanceof Array || data instanceof String || data instanceof Number) && data.tagName && data.tagName.toLowerCase() === type);
		}
	}
181365
public boolean contains(final T element) {
        if (element == null) {
            return false;
        }

        return lowerEndpoint.includes(element) && upperEndpoint.includes(element);
    }