Find list parent validation data.

@return the validation data
353865
public ValidationData findListParent() {
        if (!this.listChild) {
            return null;
        }

        ValidationData parent = this.parent;
        while (parent != null && !parent.isList()) {
            parent = parent.parent;
        }
        return parent;
    }
656170
DatanodeDescriptor[] getValidTargets() {
    if (targetGSs == null) {
      return null;
    }
    int count = 0;
    long lastBlockGS = this.getLastBlock().getGenerationStamp();
    for (long targetGS : targetGSs) {
      if (lastBlockGS == targetGS) {
        count++;
      }
    }
    if (count == 0) {
      return null;
    } if (count == targets.length) {
      return targets;
    } else {
      DatanodeDescriptor[] validTargets = new DatanodeDescriptor[count];
      for (int i=0, numOfValidTargets=0; i<targets.length; i++) {
        if (lastBlockGS == targetGSs[i]) {
          validTargets[numOfValidTargets++] = targets[i];
          if (numOfValidTargets == count) {
            return validTargets;
          }
        }
      }
      return validTargets;
    }
  }
604146
def validate_parents
      parent_relationships.each do |relationship|
        parent = relationship.get(self)
        unless parent.valid?
          unless errors[relationship.name].include?(parent.errors)
            errors[relationship.name] = parent.errors
          end
        end
      end
    end
604001
@Override
    public List<String> getRolesAllowed()
    {
        return ivRolesAllowed == null ? Collections.<String> emptyList() : Arrays.asList(ivRolesAllowed);
    }
1295022
public Map<String, Map<String, Map<String, Map<String, ?>>>> validationConstraints() {
		return getEntity(invokeGet("_constraints", null), Map.class);
	}
1093884
@Override
	public List<ParsingError> doValidate() {

		List<ParsingError> result = new ArrayList<> ();
		if( Utils.isEmptyOrWhitespaces( this.newInstanceName ))
			result.add( error( ErrorCode.CMD_MISSING_INSTANCE_NAME ));
		else if( ! this.newInstanceName.matches( ParsingConstants.PATTERN_FLEX_ID ))
			result.add( error( ErrorCode.CMD_INVALID_INSTANCE_NAME, name( this.newInstanceName )));

		if( ! this.context.instanceExists( this.instancePath )) {
			result.add( error( ErrorCode.CMD_NO_MATCHING_INSTANCE, instance( this.instancePath )));

		} else {
			String parentInstancePath = this.instancePath.replaceFirst( "/[^/]+$", "" );
			String siblingPath = parentInstancePath + "/" + this.newInstanceName;
			if( this.context.instanceExists( siblingPath ))
				result.add( error( ErrorCode.CMD_CONFLICTING_INSTANCE_NAME, conflicting( siblingPath )));
		}

		return result;
	}
160125
public Map getRootData() {
		for (Scope cur=this; true; cur=cur.parent) {
			if (cur.parent == null) {
				return cur.data;
			}
		}
	}
1069470
public List<MessageValidator<? extends ValidationContext>> findMessageValidators(String messageType, Message message) {
        List<MessageValidator<? extends ValidationContext>> matchingValidators = new ArrayList<>();

        for (MessageValidator<? extends ValidationContext> validator : messageValidators) {
            if (validator.supportsMessageType(messageType, message)) {
                matchingValidators.add(validator);
            }
        }

        if (matchingValidators.isEmpty() || matchingValidators.stream().allMatch(validator -> DefaultMessageHeaderValidator.class.isAssignableFrom(validator.getClass()))) {
            // try to find fallback message validator for given message payload
            if (message.getPayload() instanceof String &&
                    StringUtils.hasText(message.getPayload(String.class))) {
                String payload = message.getPayload(String.class).trim();

                if (payload.startsWith("<") && !messageType.equals(MessageType.XML.name())) {
                    matchingValidators = findFallbackMessageValidators(MessageType.XML.name(), message);
                } else if ((payload.trim().startsWith("{") || payload.trim().startsWith("[")) && !messageType.equals(MessageType.JSON.name())) {
                    matchingValidators = findFallbackMessageValidators(MessageType.JSON.name(), message);
                } else if (!messageType.equals(MessageType.PLAINTEXT.name())) {
                    matchingValidators = findFallbackMessageValidators(MessageType.PLAINTEXT.name(), message);
                }
            }
        }

        if (matchingValidators.isEmpty() || matchingValidators.stream().allMatch(validator -> DefaultMessageHeaderValidator.class.isAssignableFrom(validator.getClass()))) {
            throw new CitrusRuntimeException("Could not find proper message validator for message type '" +
                    messageType + "', please define a capable message validator for this message type");
        }

        if (log.isDebugEnabled()) {
            log.debug(String.format("Found %s message validators for message type: %s", matchingValidators.size(), messageType));
        }
        
        return matchingValidators;
    }
1238496
public List<ValidationData> saveAll(List<ValidationData> pDatas) {
        pDatas.forEach(this::save);
        return pDatas;
    }
689111
public List<Object> match() {
        final IntMatchResults result = new IntMatchResults();
        if (matches(result)) {
            return result.getIntResultList();
        } else {
            return null;
        }
    }
580193
public static List<ReqUrl> getUrlListFromValidationDatas(List<ValidationData> datas) {
        Map<String, ReqUrl> urlMap = new HashMap<>();
        datas.stream().forEach(data -> {
            ReqUrl url = new ReqUrl(data);
            urlMap.put(url.getUniqueKey(), url);
        });

        return urlMap.entrySet().stream().map(entry -> entry.getValue()).collect(Collectors.toList());
    }
706629
public List<String> getStringChildren(Long parentId) {
		ArrayList<String> strings = new ArrayList<>();
		List<StringEntity> entities = getByField(Column.PARENT_ID, parentId);
		for (StringEntity entity : entities) {
			strings.add(entity.getValue());
		}
		return strings;
	}
629125
public java.util.List<ValidationWarning> getValidationWarnings() {
        if (validationWarnings == null) {
            validationWarnings = new com.amazonaws.internal.SdkInternalList<ValidationWarning>();
        }
        return validationWarnings;
    }
1151575
@Pure
	public List<Object> getCurrentValues() {
		if (this.allValues == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableList(this.allValues);
	}
78890
public List<BeanType<ValidationMappingDescriptor>> getAllBean()
   {
      List<BeanType<ValidationMappingDescriptor>> list = new ArrayList<BeanType<ValidationMappingDescriptor>>();
      List<Node> nodeList = model.get("bean");
      for(Node node: nodeList)
      {
         BeanType<ValidationMappingDescriptor>  type = new BeanTypeImpl<ValidationMappingDescriptor>(this, "bean", model, node);
         list.add(type);
      }
      return list;
   }
754543
protected List<PropertyData> getChildProps(String parentId, boolean withValue)
   {
      return getChildProps.run(parentId, withValue);
   }
343276
public List<ValidationError> validateInput() {
        List<ValidationError> errors = new ArrayList<ValidationError>();

        for (FormSectionController section : getSections()) {
            for (FormElementController element : section.getElements()) {
                if (element instanceof LabeledFieldController) {
                    LabeledFieldController field = (LabeledFieldController)element;
                    errors.addAll(field.validateInput());
                }
            }
        }

        return errors;
    }