Retrieves the maximum Long.MAX_VALUE bounded length or precision for
the type. <p>

@return the maximum Long.MAX_VALUE bounded length or
precision for the type
964839
Long getPrecisionAct() {

        Integer temp = getPrecision();

        if (temp == null) {
            return ValuePool.getLong(Long.MAX_VALUE);
        } else {
            return ValuePool.getLong(temp.longValue());
        }
    }
582061
public long getContentLength() {
		String value = getFirst(CONTENT_LENGTH);
		return (value != null ? Long.parseLong(value) : -1);
	}
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;
    }
833493
public static Long getLong(String name, Long defaultValue) {
		return Long.getLong(name, defaultValue);
	}
125903
public long getLong(Integer type)
   {
      long result = 0;

      byte[] item = m_map.get(type);
      if (item != null)
      {
         result = MPPUtility.getLong6(item, 0);
      }

      return (result);
   }
304626
@Override
	public int getStructMaxSize() {
		final V factoryV = tree.factoryV();
		return super.getStructMaxSize() + (values.length * factoryV.byteLength()) + 4 + 4;
	}
934426
int getLongestChainLength() {
		int maxLen = 0;

		for (Entry<?, ?> entry : table) {
			int thisLen = 0;
			while (entry != null) {
				thisLen++;
				entry = entry.next;
			}
			maxLen = Math.max(maxLen, thisLen);
		}

		return maxLen;
	}
778033
public long value() {
        switch (type) {
        case AVERAGE:
            return numPoints != 0 ? value / numPoints : 0;
        case NONE:
            return 0;
        case MAXIMUM:
        case MINIMUM:
        case SUM:
            return value;
        default:
            throw new IllegalStateException("Unknown type [" + type + "]!");
        }
    }
396787
@Override
    public long getMaxX() {
        if (!excludeOutOfRangeValues) {
            return super.getMaxX();
        } else {
            long retMax = 0;
            Iterator<Long> iter = values.keySet().iterator();

            if (iter.hasNext()) {
                retMax = iter.next();
            }
            long excludeValue = getGranulationValue() * excludeCount;
            while (iter.hasNext()) {
                long value = iter.next();

                if (value > retMax) {
                    if ((value - retMax) < excludeValue) {
                        retMax = value;
                    }
                }
            }
            return retMax;
        }
    }
183978
public String getMaxDateLastModified() {

        if (m_searchParams.getMaxDateLastModified() == Long.MAX_VALUE) {
            return "";
        }
        return Long.toString(m_searchParams.getMaxDateLastModified());
    }
575376
static int getAndCheckPreLongs(final Memory mem) {
    final long cap = mem.getCapacity();
    if (cap < 8) { throwNotBigEnough(cap, 8); }
    final int preLongs = mem.getByte(0) & 0x3F;
    final int required = Math.max(preLongs << 3, 8);
    if (cap < required) { throwNotBigEnough(cap, required); }
    return preLongs;
  }
633493
public String getMaxDateCreated() {

        if (m_searchParams.getMaxDateCreated() == Long.MAX_VALUE) {
            return "";
        }
        return Long.toString(m_searchParams.getMaxDateCreated());
    }
809318
public static Long nextLong() {
        long randomLong = RANDOM.nextLong();
        if (randomLong < 0) {
            randomLong = randomLong + 1;
            randomLong = Math.abs(randomLong);
        }
        return randomLong;
    }
814218
public final long getMappedLength() {
        MappedByteBuffer[] mmapArray = _mmapArray;
        long length = 0;
        
        if (mmapArray != null) {
            for (MappedByteBuffer mmap : mmapArray) {
                length += mmap.capacity();
            }
        }
        
        return length;
    }
903813
@Override
	public int getMaxLength() {
		int max = 0;
		boolean found = false;
		for (Constraint c : constraints) {
			int cM = c.getMaxLength();
			if (cM != -1) {
				max += cM;
				found = true;
			}
		}
		return found ? max : -1;
	}
712701
public long length() {
        return doWithJedis(new JedisCallable<Long>() {
            @Override
            public Long call(Jedis jedis) {
                return jedis.llen(getKey());
            }
        });
    }
874243
public long readBoundedLong(final long max) throws IOException {
    final int bits = 0 >= max ? 0 : (int) (Math.floor(Math.log(max) / Math.log(2)) + 1);
    return 0 < bits ? this.read(bits).toLong() : 0;
  }