{@link InputType} of the elements composed within complex type.
@param itemKey
@return
2791
public InputType getElementTypeUsingKey(String itemKey) {
    String type = this.getDataType().get(itemKey).getAsString().toUpperCase();
    return InputType.valueOf(type);
  }
1361338
@Override
  public ApiType getByKey(String key) {
    lock.lock();
    try {
      return this.items.get(key);
    } finally {
      lock.unlock();
    }
  }
1281875
public <T> Set<T> asSet(Class<T> itemType) {
      return asCollection(Set.class, itemType);
   }
1033216
public V get(final int key) {
		final int index = (key & 0x7FFFFFFF) % elementData.length;

		IntLinkedEntry<V> m = elementData[index];
		while (m != null) {
			if (key == m.key) {
				if (accessOrder) {
					// if (log.isDebugEnabled()) log.debug("reliking " + this.key);
					m.remove();
					m.addBefore(header);
				}
				return m.value;
			}
			m = m.nextInSlot;
		}
		return null;
	}
665544
private int getIntegerIndex(SoyValue key) {
    try {
      return ((IntegerData) key).integerValue();
    } catch (ClassCastException cce) {
      try {
        // TODO: Remove this old bad behavior after existing code is compliant.
        return Integer.parseInt(key.coerceToString());
      } catch (NumberFormatException nfe) {
        throw new SoyDataException(
            "SoyList accessed with non-integer key (got key type "
                + key.getClass().getName()
                + ").");
      }
    }
  }
1261837
@Override
  public <T> List<Binding<T>> bindings(Key<T> key)
  {
    BindingSet<T> set = (BindingSet) _bindingSetMap.get(key.rawClass());

    if (set != null) {
      return set.bindings(key);
    }
    else {
      return Collections.EMPTY_LIST;
    }
  }
639252
public int removeKey(String inputKey) {
        String key = Normalizer.normalize(inputKey, Normalizer.NORMALIZE_LOWER);
        int num_removed = 0;
        List<String> vals = this.values.remove(key);
        if (null != vals) {
            num_removed = vals.size();
        }
        this.num_items -= num_removed;
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "removeKey: key=" + key + " " + num_removed);
        }
        return num_removed;
    }
903998
public int submit(List<T> itemList) {
        return JMOptional.getOptional(itemList).map(this::submitBulk).orElse(0);
    }
1067196
public final AbstractItemLink remove(long key)
    {
        AbstractItemLink link = null;
        synchronized (_getLock(key))
        {
            if(null != _entry) /// 666212
            {// 666212
               int i = _indexOfKey(key);
               AbstractItemLink previousEntry = _entry[i];
               AbstractItemLink thisEntry = previousEntry;
               while (null != thisEntry && null == link)
               {
                   AbstractItemLink nextEntry = thisEntry.getNextMappedLink();
                   if (key == thisEntry.getID())
                   {
                       link = thisEntry;
                       _size.decrementAndGet(); // Defect 597160
                       if (previousEntry == thisEntry)
                       {
                           _entry[i] = nextEntry;
                       }
                       else
                       {
                           previousEntry.setNextMappedLink(nextEntry);
                       }
                   }
                   previousEntry = thisEntry;
                   thisEntry = nextEntry;
               }
            }// 666212
        }
        return link;
    }
199815
public static boolean checkType(Object item) {
        return item == null
            || item instanceof String
            || item instanceof Integer
            || item instanceof Long
            || item instanceof Double
            || item instanceof Boolean
            || item instanceof BigInteger
            || item instanceof BigDecimal
            || item instanceof JsonObject
            || item instanceof JsonArray;
    }
929788
@Override
    public int getItemType(BaseCell item) {
        // if the item is a keyType, which means item.type is not the key
        int version = mViewManager != null ? mViewManager.getViewVersion(item.stringType) : 0;
        if (!TextUtils.isEmpty(item.typeKey)) {
            // we should use getTypeKey()
            String typeKey = item.typeKey + version;
            if (!mStrKeys.containsKey(typeKey)) {
                int newType = mTypeId.getAndIncrement();
                mStrKeys.put(typeKey, newType);
                mId2Types.put(newType, item.stringType);
            }

            return mStrKeys.get(typeKey).intValue();
        } else {
            // otherwise, use item.type as identity key
            // note, this now only be executed in MainThread, atomic not actually needed
            String stringType = item.stringType + version;
            if (!mStrKeys.containsKey(stringType)) {
                int newType = mTypeId.getAndIncrement();
                mStrKeys.put(stringType, newType);
                mId2Types.put(newType, item.stringType);
            }
            return mStrKeys.get(stringType).intValue();
        }
    }
1314487
@Override
    public <I> MatchResult<I> matchResult(I item) {
        StringDescription mismatch = new StringDescription();
        if (matches(item, mismatch)) {
            return new MatchResultSuccess<>(item, this);
        } else {
            return new MatchResultMismatch<>(item, this, mismatch.toString());
        }
    }
1173808
public void mapPossibleTypes(@Nullable Iterable<Item> items) {
        if (items != null && mFastAdapter != null) {
            for (Item item : items) {
                mFastAdapter.registerTypeInstance(item);
            }
        }
    }
1348406
public Convert<ElementCollection<T>> getOrCreateMapKeyConvert()
   {
      List<Node> nodeList = childNode.get("map-key-convert");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ConvertImpl<ElementCollection<T>>(this, "map-key-convert", childNode, nodeList.get(0));
      }
      return createMapKeyConvert();
   }
1092068
public Class<?> getType(String key) {
      if (beanDescriptor.hasReadMethod(key)) {
         return beanDescriptor.getReadMethod(key).getReturnType();
      } else if (beanDescriptor.hasWriteMethod(key)) {
         Class<?>[] paramTypes = beanDescriptor.getWriteMethod(key).getParameterTypes();
         if (paramTypes.length > 0) {
            return paramTypes[0];
         }
      }
      return null;
   }
617694
public StorageComponent<KeyType, ValueType> getStorageComponent(final KeyType key) {

        KeyToStorageComponent<KeyType, ValueType> storage = getkeyToStorage();
        StorageComponent<KeyType, ValueType> storageComponent = storage.get(key);
        if (storageComponent == null) {
            storageComponent = new StorageComponent<KeyType, ValueType>();
            storage.put(key, storageComponent);
        }
        return storageComponent;
    }
326709
@Override
    public K higherKey(K key)
    {
        Entry<K, V> entry = entry(key, null);
        Entry<K, V> higher = entrySet.higher(entry);
        if (higher != null)
        {
            return higher.getKey();
        }
        return null;
    }