Store the value/pk in the sorted set index

        For the parameters, see BaseRangeIndex.store

        We simple store the pk as a member of the sorted set with the value being the score
964886
def store(self, key, pk, value):
        

        self.connection.zadd(key, value, pk)
744903
def store(key, value, options = {})
      return super if options.include?(:raw)
      expires = expires_at(options)
      super(key, new_entry(value, expires), Utils.without(options, :expires))
      value
    end
1175765
private void ensureCapacityAndSetPair(int index, KeyValuePair kvp) {
        if (index < pairs.length) {
            pairs[index] = kvp;
        } else {
            pairs = java.util.Arrays.copyOf(pairs, Math.max(index + (index >> 1), DEFAULT_SIZE));
            pairs[index] = kvp;
        }
        setLastIndex(index);
    }
180457
public void put(K key, V value) {
        Set<V> set = storage.get(key);
        if (set == null) {
            set = new HashSet<>();
            storage.put(key, set);
        }
        set.add(value);
    }
752784
def store_value(self, name, value):
        """"""
        self.spine.send_command("storeSetting", self.group, name, value)
1050311
def put(self, rank, val):
        
        idx = bisect.bisect(self.ranks, rank)
        self.ranks.insert(idx, rank)
        self.data.insert(idx, val)
937972
def __store_callable(self, o, method_name, member):
        
        self.__store__['callables'][method_name] = eval( "o." + method_name )
        self.__store__['callables'][method_name[0].lower() + method_name[1:]] = eval( "o." + method_name )
        ret_val = self.__wrap( method_name )
        self.__store__[ method_name ] = ret_val
        self.__store__[ method_name[0].lower() + method_name[1:] ] = ret_val
771586
def store( value )
      result = value.simplify
      self.class.target.new(result.get).write @value
      result
    end
647740
@Override
    public void storeAll(Map mapEntries) {
        int batchSize = getBatchSize();
        if (batchSize == 0 || mapEntries.size() < batchSize) {
            storeBatch(mapEntries);
        }
        else {
            Map batch = new HashMap(batchSize);

            while (!mapEntries.isEmpty()) {
                Iterator iter = mapEntries.entrySet().iterator();
                while (iter.hasNext() && batch.size() < batchSize) {
                    Map.Entry entry = (Map.Entry) iter.next();
                    batch.put(entry.getKey(), entry.getValue());
                }

                storeBatch(batch);

                mapEntries.keySet().removeAll(batch.keySet());
                batch.clear();
            }
        }
    }
332766
public void put(int key, E value) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            mValues[i] = value;
        } else {
            i = ~i;

            if (i < mSize && mValues[i] == DELETED) {
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }

            if (mGarbage && mSize >= mKeys.length) {
                gc();

                // Search again because indices may have changed.
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }

            if (mSize >= mKeys.length) {
                int n = idealIntArraySize(mSize + 1);

                int[] nkeys = new int[n];
                Object[] nvalues = new Object[n];

                // Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
                System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
                System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

                mKeys = nkeys;
                mValues = nvalues;
            }

            if (mSize - i != 0) {
                // Log.e("SparseArray", "move " + (mSize - i));
                System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
                System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
            }

            mKeys[i] = key;
            mValues[i] = value;
            mSize++;
        }
    }
868767
def store_variable(var)
      # Force the correct bounds since we can't explicitly specify binary
      if var.type == :binary
        var.instance_variable_set(:@lower_bound, 0)
        var.instance_variable_set(:@upper_bound, 1)
      end
      set_variable_bounds var.index, var.lower_bound, var.upper_bound, true

      Cbc.Cbc_setObjCoeff @ptr, var.index, var.coefficient
      Cbc.Cbc_setColName(@ptr, var.index, var.name) unless var.name.nil?
      set_variable_type var.index, var.type
    end
57865
void set(final long valueIteratedTo, final long valueIteratedFrom, final long countAtValueIteratedTo,
             final long countInThisIterationStep, final long totalCountToThisValue, final long totalValueToThisValue,
             final double percentile, final double percentileLevelIteratedTo, double integerToDoubleValueConversionRatio) {
        this.valueIteratedTo = valueIteratedTo;
        this.valueIteratedFrom = valueIteratedFrom;
        this.countAtValueIteratedTo = countAtValueIteratedTo;
        this.countAddedInThisIterationStep = countInThisIterationStep;
        this.totalCountToThisValue = totalCountToThisValue;
        this.totalValueToThisValue = totalValueToThisValue;
        this.percentile = percentile;
        this.percentileLevelIteratedTo = percentileLevelIteratedTo;
        this.integerToDoubleValueConversionRatio = integerToDoubleValueConversionRatio;
    }
197703
public int store(String label) {
		if (StrInt.containsKey(label)) {
			return (StrInt.get(label).intValue());
		} else if (!newLabelsAllowed) {
			return KEY_DUMMY_LABEL;
		} else { // store label
			Integer intKey = new Integer(count++);
			StrInt.put(label, intKey);
			IntStr.put(intKey, label);

			return intKey.intValue();
		}
	}
1344635
private void storeStaticField(XField staticField, Instruction obj, boolean pushStoredValue) {
        if (RLE_DEBUG) {
            System.out.println("[storeStaticField for field " + staticField + " in instruction " + handle);
        }

        ValueNumberFrame frame = getFrame();

        AvailableLoad availableLoad = new AvailableLoad(staticField);

        int numWordsConsumed = getNumWordsConsumed(obj);
        ValueNumber[] inputValueList = popInputValues(numWordsConsumed);

        if (pushStoredValue) {
            pushOutputValues(inputValueList);
        }

        // Kill loads of this field
        frame.killLoadsOfField(staticField);

        // Make load available
        frame.addAvailableLoad(availableLoad, inputValueList);

        if (RLE_DEBUG) {
            System.out.println("[making store of " + staticField + " available]");
        }

        if (VERIFY_INTEGRITY) {
            checkConsumedAndProducedValues(obj, inputValueList, pushStoredValue ? inputValueList : EMPTY_INPUT_VALUE_LIST);
        }
    }
966309
def __store_other(self, o, method_name, member):
        
        self.__store__[ method_name ] = eval( "o." + method_name )
        self.__store__[ method_name[0].lower() + method_name[1:] ] = eval( "o." + method_name )
1023538
public static void storeFieldA(
			int holderValKind,
			Object holder,
			Object newVal,
			Object oldVal,
			String holderClass,
			String fieldName,
			String type,
			String callerClass,
			String callerMethod,
			int callerValKind,
			Object caller) {
		System.err.println("storeFieldA(     "+
				valAndValKindToString(holder, holderClass, holderValKind)+
				" . "+fieldName+				
				" = "+newVal+", "+
				"oldVal="+oldVal+", "+
//				"holderClass="+holderClass+", "+
				"fieldType="+type+", "+
//				"callerClass="+callerClass+", "+
				"callerMethod="+callerMethod+", "+
				"caller="+valAndValKindToString(caller, callerClass, callerValKind)+", "+
				")");
	}
1275090
def _get_final_set(self, sets, pk, sort_options):
        
        conn = self.cls.get_connection()
        all_sets = set()
        tmp_keys = set()

        if pk is not None and not sets and not (sort_options and sort_options.get('get')):
            # no final set if only a pk without values to retrieve
            return (None, False)

        elif sets or pk:
            if sets:
                new_sets, new_tmp_keys = self._prepare_sets(sets)
                all_sets.update(new_sets)
                tmp_keys.update(new_tmp_keys)
            if pk is not None:
                # create a set with the pk to do intersection (and to pass it to
                # the store command to retrieve values if needed)
                tmp_key = self._unique_key()
                conn.sadd(tmp_key, pk)
                all_sets.add(tmp_key)
                tmp_keys.add(tmp_key)

        else:
            # no sets or pk, use the whole collection instead
            all_sets.add(self.cls.get_field('pk').collection_key)

        if not all_sets:
            delete_set_later = False
            final_set = None
        elif len(all_sets) == 1:
            # if we have only one set, we  delete the set after calling
            # collection only if it's a temporary one, and we do not delete
            # it right now
            final_set = all_sets.pop()
            if final_set in tmp_keys:
                delete_set_later = True
                tmp_keys.remove(final_set)
            else:
                delete_set_later = False
        else:
            # more than one set, do an intersection on all of them in a new key
            # that will must be deleted once the collection is called.
            delete_set_later = True
            final_set = self._combine_sets(all_sets, self._unique_key())

        if tmp_keys:
            conn.delete(*tmp_keys)

        # return the final set to work on, and a flag if we later need to delete it
        return (final_set, [final_set] if delete_set_later else None)