inline
RESULT *allocate(int                                            *status,
                 int                                             flags,
                 const btlso::IPv4Address&                       peerAddress,
                 btlso::StreamSocketFactory<btlso::IPv4Address> *factory,
                 bdlma::Pool                                    *pool)
{
    BSLS_ASSERT(factory); BSLS_ASSERT(pool); BSLS_ASSERT(status);

    btlso::StreamSocket<btlso::IPv4Address> *socket_p = 0;
    socket_p = factory->allocate();
    if (!socket_p) {
        return NULL;                                                  // RETURN
    }
    int rc = socket_p->setBlockingMode(btlso::Flag::e_BLOCKING_MODE);

    BSLS_ASSERT(0 == rc);
    while (1) {
        int s = socket_p->connect(peerAddress);

        if (0 == s) break;
        if (btlso::SocketHandle::e_ERROR_INTERRUPTED != s) {
            *status = e_FAILED; // Any negative number satisfies the contract.
            factory->deallocate(socket_p);
            return NULL;                                              // RETURN
        }
        if (flags & btlsc::Flag::k_ASYNC_INTERRUPT) {
            *status = 1;  // Any positive number satisfies the contract.
            factory->deallocate(socket_p);
            return NULL;                                              // RETURN
        }
    }
    RESULT *channel = new (*pool) RESULT(socket_p);
    return channel;
}

int baltzo::TimeZoneUtil::convertLocalToLocalTime(
                                       LocalDatetime         *result,
                                       const char            *targetTimeZoneId,
                                       const bdlt::Datetime&  srcTime,
                                       const char            *srcTimeZoneId,
                                       DstPolicy::Enum        dstPolicy)
{
    BSLS_ASSERT(result);
    BSLS_ASSERT(targetTimeZoneId);
    BSLS_ASSERT(srcTimeZoneId);

    bdlt::DatetimeTz resultTz;
    const int rc = convertLocalToLocalTime(&resultTz,
                                           targetTimeZoneId,
                                           srcTime,
                                           srcTimeZoneId,
                                           dstPolicy);
    if (0 != rc) {
        return rc;                                                    // RETURN
    }

    result->setDatetimeTz(resultTz);
    result->setTimeZoneId(targetTimeZoneId);

    return 0;
}

void RbTreeUtil::swap(RbTreeAnchor *a, RbTreeAnchor *b)
{
    BSLS_ASSERT(a);
    BSLS_ASSERT(b);

    RbTreeAnchor tmp(a->rootNode(),
                     a->firstNode(),
                     a->numNodes());
    a->reset(b->rootNode(), b->firstNode(), b->numNodes());
    b->reset(tmp.rootNode(), tmp.firstNode(), tmp.numNodes());

    // Readjust the sentinel nodes of both trees.

    if (0 == a->numNodes()) {
        a->setFirstNode(a->sentinel());
    }
    else {
        a->rootNode()->setParent(a->sentinel());
    }

    if (0 == b->numNodes()) {
        b->setFirstNode(b->sentinel());
    }
    else {
        b->rootNode()->setParent(b->sentinel());
    }
}

void String::toFixedLength(char       *dstString,
                           int         dstLength,
                           const char *srcString,
                           int         srcLength,
                           char        padChar)
{
    BSLS_ASSERT(dstString);
    BSLS_ASSERT(             0 <= dstLength);
    BSLS_ASSERT(srcString || 0 == srcLength);
    BSLS_ASSERT(             0 <= srcLength);

    if (dstLength < srcLength) {
        // We know 'srcLength > 0', therefore '0 != srcString'.

        if (dstString != srcString) {
            bsl::memmove(dstString, srcString, dstLength);
        }
    }
    else {
        if (srcString && dstString != srcString) {
            bsl::memmove(dstString, srcString, srcLength);
        }
        for (int i = srcLength; i < dstLength; ++i) {
            dstString[i] = padChar;
        }
    }
}

static
unsigned int hash(const char *data, int length)
    // That the memory starting at the specified 'data' of specified 'length'
    // bytes in length.
{
    BSLS_ASSERT(0 <= length);
    BSLS_ASSERT(data || 0 == length);

    typedef unsigned char Ub1;
    typedef unsigned int  Ub4;

    const Ub1 *k    = reinterpret_cast<const Ub1 *>(data);
    Ub4        hash = 0;

    for (int i = 0; i < length; ++i) {
        hash += k[i];
        hash += (hash << 10);
        hash ^= (hash >>  6);
    }

    hash += (hash <<  3);
    hash ^= (hash >> 11);
    hash += (hash << 15);

    return hash;
}

void bslmt::Sluice::wait(const void *token)
{
    GenerationDescriptor *g =
                static_cast<GenerationDescriptor *>(const_cast<void *>(token));

    for (;;) {
        g->d_sema.wait();

        LockGuard<Mutex> lock(&d_mutex);

        if (g->d_numSignaled) {
            const int numSignaled = --g->d_numSignaled;
            const int numThreads  = --g->d_numThreads;

            BSLS_ASSERT(numThreads >= numSignaled);
            BSLS_ASSERT(d_pendingGeneration != g);

            if (0 == numThreads) {
                // The last thread is responsible for cleanup.

                BSLS_ASSERT(d_signaledGeneration != g);

                g->d_next = d_descriptorPool;
                d_descriptorPool = g;
            }
            return;                                                   // RETURN
        }
        // Spurious wakeups happen because 'timedWait' may timeout on the
        // semaphore, but still consume a signal.
    }
}

int DecimalUtil::quantum(Decimal128 x)
{
    BSLS_ASSERT(!isInf(x));
    BSLS_ASSERT(!isNan(x));

    return decQuadGetExponent(x.data());
}

CountingAllocator::~CountingAllocator()
{
    BSLS_ASSERT(0               <= numBytesInUse());
    BSLS_ASSERT(0               <= numBytesTotal());
    BSLS_ASSERT(numBytesInUse() <= numBytesTotal());
    BSLS_ASSERT(d_allocator_p);
}

int TimeMetrics::percentage(int category)
{
    bslmt::LockGuard<bslmt::Mutex> lock(&d_dataLock);

    int result = 0;

    BSLS_ASSERT(0 <= category);
    BSLS_ASSERT(category < (int) d_categoryTimes.size());

    bsls::TimeInterval now = bdlt::CurrentTime::now();
    bsls::TimeInterval delta = now - d_categoryStartTimes[d_currentCategory];

    int deltaMS = static_cast<int>(delta.seconds() * 1000 +
                                              delta.nanoseconds() / k_MILLION);

    d_categoryTimes[d_currentCategory] += deltaMS;
    d_currentTotal += deltaMS;

    d_categoryStartTimes[d_currentCategory] = now;

    if (d_currentTotal) {
        result = static_cast<int>(
                           d_categoryTimes[category] * 100.0 / d_currentTotal);
    }

    return result < 0
           ? 0
           : result > 100
             ? 100
             : result;
}

TimeMetrics::~TimeMetrics()
{
    BSLS_ASSERT(d_categoryStartTimes.size() == d_categoryTimes.size());
    BSLS_ASSERT(d_currentCategory <
                                static_cast<int>(d_categoryStartTimes.size()));
    BSLS_ASSERT(0 <= d_currentCategory);
}

// MANIPULATORS
void *BlockList::allocate(int size)
{
    BSLS_ASSERT(0 <= size);

    if (0 == size) {
        return 0;                                                     // RETURN
    }

    size = alignedAllocationSize(size, sizeof(Block));

    Block *block = (Block *)d_allocator_p->allocate(size);

    BSLS_ASSERT(0 == bsls::AlignmentUtil::calculateAlignmentOffset(
                    (void *)block,
                    bsls::AlignmentUtil::BSLS_MAX_ALIGNMENT));

    block->d_next_p       = (Block *)d_head_p;
    block->d_addrPrevNext = (Block **)&d_head_p;
    if (d_head_p) {
        d_head_p->d_addrPrevNext = &block->d_next_p;
    }
    d_head_p = block;

    BSLS_ASSERT(0 == bsls::AlignmentUtil::calculateAlignmentOffset(
                    (void *)&block->d_memory,
                    bsls::AlignmentUtil::BSLS_MAX_ALIGNMENT));

    return (void *)&block->d_memory;
}

void TimeInterval::addInterval(bsls::Types::Int64 seconds,
                               int                nanoseconds)
{
    BSLS_ASSERT(isSumValidInt64(d_seconds, seconds));
    BSLS_ASSERT(isSumValidInt64(
       d_seconds + seconds,
       (static_cast<bsls::Types::Int64>(d_nanoseconds) + nanoseconds) /
                                                          k_NANOSECS_PER_SEC));

    d_seconds += seconds;
    bsls::Types::Int64 nanosecs = static_cast<bsls::Types::Int64>(nanoseconds)
                                + d_nanoseconds;

    if (nanosecs >=  k_NANOSECS_PER_SEC
     || nanosecs <= -k_NANOSECS_PER_SEC) {
        d_seconds     +=                  nanosecs / k_NANOSECS_PER_SEC;
        d_nanoseconds  = static_cast<int>(nanosecs % k_NANOSECS_PER_SEC);
    }
    else {
        d_nanoseconds = static_cast<int>(nanosecs);
    }

    if (d_seconds > 0 && d_nanoseconds < 0) {
        --d_seconds;
        d_nanoseconds += k_NANOSECS_PER_SEC;
    }
    else if (d_seconds < 0 && d_nanoseconds > 0) {
        ++d_seconds;
        d_nanoseconds -= k_NANOSECS_PER_SEC;
    }
}

void TcpConnector::deallocate(btlsc::Channel *channel)
{
    BSLS_ASSERT(channel);
    char *arena = (char *) channel;
    TcpTimedChannel *c =
        dynamic_cast<TcpTimedChannel*>(channel);
    btlso::StreamSocket<btlso::IPv4Address> *s = NULL;

    if (c) {
        s = c->socket();
    }
    else {
        TcpChannel *c =
            dynamic_cast<TcpChannel*>(channel);
        BSLS_ASSERT(c);
        s = c->socket();
    }
    BSLS_ASSERT(s);

    channel->invalidate();
    d_factory_p->deallocate(s);

    bsl::vector<btlsc::Channel*>::iterator idx =
               bsl::lower_bound(d_channels.begin(), d_channels.end(), channel);
    BSLS_ASSERT(idx != d_channels.end() && *idx == channel);
    d_channels.erase(idx);

    d_pool.deallocate(arena);
    return ;
}

int btlso::SocketImpUtil::write(const btlso::SocketHandle::Handle&  socket,
                                const void                         *buffer,
                                int                                 numBytes,
                                int                                *errorCode)
{
    // Implementation notes: For non blocking IO, the send operation will write
    // out some or all of the buffer if possible.  However, since the
    // implementation of sockets may include internal buffers of certain sizes
    // and optimizations, the send function may return a "would block" error or
    // an smaller than expected number of bytes written even if it appears as
    // if the internal socket buffer has more room.  This is known as the low
    // water mark and may be implemented even if the equivalent socket option
    // is not available.  For the blocking IO case, the send operation may
    // block until all or part of the data is written.  No assumption should be
    // made regarding the number of bytes that will be written with a single
    // call.

    int rc;

    BSLS_ASSERT(buffer);
    BSLS_ASSERT(numBytes >= 0);

    rc = ::send(socket, static_cast<const char *>(buffer), numBytes, 0);

    int errorNumber = rc >= 0 ? 0 : SocketImpUtil_Util::getErrorCode();
    if (errorNumber && errorCode) {
        *errorCode = errorNumber;
    }
    return errorNumber ? SocketImpUtil_Util::mapErrorCode(errorNumber) : rc;
}

// CREATORS
ChannelPoolChannel::ChannelPoolChannel(
                             int                             channelId,
                             ChannelPool                    *channelPool,
                             btlb::BlobBufferFactory        *blobBufferFactory,
                             bdlma::ConcurrentPoolAllocator *spAllocator,
                             bslma::Allocator               *basicAllocator)
: d_mutex()
, d_callbackInProgress(false)
, d_closed(false)
, d_readQueue(basicAllocator)
, d_blobBufferFactory_p(blobBufferFactory,
                        0,
                        &bslma::ManagedPtrUtil::noOpDeleter)
, d_spAllocator_p(spAllocator)
, d_channelPool_p(channelPool)
, d_nextClockId(channelId + 0x00800000)
, d_channelId(channelId)
, d_peerAddress()
, d_localAddress()
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    BSLS_ASSERT(0 != channelPool);
    BSLS_ASSERT(0 != blobBufferFactory);
    BSLS_ASSERT(0 != spAllocator);

    // Queue these addresses since the ChannelPool channel can have
    // disappeared when we get SESSION_DOWN.

    d_channelPool_p->getLocalAddress(&d_localAddress, d_channelId);
    d_channelPool_p->getPeerAddress(&d_peerAddress, d_channelId);
}

double PeriodDayCountUtil::yearsDiff(
                                 const bdlt::Date&              beginDate,
                                 const bdlt::Date&              endDate,
                                 const bsl::vector<bdlt::Date>& periodDate,
                                 double                         periodYearDiff,
                                 DayCountConvention::Enum       convention)
{
    BSLS_ASSERT(periodDate.size() >= 2);
    BSLS_ASSERT(periodDate.front() <= beginDate);
    BSLS_ASSERT(                      beginDate <= periodDate.back());
    BSLS_ASSERT(periodDate.front() <= endDate);
    BSLS_ASSERT(                      endDate   <= periodDate.back());

    BSLS_ASSERT_SAFE(isSortedAndUnique(periodDate.begin(), periodDate.end()));

    double numYears;

    switch (convention) {
      case DayCountConvention::e_PERIOD_ICMA_ACTUAL_ACTUAL: {
        numYears = bbldc::PeriodIcmaActualActual::yearsDiff(beginDate,
                                                            endDate,
                                                            periodDate,
                                                            periodYearDiff);
      } break;
      default: {
        BSLS_ASSERT_OPT(0 && "Unrecognized convention");
        numYears = 0.0;
      } break;
    }

    return numYears;
}

int baltzo::TimeZoneUtilImp::initLocalTime(
                                       bdlt::DatetimeTz        *result,
                                       LocalTimeValidity::Enum *resultValidity,
                                       const bdlt::Datetime&    localTime,
                                       const char              *timeZoneId,
                                       DstPolicy::Enum          dstPolicy,
                                       ZoneinfoCache           *cache)
{
    BSLS_ASSERT(result);
    BSLS_ASSERT(resultValidity);
    BSLS_ASSERT(timeZoneId);
    BSLS_ASSERT(cache);

    const Zoneinfo *timeZone;
    const int rc = lookupTimeZone(&timeZone, timeZoneId, cache);
    if (0 != rc) {
        return rc;                                                    // RETURN
    }

    Zoneinfo::TransitionConstIterator iter;
    resolveLocalTime(result,
                     resultValidity,
                     &iter,
                     localTime,
                     dstPolicy,
                     *timeZone);
    return 0;
}

// STATIC HELPER FUNCTIONS
static
int lookupTimeZone(const baltzo::Zoneinfo **timeZone,
                   const char              *timeZoneId,
                   baltzo::ZoneinfoCache   *cache)
    // Load, into the specified 'timeZone', the address of the time zone
    // information having the specified 'timeZoneId' from the specified
    // 'cache'.  Return 0 on success, and a non-zero value otherwise.  A return
    // status of 'baltzo::ErrorCode::k_UNSUPPORTED_ID' indicates that
    // 'timeZoneId' is not recognized.
{
    BSLS_ASSERT(timeZone);
    BSLS_ASSERT(timeZoneId);
    BSLS_ASSERT(cache);

    int rc = 0;
    *timeZone = cache->getZoneinfo(&rc, timeZoneId);
    BSLS_ASSERT((0 == rc && 0 != *timeZone) || (0 != rc && 0 == *timeZone));

    if (0 == *timeZone) {
        BALL_LOG_SET_CATEGORY(LOG_CATEGORY);
        BALL_LOG_INFO << "No data found for time zone '" << timeZoneId
                      << "' (rc = " << rc << ")." << BALL_LOG_END;
    }

    return rc;
}

static
unsigned int reverse_hash(const char *data, int length)
    // That the memory starting at the specified 'data' of specified 'length'
    // bytes in length.  Do the bytes in the reverse of the order that 'hash'
    // would do them, so that this function, when called on a little-endian
    // machine, will return the same value as 'hash' called on a big-endian
    // machine.
{
    BSLS_ASSERT(0 <= length);
    BSLS_ASSERT(data || 0 == length);

    typedef unsigned char Ub1;
    typedef unsigned int  Ub4;

    const Ub1 *k    = reinterpret_cast<const Ub1 *>(data);
    Ub4        hash = 0;

    for (int i = length; i > 0; ) {
        hash += k[--i];
        hash += (hash << 10);
        hash ^= (hash >>  6);
    }

    hash += (hash <<  3);
    hash ^= (hash >> 11);
    hash += (hash << 15);

    return hash;
}

// MANIPULATORS
void Throttle::initialize(int                         maxSimultaneousActions,
                          Int64                       nanosecondsPerAction,
                          bsls::SystemClockType::Enum clockType)
{
    BSLS_ASSERT(0 <= maxSimultaneousActions);
    BSLS_ASSERT(0 <= nanosecondsPerAction);
    BSLS_ASSERT(maxSimultaneousActions || nanosecondsPerAction);
    BSLS_ASSERT(LLONG_MAX / bsl::max(maxSimultaneousActions, 1) >=
                                                     nanosecondsPerAction);

    BSLS_ASSERT(bsls::SystemClockType::e_MONOTONIC == clockType ||
                bsls::SystemClockType::e_REALTIME  == clockType);

    AtomicOps::setInt64(&d_prevLeakTime, -k_TEN_YEARS_NANOSECONDS);
    if (0 == maxSimultaneousActions) {
        d_nanosecondsPerAction = k_ALLOW_NONE;
    }
    else if (0 == nanosecondsPerAction) {
        d_nanosecondsPerAction = k_ALLOW_ALL;
    }
    else {
        d_nanosecondsPerAction = nanosecondsPerAction;
    }

    // If 'd_nanosecondsPerAction' is set to 'allow all' or 'allow none', then
    // it doesn't matter what 'd_nanosecondsPerTotalReset' is.

    d_nanosecondsPerTotalReset = maxSimultaneousActions * nanosecondsPerAction;
    d_maxSimultaneousActions   = 0 == nanosecondsPerAction
                               ? INT_MAX
                               : maxSimultaneousActions;
    d_clockType = clockType;
}