Puts a new string value into this binder, but using an alternative value if the given one is null.
167800
public String put(String name, String value, String alternative) {
        return put(name, value != null ? value : alternative);
    }
391733
public void addNextValue(Object val) {
    String newVal = val.toString();
    if (this.maxVal == null || this.maxVal.compareTo(newVal) < 0) {
      this.maxVal = newVal;
    }
  }
813724
public void addString(String str)
    {
        if (sourceNode != null)
        {
            addStringInternal(str);
            replaceOrRegister(sourceNode, str);
        }
        else
        {
            unSimplify();
            addString(str);
        }
    }
157975
private V putImpl(K key, V value)
  {
    V item = null;

    int hash = key.hashCode() & _mask;
    int count = _values.length;

    for (; count > 0; count--) {
      item = _values[hash];

      // No matching item, so create one
      if (item == null) {
        _keys[hash] = key;
        _values[hash] = value;
        _size++;

        return null;
      }

      // matching item gets replaced
      if (_keys[hash].equals(key)) {
        _values[hash] = value;

        return item;
      }

      hash = (hash + 1) & _mask;
    }

    throw new IllegalStateException();
  }
1180112
public void setFormValue(Object value) {

        if (value == null) {
            value = "";
        }
        if (value instanceof String) {
            String strValue = (String)value;
            if (strValue.length() > 0) {
                checkvalue(strValue);
            }
        }

    }
1020049
public PactDslJsonArray stringValue(String value) {
      if (value == null) {
        body.put(JSONObject.NULL);
      } else {
        body.put(value);
      }
      return this;
    }
1329697
public V put(String key, V value) {

	if (key == null || value == null) {
	    throw new NullPointerException("keys and values cannot be null");
	}

	int keyLength = key.length();
	Node<V> n = rootNode;

	for (int curKeyIndex = 0; curKeyIndex <= keyLength; ++curKeyIndex) {	    

	    CharSequence nodePrefix = n.getPrefix();

	    int nextCharIndex = curKeyIndex + 1;

	    // if the current node is an intermediate node, then we need to
	    // match all of the prefix characters to use its children.  
	    if (nodePrefix.length() > 0) {
		int charOverlap = countOverlap(key, curKeyIndex, nodePrefix,0);
		int prefixLength = nodePrefix.length();
		
		// if 0 ore more characters overlapped, add this node to
		// somewhere in the middle
		if (charOverlap < prefixLength) {
		    addIntermediateNode(n,
					charOverlap,
					key,
					curKeyIndex,
					value);
		    size++;
		    return null;
		}

		// if all of the characters overlapped, then lookup the
		// transition to the next node based on the next character after
		// the matching prefix
		curKeyIndex += prefixLength;
		nextCharIndex = curKeyIndex + 1;
	    }

	    // If we have exhausted all the characters in the key, then the
	    // current node should map to the value
	    if (curKeyIndex == keyLength) {
		return replaceValue(n, value);
	    }
	    	    
	    // Otherwise, more characters exist, so check to see if there is a
	    // transition from the next sequence of the key to node.  If so, we
	    // use this to keep searching for the key's node
	    else {
		Node<V> child = n.getChild(key.charAt(curKeyIndex));
		
		// if there was no other node to transition to, then the
		// remaining portion of the key is used to form a child node of
		// the current node.  Since this is a new mapping, we can return
		// null immediately.
		if (child == null) {
		    addChildNode(n, key, curKeyIndex, value);
		    return null;
		}
		// otherwise, update the current node to the child and repeat
		// the search process
		else {
		    n = child;
		}
	    }	    
	}

	// NOTE: we should never reach this case, as the one of the conditions
	// in the for loop will determine where the key goes.
	return null;
    }
981468
public <T> void setHintValue(Hint<T> hint, T value) {
		if (value == null) {
			throw new IllegalArgumentException("Null value passed.");
		}
		hintValues.put(hint, value);
	}
289884
function prepend (value, string) {
  if (
    value === null || value === undefined || value === '' ||
    string === null || string === undefined
  ) {
    return value
  }
  return string + value
}
779641
function append (value, string) {
  if (
    value === null || value === undefined || value === '' ||
    string === null || string === undefined
  ) {
    return value
  }
  return value + string
}
181268
public int append(String stringValue, boolean nullTerminated) {
        if (stringValue != null)
            append(stringValue.getBytes());
        if (nullTerminated)
            append((byte)0);
        return bytesLength;
    }
957353
public void put(Long value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			compiledStatement.bindLong(compiledStatementBindIndex++, (long) value);
		}
	}
1078622
private static void putIfNotNull(final Map<String, Object> map, final String key, final Object value) {
        if (value != null) {
            map.put(key, value);
        }
    }
868964
public void put(final String key, final String value) {
        if (value == null) {
            throw new IllegalArgumentException("No value provided for key " + key);
        }
        validate(key, value);
        data.putValue(key, value);
    }
1227970
public V put(K key, V value)
  {
    V oldValue = compareAndPut(null, key, value, false);

    return oldValue;
  }
1322778
public void setValue(StringValue value, int offset, int len) {
		Validate.notNull(value);
		setValue(value.value, offset, len);
	}
454159
public Options putString(String key, IModel<String> value)
	{
		putOption(key, new StringOption(value));
		return this;
	}