Returns the length prefix value for this message, as encoded according to
the Solver-Aggregator protocol.

@return the length prefix for this message.
427134
public int getLengthPrefix() {
    // Message ID
    int length = 1;
    // Number of rules
    length += 4;
    if (this.rules != null) {
      for (SubscriptionRequestRule rule : this.rules) {
        // Physical Layer
        ++length;
        // Transmitters
        length += 4 + rule.getNumTransmitters()
            * Transmitter.TRANSMITTER_ID_SIZE * 2;
        // Update interval
        length += 8;
      }

    }

    return length;
  }
501857
public int getSerializedSizeAsMessageSet() {
    int result = 0;
    for (final Map.Entry<Integer, Field> entry : fields.entrySet()) {
      result += entry.getValue().getSerializedSizeAsMessageSetExtension(
        entry.getKey());
    }
    return result;
  }
175077
public int getLength()
  {
    if(!isReverseAxes())
      return super.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;      

    int count = 0;
    
    XPathContext xctxt = getXPathContext();
    try
    {
      OneStepIterator clone = (OneStepIterator) this.cloneWithReset();
      
      int root = getRoot();
      xctxt.pushCurrentNode(root);
      clone.setRoot(root, xctxt);
 
      clone.m_predCount = m_predicateIndex;

      int next;

      while (DTM.NULL != (next = clone.nextNode()))
      {
        count++;
      }
    }
    catch (CloneNotSupportedException cnse)
    {
       // can't happen
    }
    finally
    {
      xctxt.popCurrentNode();
    }
    if (isPredicateTest && m_predicateIndex < 1)
      m_length = count;    
      
    return count;
  }
115197
public long length() {
        return doWithJedis(new JedisCallable<Long>() {
            @Override
            public Long call(Jedis jedis) {
                return jedis.exists(getKey()) ? jedis.hlen(getKey()) : 0;
            }
        });
    }
916018
public NumberExpression<Integer> length() {
        if (length == null) {
            length = Expressions.numberOperation(Integer.class, Ops.STRING_LENGTH, mixin);
        }
        return length;
    }
608940
public double getLength() {
		double len = 0;
		if (!isEmpty()) {
			for (Polygon polygon : polygons) {
				len += polygon.getLength();
			}
		}
		return len;
	}
827994
public int getMessageLength() {
    // Message type, Id length
    int length = 1 + 4;

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

    // Attribute name length
    length += 4;

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

    if (this.origin != null) {
      try {
        length += this.origin.getBytes("UTF-16BE").length;
      } catch (UnsupportedEncodingException uee) {
        log.error("Unable to encode to UTF-16BE.");
      }
    }

    return length;
  }
194312
protected String getPropertyName(String methodName, int prefixLength) {
		return Character.toLowerCase(methodName.charAt(prefixLength)) + methodName.substring(prefixLength + 1);
	}
686797
@Override
    public String getMessage() {
        final int maxTipLength = 10;
        int end = position + 1;
        int start = end - maxTipLength;
        if (start < 0) {
            start = 0;
        }
        if (end > jsonString.length()) {
            end = jsonString.length();
        }
        return String.format("%s (%d):%s", jsonString.substring(start, end), position, super.getMessage());
    }
231206
public String getString() 
    {
        String strFinal = FirstMLastConverter.partsToName(m_recThis, m_iNamePrefix, m_iNameFirst, m_iNameMiddle, m_iNameSur, m_iNameSuffix, m_iNameTitle);
        int maxLength = this.getMaxLength();
        if (strFinal.length() > maxLength)
            strFinal = strFinal.substring(0, maxLength);    // Truncate to max length
        return strFinal;
    }
252690
public int encodedLength()
    {
        int length = 0;

        for (final Type t : containedTypeByNameMap.values())
        {
            if (t.isVariableLength())
            {
                return Token.VARIABLE_LENGTH;
            }

            if (t.offsetAttribute() != -1)
            {
                length = t.offsetAttribute();
            }

            if (t.presence() != Presence.CONSTANT)
            {
                length += t.encodedLength();
            }
        }

        return length;
    }
363508
@Override
    public int getHeaderLength() {
        try {
            final byte b = this.headers.getByte(0);
            // length is encoded as the number of 32-bit words, so to get number of bytes we must multiply by 4
            return (b & 0x0F) * 4;
        } catch (final IOException e) {
            throw new RuntimeException("unable to get the header length of the IP packet due to IOException", e);
        }
    }
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;
  }
1154335
public String getExpressionString() {
        StringBuffer buf = new StringBuffer();
        buf.append(mPrefix.getExpressionString());

        for (int i = 0; mSuffixes != null && i < mSuffixes.size(); i++) {
            ValueSuffix suffix = (ValueSuffix) mSuffixes.get(i);
            buf.append(suffix.getExpressionString());
        }

        return buf.toString();
    }
1373898
public int getLength()
  {

    if (m_count == -1)
    {
      short count = 0;

      for (int n = dtm.getFirstAttribute(element); n != -1;
              n = dtm.getNextAttribute(n))
      {
        ++count;
      }

      m_count = count;
    }

    return (int) m_count;
  }
1357063
public long getIPv4PrefixCount(int prefixLength) {
		if(prefixLength < 0) {
			throw new PrefixLenException(this, prefixLength);
		}
		int bitCount = getBitCount();
		if(bitCount <= prefixLength) {
			return getIPv4Count();
		}
		int shiftAdjustment = bitCount - prefixLength;
		long upperAdjusted = getUpper().longValue() >>> shiftAdjustment;
		long lowerAdjusted = getLower().longValue() >>> shiftAdjustment;
		return upperAdjusted - lowerAdjusted + 1;
	}
454776
public int getPrefixValueCount() {
		Integer prefixLength = getSegmentPrefixLength();
		if(prefixLength == null) {
			return getValueCount();
		}
		int shiftAdjustment = getBitCount() - prefixLength;
		return (getUpperSegmentValue() >>> shiftAdjustment) - (getSegmentValue() >>> shiftAdjustment) + 1;
	}