check if the master has the key
 @param [String] key key for check
 @return [String, Integer, Float, Boolean] value of key
343108
def has_param(key)
      code, message, value = @server.call("hasParam", @caller_id, key)
      case code
      when 1
        return value
      when -1
        raise message
      else
        return false
      end
    end
583490
@VisibleForTesting
  public boolean containsKey(K key) {
    Preconditions.checkNotNull(key, "key can not be null");
    return mCache.containsKey(key);
  }
990404
def has_keys(self, keys):
        
        self.is_a(Mapping)
        self.contains_all_of(keys)
        return ChainInspector(self._subject)
985377
public boolean containsKey(Object key)
    {
        purge();
        Entry entry = getEntry(key);
        if (entry == null) return false;
        return entry.getValue() != null;
    }
50700
def masterfile?(element_key)
      if Tools.class_type(element_key) == 'DO' # Only DO Types can have a file
        file_list = load(element_key)
        unless file_list.nil?
          file_list.each do |file|
            return true if file.fileStorageType.casecmp('master').zero?
          end
        end
      end
      false
    end
1346870
def [](key)
      hashed_key = hash_key(key)
      unless (entry = @btree.get(hashed_key))
        return nil
      end

      if entry.is_a?(PEROBS::Array)
        entry.each do |ae|
          return ae.value if ae.key == key
        end
      else
        return entry.value if entry.key == key
      end

      nil
    end
237908
def search(key)
      base = @base
      chck = @chck
      node = @base[0]
      kin = KeyStream.new(key)
    
      while true
        code = kin.read
        idx = node + code
        node = base[idx]
      
        if(chck[idx] == code)
          if(node >= 0)
            next
          elsif(kin.eos? or key_exists?(kin, node))
            return Node::Base.ids(node)
          end
          return -1
        end
      end
    end
1278166
def _check_key(self, key):
        
        if not len(key) == 2:
            raise TypeError('invalid key: %r' % key)
        elif key[1] not in TYPES:
            raise TypeError('invalid datatype: %s' % key[1])
833111
private boolean contains(final int key, final int index) {
        return (key != 0 || states[index] == FULL) && keys[index] == key;
    }
82566
def get(self, key):
        

        if not self.is_loaded:
            self.retrieve()

            self.is_loaded = True

        if self.has(key=key):
            return self.data[key]
        else:
            return None
894700
def has_key?(key)
      if :hash == self.type
        self.children.any? { |pair_node| pair_node.key.to_value == key }
      else
        raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.debug_info}"
      end
    end
290668
@Override
    public boolean containsKey(Object key) {
        if (key instanceof String) {
            return has((String) key, this);
        } else if (key instanceof Number) {
            return has(((Number) key).intValue(), this);
        }
        return false;
    }
223129
def any_present?(*keys)
      keys.each do |key|
        return true if self.send(key).present?
      end
      return false
    end
1190953
public boolean containsKey(Object key)
    {
        if (key==null)
            return _nullEntry!=null;
        return
            getEntry(key.toString(),0,key==null?0:key.toString().length())!=null;
    }
662639
public boolean containsKey(Object key) {
        if (key == null) {
            return false;
        }

        Entry tab[] = mTable;
        int hash = System.identityHashCode(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;

        for (Entry e = tab[index], prev = null; e != null; e = e.mNext) {
            Object entryKey = e.getKey();

            if (entryKey == null) {
                // Clean up after a cleared Reference.
                mModCount++;
                if (prev != null) {
                    prev.mNext = e.mNext;
                }
                else {
                    tab[index] = e.mNext;
                }
                mCount--;
            }
            else if (e.mHash == hash && key == entryKey) {
                return true;
            }
            else {
                prev = e;
            }
        }

        return false;
    }
958575
public boolean containsKey(Key<?> key) {
    for (int i = 0; i < size; i++) {
      if (bytesEqual(key.asciiName(), name(i))) {
        return true;
      }
    }
    return false;
  }
1272944
public static boolean containsKey(final String _key)
    {
        final Cache<String, BundleInterface> cache = InfinispanCache.get()
                        .<String, BundleInterface>getIgnReCache(BundleMaker.CACHE4BUNDLE);
        return cache.containsKey(_key);
    }