Get the keysize. If no key size specified this will return the default
key size.

@return
337130
public Integer getKeySize() {
		
		if(keySize == null){
			
			switch (algorithm) {
			case DES:
				keySize = DEFAULT_DES_KEY_SIZE;
				break;

			default:
				keySize = DEFAULT_AES_KEY_SIZE;
				break;
			}
			
		}
		
		return keySize;
		
	}
1034665
def Size(self):
        

        return s.uint8 + GetVarSize(self.Key) + GetVarSize(self.Field) + GetVarSize(self.Value)
294342
public function getKey() {
        if (empty($this->key)) {
            return null;
        }
        return substr($this->key, 0, $this->getKeySize());
    }
1260075
public boolean[] getKeyUsage() {
        try {
            String extAlias = OIDMap.getName(PKIXExtensions.KeyUsage_Id);
            if (extAlias == null)
                return null;

            KeyUsageExtension certExt = (KeyUsageExtension)this.get(extAlias);
            if (certExt == null)
                return null;

            boolean[] ret = certExt.getBits();
            if (ret.length < NUM_STANDARD_KEY_USAGE) {
                boolean[] usageBits = new boolean[NUM_STANDARD_KEY_USAGE];
                System.arraycopy(ret, 0, usageBits, 0, ret.length);
                ret = usageBits;
            }
            return ret;
        } catch (Exception e) {
            return null;
        }
    }
1340589
public int size() {

        int acc = 0;

        for (Map.Entry<String, List<Cell>> entry : cells.entrySet()) {
            acc += entry.getValue().size();
        }

        return acc;
    }
1016428
static public int getByteSize() {
    int size = 0;
    size += 16;
    size += 16;
    size += 24;
    size += 24;
    size += 20;
    size += 3;
    size += 5;
    size += 36;
    size += 64;
    size += 64;
    size = size/8;
    return size;
  }
544739
@Override
    public int size() {
        Map<String, GroovyRunner> map = getMap();
        readLock.lock();
        try {
            return map.size();
        } finally {
            readLock.unlock();
        }
    }
1189365
@Override
    public int size () {
        return 4 + ( this.hashAlgos != null ? 2 * this.hashAlgos.length : 0 ) + ( this.salt != null ? this.salt.length : 0 );
    }
993817
public String getKey() {
    List<String> split = BRANCH_OR_PULL_REQUEST_SPLITTER.splitToList(kee);
    return split.size() == 2 ? split.get(0) : kee;
  }
995899
public int getSize() {
		InnerList iList = ref.get();
		return iList != null ? iList.getList().size() : 0;
	}
1226455
public KeySignature getKey() {
		for (int i = 0, j = size(); i < j; i++) {
			if (elementAt(i) instanceof KeySignature)
				return (KeySignature) elementAt(i);
		}
		return new KeySignature(Note.C, KeySignature.MAJOR);
	}
1096058
private int keyColumnEnd()
  {
    int offset = 0;
    
    for (int i = 0; i < _columns.length; i++) {
      if (offset == _keyStart + _keyLength) {
        return i;
      }
      
      offset += _columns[i].length();
    }
    
    if (offset == _keyStart + _keyLength) {
      return _columns.length;
    }
    
    throw new IllegalStateException();
  }
812642
public Dimension getPreferredSize()
    {
    	if (this.getParent() != null)
        	return new Dimension(this.getParent().getWidth() / 3, super.getPreferredSize().height);
    	return super.getPreferredSize();
    }
101667
@Override
    public int size() {
        registryLock.readLock().lock();
        try {
            return entryMap.size();
        } finally {
            registryLock.readLock().unlock();
        }
    }
368850
@SuppressWarnings("unchecked")
    public Iterator<K> keys()
    {
        int size = _size;

        if (size == 0)
        {
            return null;
        }
        ArrayList<K> keyList = new ArrayList<K>();
        int i = (size - 1) * 2;
        while (i >= 0)
        {
            keyList.add((K) _array[i]);
            i = i - 2;
        }
        return keyList.iterator();
    }
816095
public long getSize() {
        long size = isParsed ? getContentSize() : content.limit();
        size += (8 + // size|type
                (size >= ((1L << 32) - 8) ? 8 : 0) + // 32bit - 8 byte size and type
                (UserBox.TYPE.equals(getType()) ? 16 : 0));
        size += (deadBytes == null ? 0 : deadBytes.limit());
        return size;
    }
1183395
public int size() {
        if (pad_bits == 0) {
            return bin.length;
        }
        if (bin.length == 0) {
            throw new java.lang.IllegalStateException("Impossible length");
        }
        return bin.length - 1;
    }