Check data inner rules.

@param data    the data
@param bodyObj the body obj
346214
public void checkDataInnerRules(ValidationData data, Object bodyObj) {
        data.getValidationRules().stream().filter(vr -> vr.isUse()).forEach(rule -> {
            if (data.isListChild()) {
                this.checkPointListChild(data, rule, bodyObj, rule.getStandardValue());
            } else {
                this.checkPoint(data, rule, bodyObj, rule.getStandardValue());
            }
        });
    }
476488
private static void examineOperatingSystem(final UserAgent.Builder builder, final Data data) {
		if (net.sf.uadetector.OperatingSystem.EMPTY.equals(builder.getOperatingSystem())) {
			for (final Entry<OperatingSystemPattern, OperatingSystem> entry : data.getPatternToOperatingSystemMap().entrySet()) {
				final Matcher matcher = entry.getKey().getPattern().matcher(builder.getUserAgentString());
				if (matcher.find()) {
					entry.getValue().copyTo(builder);
					break;
				}
			}
		}
	}
651210
function BusinessRules(Data) {
            this.Data = Data;
            this.MainValidator = this.createMainValidator().CreateRule("Data");

            this.ValidationResult = this.MainValidator.ValidationResult;
            this.HobbiesNumberValidator = this.MainValidator.Validators["Hobbies"];
        }
552869
public void newDataReady(DataType data) {
		ArrayList<Runnable> list;
		synchronized (this) {
			if (end) throw new IllegalStateException("method endOfData already called, method newDataReady is not allowed anymore");
			waitingData.addLast(data);
			list = listeners;
			listeners = null;
		}
		if (list != null) {
			for (Runnable listener : list) listener.run();
		}
		// notify after listeners
		synchronized (this) {
			this.notify();
		}
	}
948234
protected void addHttpData(InterfaceHttpData data) {
        if (data == null) {
            return;
        }
        List<InterfaceHttpData> datas = bodyMapHttpData.get(data.getName());
        if (datas == null) {
            datas = new ArrayList<InterfaceHttpData>(1);
            bodyMapHttpData.put(data.getName(), datas);
        }
        datas.add(data);
        bodyListHttpData.add(data);
    }
938836
@Override
	public void body() {

		IMessageEvent msg = (IMessageEvent) getReason();
		String content = (String) msg.getParameter("content").getValue();
		if (content.equalsIgnoreCase("NewRecordedCall")) {
			Report report = new Report();

			this.getBeliefbase().getBelief("report").setFact(report);
			this.getBeliefbase().getBelief("createdIssueReport").setFact(true);
		}

	}
250967
public void apply(HashMap<String, Object> data) {
        for (HashMap<String, String> rule : rules) {
            if (!isSWExtracted || (!isSoilRules(rule) && !isWthRules(rule))) {
                applyRule(data, rule);
            }
        }
    }
1252458
private void validateEntities(JsonNode data) throws InvalidInputException {
    for (JsonNode node : data.findParents(INDEX_START)) {

      for (String key : new String[] {INDEX_START, INDEX_END, ID, TYPE}) {
        if (node.path(key).isMissingNode()) {
          throw new InvalidInputException("Required field \"" + key + "\" missing from the entity payload");
        }
      }

      int startIndex = node.get(INDEX_START).intValue();
      int endIndex = node.get(INDEX_END).intValue();

      if (endIndex <= startIndex) {
        throw new InvalidInputException(String.format("Invalid entity payload: %s (start index: %s, end index: %s)",
            node.get(ID).textValue(), startIndex, endIndex));
      }

    }
  }
426161
public void setData(byte[] data) {
        // There are always two bytes of payload in the message -- the
        // slave ID and the run status indicator.
        if (data == null) {
            m_length = 2;
            m_data = new byte[0];

            return;
        }

        if (data.length > 249) {
            throw new IllegalArgumentException("data length limit exceeded");
        }

        m_length = data.length + 2;

        m_data = new byte[data.length];
        System.arraycopy(data, 0, m_data, 0, data.length);
    }
1250770
public void setBody(String body)
    {
    	String xbody = body;
    	String [] row = xbody.split("\n");
    	for(int i=0; i<row.length; i++){
    		this.m_xbody.add(row[i]);
    	}
    }
222574
public void setData(JSONObject data) {
    try {
      Map<String, Object> map = new HashMap<String, Object>();
      Iterator iter = data.keySet().iterator();
      while (iter.hasNext()) {
        String key = (String) iter.next();
        Object value = data.get(key);
        map.put(key, value);
      }
      this.pushData.put("data", map);
    } catch (Exception exception) {
      LOGGER.w(exception);
    }
  }
1365837
function (data) {
    var self = this;

    if (typeof data === 'object') {
      data = EJSON.stringify(data);
    }

    _.each(self.callbacks['message'], function (cb) {
      cb(data);
    });
  }
1134390
public void checkPointListChild(ValidationData param, ValidationRule rule, Object bodyObj, Object standardValue) {
        ValidationData listParent = param.findListParent();
        List list = (List) listParent.getValue(bodyObj);
        if (list == null || list.isEmpty()) {
            return;
        }

        list.stream().forEach(item -> {
            this.checkPoint(param, rule, item, standardValue);
        });

    }
532246
protected final Body statements(Data data) throws TemplateException {
	ScriptBody body = new ScriptBody(data.factory);

	statements(data, body, true);
	return body;
    }
188422
public BaseDataJsonFieldBo setData(Object data) {
        return setData(data != null ? SerializationUtils.toJson(data) : null);
    }
1037620
public void addIndex(ValidationData data) {
        for (ValidationDataIndex idx : this.idxs) {
            ValidationIndexUtil.addIndexData(data, idx);
        }
    }
1263332
protected void checkForAllowedBody() {
        int code = getIntCode();
        // check for explicit codes
        if (204 == code || 304 == code) {
            setBodyAllowed(false);
        }
        // all 1xx codes should not have a body
        else if (100 <= code && 200 > code) {
            setBodyAllowed(false);
        }
        // default everything else...
        else {
            setBodyAllowed(true);
        }
    }