自学教程：C++ BSLS_ASSERT函数代码示例

inlineRESULT *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;        }    }}

staticunsigned 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);}

// MANIPULATORSvoid *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;}

// CREATORSChannelPoolChannel::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 FUNCTIONSstaticint 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;}

staticunsigned 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;}

// MANIPULATORSvoid 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;}

void *BufferImpUtil::allocateFromBufferRaw(int                       *cursor,                                           char                      *buffer,                                           int                        size,                                           bsls::Alignment::Strategy  strategy){    BSLS_ASSERT(cursor);    BSLS_ASSERT(buffer);    BSLS_ASSERT(0 < size);    BSLS_ASSERT(0 <= *cursor);    void *result = 0;    switch (strategy) {      case bsls::Alignment::BSLS_MAXIMUM: {        result = BufferImpUtil::allocateMaximallyAlignedFromBufferRaw(cursor,                                                                      buffer,                                                                      size);      } break;      case bsls::Alignment::BSLS_NATURAL: {        result = BufferImpUtil::allocateNaturallyAlignedFromBufferRaw(cursor,                                                                      buffer,                                                                      size);      } break;      case bsls::Alignment::BSLS_BYTEALIGNED: {        result = BufferImpUtil::allocateOneByteAlignedFromBufferRaw(cursor,                                                                    buffer,                                                                    size);      } break;      default: {        BSLS_ASSERT_OPT(0 && "Invalid alignment 'strategy' value.");      } break;    }    return result;}

StackTraceTestAllocator::StackTraceTestAllocator(                                           int               numRecordedFrames,                                           bslma::Allocator *basicAllocator): d_magic(k_STACK_TRACE_TEST_ALLOCATOR_MAGIC), d_numBlocksInUse(0), d_blocks(0), d_mutex(), d_name("<unnamed>"), d_failureHandler(bsl::allocator_arg_t(),                   bsl::allocator<FailureHandler>(basicAllocator                                   ? basicAllocator                                   : &bslma::MallocFreeAllocator::singleton())), d_maxRecordedFrames(numRecordedFrames + k_IGNORE_FRAMES), d_traceBufferLength(getTraceBufferLength(numRecordedFrames)), d_ostream(&bsl::cerr), d_demangleFlag(true), d_allocator_p(basicAllocator ? basicAllocator                               : &bslma::MallocFreeAllocator::singleton()){    BSLS_ASSERT_OPT(numRecordedFrames >= 2);    BSLS_ASSERT(d_maxRecordedFrames >= numRecordedFrames);    BSLS_ASSERT(d_traceBufferLength >= d_maxRecordedFrames);    // This must be assigned in a statement in the body of the c'tor rather    // than in the initializer list to work around a microsoft bug with    // function pointers.    d_failureHandler = &failAbort;}