Verifies that {@code rowKey}, {@code columnKey} and {@code value} are
non-null, and returns a new entry with those values.
973507
static <R, C, V> Cell<R, C, V> cellOf(R rowKey, C columnKey, V value) {
    return Tables.immutableCell(checkNotNull(rowKey), checkNotNull(columnKey), checkNotNull(value));
  }
652846
@Override
    public V put(K key, V value)
    {
        BinarySet<Entry<K,V>> es = (BinarySet<Entry<K,V>>) entrySet;
        Entry<K,V> oldEntry = es.addEntry(entry(key, value));
        if (oldEntry != null)
        {
            return oldEntry.getValue();
        }
        return null;
    }
1213344
private V getValue(InternalCacheEntry<K, V> entry) {
      return isNull(entry) ? null : entry.getValue();
   }
1334585
public void doesNotContainCell(
      @NullableDecl Object rowKey, @NullableDecl Object colKey, @NullableDecl Object value) {
    doesNotContainCell(Tables.<Object, Object, Object>immutableCell(rowKey, colKey, value));
  }
529714
public static KeyValue getReferenceKeyValue(byte[] rowkey, String propertyName,
            String schemaName, List<BeanId> refs, UniqueIds uids) {
        final byte[] pid = uids.getUsid().getId(propertyName);
        final byte[] sid = uids.getUsid().getId(schemaName);
        final byte[] qual = new byte[] { sid[0], sid[1], pid[0], pid[1] };
        final byte[] iids = getIids2(refs, uids);
        return new KeyValue(rowkey, REF_COLUMN_FAMILY, qual, iids);
    }
485277
public void insert(final String key, final String columnName, final String value) {
    createMutator(keyspace, serializer).insert(
        key, columnFamilyName, createColumn(columnName, value, serializer, serializer));

  }
854515
public DataRow set(String columnCode, String value) throws UnknownColumnException {
		for (DataColumn column : columns) {
			if (columnCode.equals(column.getCode())) {
				content.put(column, value);
				return this;
			}
		}
		throw new UnknownColumnException(columnCode);
	}
790172
protected void ensureRowKey(E key) {
		if (!rowKeys.containsKey(key)) {
			rowKeys.put(key, rowKeys.size());
			addRow();
		}
	}
135130
public DataRow findRowIgnoreCase(int columnIndex, String value)
	{
		for (DataRow dataRow : dataRows)
		{
			String columnValue = (String) dataRow.getColumn(columnIndex);
			if (value.equalsIgnoreCase(columnValue))
			{
				return dataRow;
			}
		}
		return null;
	}
1205120
public BooleanColumn set(Selection rowSelection, boolean newValue) {
        for (int row : rowSelection) {
            set(row, newValue);
        }
        return this;
    }
1148445
private static void validateSetValueEntryForSet(Object entry, Set<?> set) {
    if (entry instanceof Set<?> || entry instanceof SetValue) {
      throw new IllegalArgumentException("Unsupported Value type [nested sets]");
    }
    if (!set.isEmpty()) {
      Object existingEntry = set.iterator().next();
      if (!existingEntry.getClass().isAssignableFrom(entry.getClass())) {
        throw new IllegalArgumentException(
            String.format(
                "Unsupported Value type [SetValue with " + "mixed types %s and %s]",
                existingEntry.getClass(), entry.getClass()));
      }
    }
  }
453454
public static boolean containsKeyColumn(KeyColumnValueStore store, StaticBuffer key, StaticBuffer column, StoreTransaction txh) throws BackendException {
        return get(store, key, column, txh) != null;
    }
467832
public synchronized TableModel<V> setCell(int columnIndex, int rowIndex, V value) {
        getCell(columnIndex, rowIndex);
        List<V> row = rows.get(rowIndex);

        //Pad row with null if necessary
        for(int j = row.size(); j < columnIndex; j++) {
            row.add(null);
        }

        V existingValue = row.get(columnIndex);
        if(existingValue == value) {
            return this;
        }
        row.set(columnIndex, value);
        for(Listener<V> listener: listeners) {
            listener.onCellChanged(this, rowIndex, columnIndex, existingValue, value);
        }
        return this;
    }
192654
private void addColumn(String storeName, String rowKey, String colName, byte[] colValue) {
        Map<String, Map<String, byte[]>> rowMap = m_columnAdds.get(storeName);
        if (rowMap == null) {
            rowMap = new HashMap<>();
            m_columnAdds.put(storeName, rowMap);
        }
        
        Map<String, byte[]> colMap = rowMap.get(rowKey);
        if (colMap == null) {
            colMap = new HashMap<>();
            rowMap.put(rowKey, colMap);
        }
        
        byte[] oldValue = colMap.put(colName, colValue);
        if (oldValue == null) {
            m_totalUpdates++;
        } else if (!Arrays.equals(oldValue, colValue)) {
            m_logger.debug("Warning: duplicate column mutation with different value: " +
                           "store={}, row={}, col={}, old={}, new={}",
                           new Object[]{storeName, rowKey, colName, oldValue, colValue});
        }
    }
735940
public T getValue(E row, E col) {
		if(!rowKeys.containsKey(row))
			return null;
		if(!colKeys.containsKey(col))
			return null;
		try{
			get(rowKeys.get(row)).get(colKeys.get(col));
		} catch(IndexOutOfBoundsException e){
			return null;
		}
		return get(rowKeys.get(row)).get(colKeys.get(col));
	}
1256541
public void containsEntry(@NullableDecl Object key, @NullableDecl Object value) {
    Entry<Object, Object> entry = Maps.immutableEntry(key, value);
    if (!actual().entrySet().contains(entry)) {
      List<Object> keyList = Lists.newArrayList(key);
      List<Object> valueList = Lists.newArrayList(value);
      if (hasMatchingToStringPair(actual().keySet(), keyList)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s contains entry <%s (%s)>. However, it does contain keys "
                        + "<%s>.",
                    actualAsString(),
                    entry,
                    objectToTypeName(entry),
                    countDuplicatesAndAddTypeInfo(
                        retainMatchingToString(actual().keySet(), keyList /* itemsToCheck */)))));
      } else if (hasMatchingToStringPair(actual().values(), valueList)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s contains entry <%s (%s)>. However, it does contain values "
                        + "<%s>.",
                    actualAsString(),
                    entry,
                    objectToTypeName(entry),
                    countDuplicatesAndAddTypeInfo(
                        retainMatchingToString(actual().values(), valueList /* itemsToCheck */)))));
      } else if (actual().containsKey(key)) {
        Object actualValue = actual().get(key);
        /*
         * In the case of a null expected or actual value, clarify that the key *is* present and
         * *is* expected to be present. That is, get() isn't returning null to indicate that the key
         * is missing, and the user isn't making an assertion that the key is missing.
         */
        StandardSubjectBuilder check = check("get(%s)", key);
        if (value == null || actualValue == null) {
          check = check.withMessage("key is present but with a different value");
        }
        // See the comment on IterableSubject's use of failEqualityCheckForEqualsWithoutDescription.
        check.that(actualValue).failEqualityCheckForEqualsWithoutDescription(value);
      } else if (actual().containsValue(value)) {
        Set<Object> keys = new LinkedHashSet<>();
        for (Entry<?, ?> actualEntry : actual().entrySet()) {
          if (Objects.equal(actualEntry.getValue(), value)) {
            keys.add(actualEntry.getKey());
          }
        }
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s contains entry <%s>. "
                        + "However, the following keys are mapped to <%s>: %s",
                    actualAsString(), entry, value, keys)));
      } else {
        failWithActual("expected to contain entry", entry);
      }
    }
  }
288172
@Override
    public boolean containsValue(Object value) {
        if (value == null) {
            throw new NullPointerException();
        }

        for (Map.Entry<K, CachedValue<K, V>> entry : map.entrySet()) {
            CachedValue<K, V> cachedValue = entry.getValue();
            if (cachedValue.getValue().equals(value)) {
                if (isValueExpired(cachedValue)) {
                    if (map.remove(cachedValue.getKey(), cachedValue)) {
                        onValueRemove(cachedValue);
                    }
                } else {
                    readValue(cachedValue);
                    return true;
                }
            }
        }
        return false;
    }