Store a late-defined characteristic, with a Charisma wrapper.
 @param [Symbol] key The name of the characteristic, which must match one defined in the class's characterization
 @param value The value of the characteristic
190637
def []=(key, value)
      characteristics[key] = Curation.new value, subject.class.characterization[key]
    end
1101423
def set_custom_value(self, key, value):
        
        self._owner.customParameters.append(
            self._glyphs_module.GSCustomParameter(name=key, value=value)
        )
898572
function(key, value) {
        var keys = this.keys;
        var values = this.values;
        var guid = guidFor(key);

        // ensure we don't store -0
        var k = key === -0 ? 0 : key;

        keys.add(k, guid);

        values[guid] = value;

        this.size = keys.size;

        return this;
      }
804779
def partition_key(self, value):
        
        annotations = dict(self._annotations)
        annotations[self._partition_key] = value
        header = MessageHeader()
        header.durable = True
        self.message.annotations = annotations
        self.message.header = header
        self._annotations = annotations
1004833
function defineKey(value, key, src, propHash){
  var isDescriptor = descriptors.isDescriptor(value)
    , isRequired   = descriptors.isRequired(value)
    , prev;

  if (isRequired && (key in src)) return

  if ( !isRequired ) {
    if ( isDescriptor) {
      prev = (propHash.hasOwnProperty(key) ? propHash[key] : []).splice(0)
      return defineKey(value.resolve.call(src, key, prev), key, src, propHash)
    }
    else
      add(propHash, key, value)
  }

  src[key] = value
}
475048
def put(key, value)
      if key == ''
        @object_types[:root] = [:root]
        @store[:root] = value
      else
        @notfound.delete(key.to_sym)
        (@object_types[value.type] ||= []) << key.to_s
        if @store[key.to_sym]
          @object_types[@store[key.to_sym].type].delete(key.to_s)
        end
        @store[key.to_sym] = value
      end
    end
626170
def []=(key, value)
      entry = find_entry(key)
      @dirty = true
      if entry.nil?
        @entries << [key, value]
      else
        entry[1] = value
      end
    end
1282034
def set(key, value = nil)
      if key.is_a?(Hash)
        properties.merge!(key)
      else
        properties[key] = value
      end
    end
191956
def []=(key, value)
      if value
        ffi_delegate.set_meta(key, "%s", :string, value)
      else
        ffi_delegate.unset_meta(key)
      end
    end
771586
def store( value )
      result = value.simplify
      self.class.target.new(result.get).write @value
      result
    end
911739
def fetch_value(key)
      val = fetch_nested(key)
      return val if self[:no_pruning].include?(key)
      Prunable::VALUES.include?(val) ? Prunable::Value : val
    end
806634
def register(self, key, value):
        

        self._actions[key] = value

        # invalidate cache of results for existing key
        if key in self._cache:
            del self._cache[key]
897343
public void cache(Integer key, Object value) {
        synchronized (this) {
            Integer curkey = keys.get(value);
            // Already cached?
            if (curkey != null) return;
            cache.put(key, value);
            keys.put(value, key);
        }
    }
415902
def []=(key, value)
      if config = configs[key]
        config.set(receiver, value)
      else
        store[key] = value
      end
    end
43309
public void put(String key, Long value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindLong(compiledStatementBindIndex++, (long) value);
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);		
		args.add(value);
		valueType.add(ParamType.LONG);
	}
173904
public void setProp(String key, Object value) {
    this.specProperties.put(key, value.toString());
  }
846014
function set(key, value) {
    return strong.def(validate(this, MAP), key === 0 ? 0 : key, value);
  }