Returns the length of the message, in bytes, excluding the message length
prefix value.

@return the length of the message, in bytes, excluding the message length
prefix value.
558538
public int getMessageLength() {
    // Message type, ticket #
    int messageLength = 1 + 4;

    // Identifier length prefix
    messageLength += 4;

    if (this.identifierRegex != null) {
      try {
        messageLength += this.identifierRegex.getBytes("UTF-16BE").length;
      } catch (UnsupportedEncodingException e) {
        log.error("Unable to encode String into UTF-16.");
        e.printStackTrace();
      }
    }

    // Number of query attributes length prefix
    messageLength += 4;

    // Add length prefix and String length for each attribute
    if (this.attributeRegexes != null) {
      for (String attrib : this.attributeRegexes) {
        messageLength += 4;
        try {
          messageLength += attrib.getBytes("UTF-16BE").length;
        } catch (UnsupportedEncodingException e) {
          log.error("Unable to encode String into uTF-16");
          e.printStackTrace();
        }
      }
    }

    // Begin and end timestamps
    messageLength += 16;

    return messageLength;
  }
1224765
short getStructLength()
	{
		int len = device.getStructLength() + suppfam.getStructLength();
		if (mfr != null)
			len += mfr.getStructLength();
		return (short) len;
	}
532029
def length(self):
        

        if not self.__length:
            self.__length = self.__get_length()

        return self.__length
1121335
public int getSolverLength() {
    // Attribute name alias, creation date, Id length,
    int length = 4 + 8 + 4;

    // Id,
    if (this.identifier != null) {
      try {
        length += this.identifier.getBytes("UTF-16BE").length;
      } catch (UnsupportedEncodingException e) {
        throw new RuntimeException("Unable to encode UTF16 strings.", e);
      }
    }

    // Data length
    length += 4;
    // Data
    if (this.data != null) {
      length += this.data.length;
    }

    return length;
  }
173305
public int getExtensionLength()
    {
        if (!getExtensionBit())
            return 0;

        //the extension length comes after the RTP header, the CSRC list, and
        //after two bytes in the extension header called "defined by profile"
        int extLenIndex =  FIXED_HEADER_SIZE
                        + getCsrcCount()*4 + 2;
        
        return ((buffer.get(extLenIndex) << 8) | buffer.get(extLenIndex + 1) * 4);
    }
21494
public int getLength()
  {
    int length = 0;
    
    for (TempCharBuffer ptr = _head; ptr != null; ptr = ptr._next) {
      length += ptr.getLength();
    }

    return length;
  }
115530
public int getMessageSizeForPriorityCalc() {
        int size = getMessageSize();
        for (TransactionInput input : inputs) {
            // 41: min size of an input
            // 110: enough to cover a compressed pubkey p2sh redemption (somewhat arbitrary).
            int benefit = 41 + Math.min(110, input.getScriptSig().getProgram().length);
            if (size > benefit)
                size -= benefit;
        }
        return size;
    }
228736
public int getLength() {
        if (m_last == -1) {
            int node;
            while ((node = m_iter.next()) != DTMAxisIterator.END) {
                m_cachedNodes.addElement(node);
            }
            m_last = m_cachedNodes.size();
        }
        return m_last;
    }
268480
public int getMessageSetSerializedSize() {
    int size = 0;
    for (int i = 0; i < fields.getNumArrayEntries(); i++) {
      size += getMessageSetSerializedSize(fields.getArrayEntryAt(i));
    }
    for (final Map.Entry<FieldDescriptorType, Object> entry :
             fields.getOverflowEntries()) {
      size += getMessageSetSerializedSize(entry);
    }
    return size;
  }
501857
public int getSerializedSizeAsMessageSet() {
    int result = 0;
    for (final Map.Entry<Integer, Field> entry : fields.entrySet()) {
      result += entry.getValue().getSerializedSizeAsMessageSetExtension(
        entry.getKey());
    }
    return result;
  }
730646
public int getMessageLength() {
    // Message ID
    int length = 1;

    if (this.weights != null) {
      for (String origin : this.weights.keySet()) {
        // String prefix, weight
        length += 8;
        try {
          length += origin.getBytes("UTF-16BE").length;
        } catch (UnsupportedEncodingException uee) {
          log.error("Unable to encode to UTF-16BE.");
        }
      }
    }

    return length;
  }
1126316
public int getLength()
  {      
    // Tell if this is being called from within a predicate.
  	boolean isPredicateTest = (this == m_execContext.getSubContextList());

    // And get how many total predicates are part of this step.
  	int predCount = getPredicateCount();
  	
    // If we have already calculated the length, and the current predicate 
    // is the first predicate, then return the length.  We don't cache 
    // the anything but the length of the list to the first predicate.
    if (-1 != m_length && isPredicateTest && m_predicateIndex < 1)
  		return m_length;
  	
    // I'm a bit worried about this one, since it doesn't have the 
    // checks found above.  I suspect it's fine.  -sb
    if (m_foundLast)
  		return m_pos;
  		
    // Create a clone, and count from the current position to the end 
    // of the list, not taking into account the current predicate and 
    // predicates after the current one.
    int pos = (m_predicateIndex >= 0) ? getProximityPosition() : m_pos;
              
    LocPathIterator clone;

    try
    {
      clone = (LocPathIterator) clone();        
    }
    catch (CloneNotSupportedException cnse)
    {
      return -1;
    }

    // We want to clip off the last predicate, but only if we are a sub 
    // context node list, NOT if we are a context list.  See pos68 test, 
    // also test against bug4638.
    if (predCount > 0 && isPredicateTest)
    {
      // Don't call setPredicateCount, because it clones and is slower.
      clone.m_predCount = m_predicateIndex;
      // The line above used to be:
      // clone.m_predCount = predCount - 1;
      // ...which looks like a dumb bug to me. -sb
    }

    int next;

    while (DTM.NULL != (next = clone.nextNode()))
    {
      pos++;
    }
    
    if (isPredicateTest && m_predicateIndex < 1)
      m_length = pos;
    
    return pos;
  }
582061
public long getContentLength() {
		String value = getFirst(CONTENT_LENGTH);
		return (value != null ? Long.parseLong(value) : -1);
	}
1311925
private int getLength()
    {
        if (m_length_ >= 0) {
            return m_length_;
        }
        int length = m_key_.length;
        for (int index = 0; index < length; index ++) {
            if (m_key_[index] == 0) {
                length = index;
                break;
            }
        }
        m_length_ = length;
        return m_length_;
    }
1207260
public int getLengthInBytes() {
        long length = polygonOverheadInBytes();
        for (List<XYZPoint> loop : m_loops) {
            length += loopLengthInBytes(loop.size());
        }

        return (int)length;
    }
371575
public int getLength()
  {
    int length = 0;
    
    for (TempBuffer ptr = _head; ptr != null; ptr = ptr.next()) {
      length += ptr.length();
    }

    return length;
  }
1073433
public function getLength()
    {
        if (!$this->stub && !is_int($this->length)) {
            $this->length = strlen($this->data);
        }

        return $this->length;
    }