Puts a new value in the property table with the appropriate flags
356724
public int get(Object key)
  {
    if (key == null)
      key = NULL_KEY;

    int hash = key.hashCode() & _mask;

    for (Item item = _entries[hash]; item != null; item = item._next) {
      Object itemKey = item._key;
      
      if (itemKey == key || itemKey.equals(key))
        return item._value;
    }

    return NULL;
  }
189235
public void changeProperty(String propertyName, Object propertyValue)
            throws ShanksException {
        this.properties.put(propertyName, propertyValue);
        this.checkStatus();
    }
497568
public void addProperty(String name, String value, int valueIndex) {
        if(name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Invalid property name: " + name);
        }
        if(value == null || value.isEmpty()) {
            throw new IllegalArgumentException("Invalid property value: " + value);
        }
        if(props == null) {
            props = new HashMap<String,String>();
        }
        props.put(name, value);
        this.lastPropertyName = name;
        this.lastPropertyValue = value;
        this.lastChunkIndex = valueIndex;
        separator = -1;
    }
943475
function insertProperty (fixer, node, propertyText) {
      if (node.properties.length === 0) {
        return fixer.replaceText(node, `{\n${propertyText}\n}`);
      }
      return fixer.insertTextAfter(
        sourceCode.getLastToken(node.properties[node.properties.length - 1]),
        `,\n${propertyText}`
      );
    }
969139
private void updateScalarReplaceValue(String currentValue, String newValue) {
        m_dbTran.addScalarValueColumn(m_tableDef, m_dbObj.getObjectID(), m_fieldName, newValue);
        Set<String> currTermSet = tokenize(Utils.isEmpty(currentValue) ? "" : currentValue);
        Set<String> newTermSet = tokenize(newValue);
        for (String term : currTermSet) {
            if (!newTermSet.remove(term)) {
                unindexTerm(term);
            }
        }
        indexTerms(newTermSet);
        addFieldTermReferences(newTermSet);
        if (Utils.isEmpty(currentValue)) {
            addFieldReference();
        }
    }
287839
@SuppressWarnings("unchecked")
    private static void setMappedValue(Object obj, Property property, Object key, Object value, ObjectWrapper options) {
        if (property == null) {
            throw new IllegalArgumentException("Cannot set a new mapped value to a 'null' property.");
        }

        if (Map.class.isAssignableFrom(property.getType())) {
            Map map = (Map) property.get(obj);

            if (map == null) {
                if (options.isAutoInstancing) {
                    map = new LinkedHashMap();
                    property.set(obj, map);
                } else {
                    throw new NullPointerException("Invalid 'null' value found for the mapped '" + property + "' in "
                                                           + obj.getClass().getName() + " object.");
                }
            }

            map.put(key, value);
        } else {
            throw new IllegalArgumentException("Cannot set a new mapped value to " + property
                                                       + ". Only Map type is supported for mapped properties, but " + property.getType().getName()
                                                       + " found.");
        }
    }
923716
public Object put(String propertyName, Object newValue) {
        if (VALID_KEY.matcher(propertyName).matches() == false) {
            throw new IllegalArgumentException("Invalid key for FlexiBean: " + propertyName);
        }
        return dataWritable().put(propertyName, newValue);
    }
183607
@Override
    public void addValuesForField() {
        String objID = m_dbObj.getObjectID();
        assert !Utils.isEmpty(objID);
        m_dbTran.addIDValueColumn(m_tableDef, objID);
        m_dbTran.addAllObjectsColumn(m_tableDef, objID, m_tableDef.getShardNumber(m_dbObj));
    }
105237
public void put(String value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			compiledStatement.bindString(compiledStatementBindIndex++, value);
		}

	}
37355
private void putValues(EsRequest doc, EsIndexColumn column, Object[] value) {
        Object[] columnValue = column.columnValues(value);
        int[] ln = new int[columnValue.length];
        String[] lc = new String[columnValue.length];
        String[] uc = new String[columnValue.length];

        for (int i = 0; i < columnValue.length; i++) {
            String stringValue = column.stringValue(columnValue[i]);
            lc[i] = stringValue.toLowerCase();
            uc[i] = stringValue.toUpperCase();
            ln[i] = stringValue.length();
        }

        doc.put(column.getName(), columnValue);
        doc.put(column.getLowerCaseFieldName(), lc);
        doc.put(column.getUpperCaseFieldName(), uc);
        doc.put(column.getLengthFieldName(), ln);
    }
713307
public void put(String key, BigDecimal value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindString(compiledStatementBindIndex++, value.toPlainString());
			}
		} else if (values != null) {
			values.put(key, value.toPlainString());
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.INTEGER);
	}
861681
function(newValue,property,config) {
                var thesetter = config.setter;
                if ( typeof(config.setter) === 'string' ) {
                    record[config.setter](newValue, property, config,record);
                } else {
                    //assume function
                    thesetter.call(record,newValue, property, config,record);
                }

            }
605937
private void updateValue(Point location) {
        CellPosition oldValue = value;
        if (location == null) {
            value = null;
        } else {
            int row = table.rowAtPoint(location);
            int column = table.columnAtPoint(location);
            value = new CellPosition(row, column);
        }
        maybeNotifyListeners(oldValue, value);
    }
1175582
function appendInternal(that, propertyList, args, options) {
    var arrayToAppend = args[0]
    if(arrayToAppend.length === 0) return; //nothing to do

    var array = getPropertyValue(that.subject, propertyList)
    var originalLength = array.length

    var spliceArgs = [originalLength, 0]
    spliceArgs = spliceArgs.concat(arrayToAppend)
    var oldLength = array.length
    array.splice.apply(array, spliceArgs)

    var internalObservees = unionizeList(array, oldLength, array.length, options.union)

    var event = {type: 'added', property: propertyList, index: originalLength, count: arrayToAppend.length}
    if(options.data !== undefined) event.data = event.id = options.data
    that.emit('change', event)

    unionizeListEvents(that, internalObservees, propertyList, options.union)
}
380464
@Override
    public void setIsNew(boolean flag) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            StringBuffer sb = new StringBuffer(newValueString).append(flag).append(oldValueString).append(_isNew).append(appNameAndIdString);
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, "setIsNew", sb.toString());
        }
        _isNew = flag;
    }
360660
public void put(String key, Float value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				this.compiledStatement.bindDouble(compiledStatementBindIndex++, (float) value);
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.FLOAT);
	}
1148744
def new_value(self, key, value):
        """"""
        data = self.model.get_data()
        data[key] = value
        self.set_data(data)