TODO Equals to load values
160552
public void set(BitArray ba) {
        if (ba.size != this.size)
            throw new IllegalArgumentException();
        for (int i = 0; i < this.data.length; ++i)
            this.data[i] = ba.data[i];
    }
798534
def load(self, value: Any, type_: Type[T], *, annotation: Optional[Annotation] = None) -> T:
        
        try:
            index = self.index(type_)
        except ValueError:
            raise TypedloadTypeError(
                'Cannot deal with value of type %s' % type_,
                value=value,
                type_=type_
            )

        # Add type to known types, to resolve ForwardRef later on
        if self.frefs is not None and hasattr(type_, '__name__'):
            tname = type_.__name__
            if tname not in self.frefs:
                self.frefs[tname] = type_

        func = self.handlers[index][1]
        try:
            return func(self, value, type_)
        except Exception as e:
            assert isinstance(e, TypedloadException)
            e.trace.insert(0, TraceItem(value, type_, annotation))
            raise e
1052660
function equals(first, second){

		//If are the same instance, true
		if (first === second)
			return true;
			
		//If values are equals, return true
		if (first == second)
			return true;
			
		//If different type, false
		if (typeof first != typeof second)
			return false;
			
		//If are not objects, check value
		if (typeof first != "object")
			return first == second;
			
		//For each property on first
		for (var current in first){
		
			//Get property value from each element
			var firstValue = first[current];
			var secondValue = second[current];
			
			//If current is object, invoke "Equals" on each 
			//member of the object; otherwise just check values
			var isEqual = (typeof firstValue === 'object') ? equals(firstValue, secondValue) : firstValue == secondValue;
			
			//If not equals, exit
			if (!isEqual)
				return false;
		}
		
		//Confirm
		return true;	
	}
496892
def process_bind_param(self, value, dialect):
        """"""
        if value is not None:
            value = simplejson.dumps(value)
        return value
1162502
function toDefault(val, def) {
    if (is_1.isValue(val) && !(is_1.isEmpty(val) && !is_1.isEmpty(def)))
        return val;
    return is_1.isValue(def) ? def : null;
}
1366650
private Object itemValue(Object obj, Object item) throws Exception {
		// String value
		if (item instanceof String) {
			return item;
		}

		Element node = (Element) item;
		String tag = node.getTagName();
		// TODO: in case of jdk7 usage use swtich instead
		if ("Call".equals(tag)) {
			return call(obj, node);
		}
		if ("Get".equals(tag)) {
			return get(obj, node);
		}
		if ("New".equals(tag)) {
			return newObj(obj, node);
		}
		if ("Ref".equals(tag)) {
			return refObj(obj, node);
		}
		if ("Array".equals(tag)) {
			return newArray(obj, node);
		}
		if ("Map".equals(tag)) {
			return newMap(obj, node);
		}
		if ("Property".equals(tag)) {
			return propertyObj(obj, node);
		}

		if ("SystemProperty".equals(tag)) {
			String name = getAttribute(node, "name");
			String defaultValue = getAttribute(node, "default");
			return System.getProperty(name, defaultValue);
		}

		LOG.warn("Unknown value tag: {}", node);
		return null;
	}
1033149
function(val) {
      return val === undefined ? (this.length ? this[0].value : null) : this.each(function(index, el) {
        el.value = val;
      });
    }
774002
@Override
    public boolean containsValue(Object value) {
        for (V v : values()) {
            if (v.equals(value)) {
                return true;
            }
        }
        return false;
    }
130966
protected Object getDataValue(Trace trace, Node node, Direction direction, Map<String, ?> headers,
            Object[] values) {
        if (source == DataSource.Content) {
            return values[index];
        } else if (source == DataSource.Header) {
            return headers.get(key);
        }
        return null;
    }
866170
private static Object[] buildBindValues(Object bindValue) {
        if (bindValue instanceof boolean[]) {
            boolean[] bools = (boolean[]) bindValue;
            return bools.length > 0 ? ArrayUtils.toObject(bools) : null;
        } else if (bindValue instanceof short[]) {
            short[] shorts = (short[]) bindValue;
            return shorts.length > 0 ? ArrayUtils.toObject(shorts) : null;
        } else if (bindValue instanceof int[]) {
            int[] ints = (int[]) bindValue;
            return ints.length > 0 ? ArrayUtils.toObject(ints) : null;
        } else if (bindValue instanceof long[]) {
            long[] longs = (long[]) bindValue;
            return longs.length > 0 ? ArrayUtils.toObject(longs) : null;
        } else if (bindValue instanceof float[]) {
            float[] floats = (float[]) bindValue;
            return floats.length > 0 ? ArrayUtils.toObject(floats) : null;
        } else if (bindValue instanceof double[]) {
            double[] doubles = (double[]) bindValue;
            return doubles.length > 0 ? ArrayUtils.toObject(doubles) : null;
        } else if (bindValue instanceof char[]) {
            char[] chars = (char[]) bindValue;
            return chars.length > 0 ? ArrayUtils.toObject(chars) : null;
        } else if (bindValue instanceof Object[]) {
            Object[] objs = (Object[]) bindValue;
            return objs.length > 0 ? objs : null;
        } else if (bindValue instanceof List<?>) {
            List<?> list = (List<?>) bindValue;
            return list.size() > 0 ? list.toArray() : null;
        }
        return new Object[] { bindValue };
    }

    private static String buildStatementAndValues(String sql, Map<String, ?> bindValues,
            List<Object> outValues) {
        if (bindValues == null) {
            bindValues = new HashMap<>();
        }
        StringBuffer sb = new StringBuffer();
        Matcher m = PATTERN_NAMED_PARAM.matcher(sql);
        while (m.find()) {
            String namedParam = m.group(1);
            Object bindValue = bindValues.get(namedParam);
            Object[] bindList = buildBindValues(bindValue);
            m.appendReplacement(sb, StringUtils.repeat("?", ",", bindList.length));
            for (Object bind : bindList) {
                outValues.add(bind);
            }
        }
        m.appendTail(sb);
        return sb.toString();
    }

    /**
     * Prepare and bind parameter values a named-parameter statement.
     * 
     * @param conn
     * @param sql
     * @param bindValues
     *            name-based bind values
     * @return
     * @since 0.8.2
     * @throws SQLException
     */
    public static PreparedStatement prepareAndBindNamedParamsStatement(Connection conn, String sql,
            Map<String, ?> bindValues) throws SQLException {
        List<Object> indexBindValues = new ArrayList<>();
        String finalSql = buildStatementAndValues(sql, bindValues, indexBindValues);
        PreparedStatement pstm = conn.prepareStatement(finalSql);
        bindParams(pstm, indexBindValues.toArray());
        return pstm;
    }

    /**
     * Prepare and bind parameter values a named-parameter statement.
     * 
     * @param conn
     * @param sql
     * @param resultSetType
     * @param resultSetConcurrency
     * @param bindValues
     *            name-based bind values
     * @return
     * @since 0.8.2
     * @throws SQLException
     */
    public static PreparedStatement prepareAndBindNamedParamsStatement(Connection conn, String sql,
            int resultSetType, int resultSetConcurrency, Map<String, ?> bindValues)
            throws SQLException {
        List<Object> indexBindValues = new ArrayList<>();
        String finalSql = buildStatementAndValues(sql, bindValues, indexBindValues);
        PreparedStatement pstm = conn.prepareStatement(finalSql, resultSetType,
                resultSetConcurrency);
        bindParams(pstm, indexBindValues.toArray());
        return pstm;
    }

    /**
     * Prepare and bind parameter values a named-parameter statement.
     * 
     * @param conn
     * @param sql
     * @param resultSetType
     * @param resultSetConcurrency
     * @param resultSetHoldability
     * @param bindValues
     *            name-based bind values
     * @return
     * @since 0.8.2
     * @throws SQLException
     */
    public static PreparedStatement prepareAndBindNamedParamsStatement(Connection conn, String sql,
            int resultSetType, int resultSetConcurrency, int resultSetHoldability,
            Map<String, ?> bindValues) throws SQLException {
        List<Object> indexBindValues = new ArrayList<>();
        String finalSql = buildStatementAndValues(sql, bindValues, indexBindValues);
        PreparedStatement pstm = conn.prepareStatement(finalSql, resultSetType,
                resultSetConcurrency, resultSetHoldability);
        bindParams(pstm, indexBindValues.toArray());
        return pstm;
    }
758600
function load( available, toLoad ) {
    let loadList = available;
    if ('string' === typeof toLoad ) {
      loadList = [toLoad];
    }
    if (Array.isArray(toLoad)) {
      loadList = toLoad;
    }
    loadList.forEach(function( name ) {
      if ( available.indexOf(name) < 0 ) {
        return;
      }
      require('./'+name);
    });
  }
822322
function(val, desc){
        this.assert(
            val.valueOf() === this.obj
            , function(){ return 'expected ' + this.inspect + ' to equal ' + i(val) + (desc ? " | " + desc : "") }
            , function(){ return 'expected ' + this.inspect + ' to not equal ' + i(val) + (desc ? " | " + desc : "") }
            , val);
        return this;
    }
473473
function parseValues(obj) {
        Object.keys(obj).forEach(function (key) {
            obj[key] = parseValue(obj[key]);
        });
        return obj;
    }
726786
@Override
    protected final Object equivalentValues(Object value) {
        boolean result = equivalentXml(value);
        return result ? Boolean.TRUE : Boolean.FALSE;
    }
1278292
def index(self, value: Any) -> int:
        
        for i, cond in ((j[0], j[1][0]) for j in enumerate(self.handlers)):
            try:
                match = cond(value)
            except:
                if self.raiseconditionerrors:
                    raise
                match = False
            if match:
                return i
        raise TypedloadValueError('Unable to dump %s' % value, value=value)
905506
private synchronized void loadExistingData() {
        for (ChildData childData : _pathCache.getCurrentData()) {
            addNode(childData.getPath(), parseChildData(childData));
        }
    }
1005178
private static String joinSetAndGetValue(List<Field> fields,
			List<Object> values, Object obj, boolean withNull) {
		StringBuilder sb = new StringBuilder();
		int fieldSize = fields.size();
		for(int i = 0; i < fieldSize; i++) {
			Column column = fields.get(i).getAnnotation(Column.class);
			Object value = DOInfoReader.getValue(fields.get(i), obj);
			if(column.casVersion()) {
				if(value == null) {
					throw new CasVersionNotMatchException("casVersion column value is null");
				}
				Long _v = null;
				if(value instanceof Long) {
					_v = (Long) value;
				} else if (value instanceof Integer) {
					_v = ((Integer) value).longValue();
				} else {
					throw new CasVersionNotMatchException("casVersion column type must be Integer or Long");
				}
				sb.append(getColumnName(column)).append("=").append(_v + 1).append(",");
			} else {
				if(value != null && column.isJSON()) {
					value = JSON.toJson(value);
				}
				if(withNull || value != null) {
					sb.append(getColumnName(column)).append("=?,");
					values.add(value);
				}
			}
		}
		return sb.length() == 0 ? "" : sb.substring(0, sb.length() - 1);
	}