Adds a long string entry to the AmqpTable.

@param key    name of an entry
@param value  long string value of an entry
@return AmqpTable object that holds the table of entries
352513
public AmqpTable addLongString(String key, String value) {
        this.add(key, value, AmqpType.LONGSTRING);
        return this;
    }
319023
@Override
    public Long put(char key, Long value) {
        verifyStandardSetting(key, value);
        return super.put(key, value);
    }
197309
public TaskResult add(String key, String[] value) {
    mBundle.putStringArray(key, value);
    return this;
  }
791500
public synchronized long addValue(String value) {
		sequences.add(++lastSequence);
		values.add(value);
		return lastSequence;
	}
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);
	}
600369
public static @Nonnull Entry<String,JsonElement> field(String key, JsonElement value) {
        Entry<String, JsonElement> entry = new Entry<String,JsonElement>() {

            @Override
            public String getKey() {
                return key;
            }

            @Override
            public JsonElement getValue() {
                return value;
            }

            @Override
            public JsonElement setValue(JsonElement value) {
                throw new UnsupportedOperationException("entries are immutable");
            }};
            return entry;
    }
1032227
public void put(String key, Boolean value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				this.compiledStatement.bindLong(compiledStatementBindIndex++, (((Boolean) value) == true ? 1 : 0));
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);
		args.add(value);
		valueType.add(ParamType.BOOLEAN);
	}
673945
public Long getLong(String key)
   {
      Long longValue = null;
      String sVal = getText(key);
      if ((sVal != null) && (sVal.length() > 0))
      {
         longValue = Long.valueOf(sVal);
      }
      return longValue;
   }
838410
public String put(final String key, String value) {
        if (key == null || initProps == null)
            return null;

        return initProps.put(key, value);
    }
369968
public T put(final int key, final T value) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);
		T oldvalue = null;

		long entry = elementKeys[index];
		if (entry == Integer.MIN_VALUE) {
			++elementCount;
		} else {
			oldvalue = elementValues[index];
			collisions++;
		}
		elementKeys[index] = key;
		elementValues[index] = value;
		return oldvalue;
	}
1029514
public long getLong(String key) {
		addToDefaults(key, null);
		String value = getRequired(key);
		return Long.parseLong(value);
	}
1277978
public T put(YamlNode key, Long value) {
        return put(key, getNodeFactory().longNode(value));
    }
611884
public TaskResult add(String key, CharSequence[] value) {
    mBundle.putCharSequenceArray(key, value);
    return this;
  }
59249
public final void put(long key, long value) {
		if (!isLeaf) {
			throw DBLogger.newFatalInternal("Tree inconsistency.");
		}

		//in any case, check whether the key(+value) already exists
        int pos = binarySearch(0, nEntries, key, value);
        //key found? -> pos >=0
        if (pos >= 0) {
        	//check if values changes
            if (value != values[pos]) {
                markPageDirtyAndClone();
                values[pos] = value;
            }
            return;
        } 

        if (nEntries < ind.maxLeafN) {
            //okay so we add it locally
            pos = -(pos+1);
            markPageDirtyAndClone();
            if (pos < nEntries) {
                System.arraycopy(keys, pos, keys, pos+1, nEntries-pos);
                System.arraycopy(values, pos, values, pos+1, nEntries-pos);
            }
            keys[pos] = key;
            values[pos] = value;
            nEntries++;
            return;
		} else {
			//treat page overflow
			LLIndexPage newP;
			boolean isNew = false;
			boolean isPrev = false;
			//use ind.maxLeafN -1 to avoid pretty much pointless copying (and possible endless 
			//loops, see iterator tests)
			LLIndexPage next = (LLIndexPage) parent.getNextLeafPage(this);
			if (next != null && next.nEntries < ind.maxLeafN-1) {
				//merge
				newP = next;
				newP.markPageDirtyAndClone();
				isPrev = false;
			} else {
				//Merging with prev is not make a big difference, maybe we should remove it...
				LLIndexPage prev = (LLIndexPage) parent.getPrevLeafPage(this);
				if (prev != null && prev.nEntries < ind.maxLeafN-1) {
					//merge
					newP = prev;
					newP.markPageDirtyAndClone();
					isPrev = true;
				} else {
					newP = new LLIndexPage(ind, parent, true);
					isNew = true;
				}
			}
			
			markPageDirtyAndClone();
			int nEntriesToKeep = (nEntries + newP.nEntries) >> 1;
			if (isNew) {
				if (ind.isUnique()) {
					//This is an optimization for indices that add increasing unique numbers 
					//such as OIDs. For these, it increases the average fill-size.
					//find split point such that pages can be completely full
					int pos2 = binarySearch(0, nEntries, keys[0] + ind.maxLeafN, value);
					if (pos2 < 0) {
						pos2 = -(pos2+1);
					}
					if (pos2 > nEntriesToKeep) {
						nEntriesToKeep = pos2;
					}
				} else {
					//non-unique: we assume ascending keys.
					//If they are not ascending, merging with subsequent page sorts it out.
					nEntriesToKeep = (int) (ind.maxLeafN * 0.9);
				}
			}
			int nEntriesToCopy = nEntries - nEntriesToKeep;
			if (isNew) {
				//works only if new page follows current page
				System.arraycopy(keys, nEntriesToKeep, newP.keys, 0, nEntriesToCopy);
				System.arraycopy(values, nEntriesToKeep, newP.values, 0, nEntriesToCopy);
			} else if (isPrev) {
				//copy element to previous page
				System.arraycopy(keys, 0, newP.keys, newP.nEntries, nEntriesToCopy);
				System.arraycopy(values, 0, newP.values, newP.nEntries, nEntriesToCopy);
				//move element forward to beginning of page
				System.arraycopy(keys, nEntriesToCopy, keys, 0, nEntries-nEntriesToCopy);
				System.arraycopy(values, nEntriesToCopy, values, 0, nEntries-nEntriesToCopy);
			} else {
				//make space on next page
				System.arraycopy(newP.keys, 0, newP.keys, nEntriesToCopy, newP.nEntries);
				System.arraycopy(newP.values, 0, newP.values, nEntriesToCopy, newP.nEntries);
				//insert element in next page
				System.arraycopy(keys, nEntriesToKeep, newP.keys, 0, nEntriesToCopy);
				System.arraycopy(values, nEntriesToKeep, newP.values, 0, nEntriesToCopy);
			}
			nEntries = (short) nEntriesToKeep;
			newP.nEntries = (short) (nEntriesToCopy + newP.nEntries);
			//New page and min key
			if (isNew || !isPrev) {
				if (ind.isUnique()) {
					if (newP.keys[0] > key) {
						put(key, value);
					} else {
						newP.put(key, value);
					}
				} else {
					//why doesn't this work??? Because addSubPage needs the new keys already in the 
					//page
	//				parent.addSubPage(newP, newP.keys[0], newP.values[0]);
	//				locatePageForKey(key, value, false).put(key, value);
					if (newP.keys[0] > key || (newP.keys[0]==key && newP.values[0] > value)) {
						put(key, value);
					} else {
						newP.put(key, value);
					}
				}
			} else {
				if (ind.isUnique()) {
					if (keys[0] > key) {
						newP.put(key, value);
					} else {
						put(key, value);
					}
				} else {
					if (keys[0] > key || (keys[0]==key && values[0] > value)) {
						newP.put(key, value);
					} else {
						put(key, value);
					}
				}
			}
			if (isNew) {
				parent.addSubPage(newP, newP.keys[0], newP.values[0]);
			} else {
				//TODO probably not necessary
				newP.parent.updateKey(newP, newP.keys[0], newP.values[0]);
			}
			parent.updateKey(this, keys[0], values[0]);
		}
	}
825138
public void setLong(String name, long value) throws UnsupportedEncodingException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setLong", Long.valueOf(value));
    getBodyMap().put(name, Long.valueOf(value));
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setLong");
  }
178056
public T put(String regularExpKey, T value)
	{
		return this.lookupMap.put(regularExpKey, value);
	}
95865
public void append(int key, long value) {
        if (mSize != 0 && key <= mKeys[mSize - 1]) {
            put(key, value);
            return;
        }

        int pos = mSize;
        if (pos >= mKeys.length) {
            growKeyAndValueArrays(pos + 1);
        }

        mKeys[pos] = key;
        mValues[pos] = value;
        mSize = pos + 1;
    }