MovableAllocTestType::~MovableAllocTestType() { d_allocator_p->deallocate(d_data_p); BSLS_ASSERT_OPT(!!d_data_p == (bsltf::MoveState::e_NOT_MOVED == d_movedFrom)); // Ensure that this objects has not been bitwise moved. BSLS_ASSERT_OPT(this == d_self_p); }
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; }
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; }
void GuardingAllocator::deallocate(void *address) { if (BSLS_PERFORMANCEHINT_PREDICT_UNLIKELY(0 == address)) { BSLS_PERFORMANCEHINT_UNLIKELY_HINT; return; // RETURN } const int pageSize = getSystemPageSize(); void *firstPage; // address of the first page of the allocation void *guardPage; // address of the guard page if (e_BEFORE_USER_BLOCK == d_guardPageLocation) { // The memory page before the block returned to the user is protected. firstPage = static_cast<char *>(address) - pageSize; guardPage = firstPage; } else { // The memory page after the block returned to the user is protected. firstPage = *(void **)(static_cast<char *>(address) - OFFSET); guardPage = *(void **)(static_cast<char *>(address) - OFFSET * 2); } // Unprotect the guard page and free the memory. const int rc = systemUnprotect(guardPage, pageSize); (void)rc; BSLS_ASSERT_OPT(0 == rc); systemFree(firstPage); }
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; }
void StdTestAllocatorConfiguration::setDelegateAllocatorRaw( bslma::Allocator *basicAllocator) { BSLS_ASSERT_OPT(basicAllocator); s_StdTestAllocatorConfiguration_allocator_p = basicAllocator; }
AllocTestType::~AllocTestType() { d_allocator_p->deallocate(d_data_p); // Ensure that this objects has not been bitwise moved. BSLS_ASSERT_OPT(this == d_self_p); }
// CLASS METHODS int PeriodDayCountUtil::daysDiff(const bdlt::Date& beginDate, const bdlt::Date& endDate, DayCountConvention::Enum convention) { int numDays; switch (convention) { case DayCountConvention::e_PERIOD_ICMA_ACTUAL_ACTUAL: { numDays = bbldc::PeriodIcmaActualActual::daysDiff(beginDate, endDate); } break; default: { BSLS_ASSERT_OPT(0 && "Unrecognized convention"); numDays = 0; } break; } return numDays; }
FixedThreadPool::FixedThreadPool(int numThreads, int maxNumPendingJobs, bslma::Allocator *basicAllocator) : d_queue(maxNumPendingJobs, basicAllocator) , d_control(e_STOP) , d_gateCount(0) , d_numThreadsReady(0) , d_threadGroup(basicAllocator) , d_numThreads(numThreads) { BSLS_ASSERT_OPT(0 != d_numThreads); disable(); #if defined(BSLS_PLATFORM_OS_UNIX) initBlockSet(&d_blockSet); #endif }
double BasicDayCountUtil::yearsDiff(const bdlt::Date& beginDate, const bdlt::Date& endDate, DayCountConvention::Enum convention) { double numYears; switch (convention) { case DayCountConvention::e_ACTUAL_360: { numYears = bbldc::BasicActual360::yearsDiff(beginDate, endDate); } break; case DayCountConvention::e_ACTUAL_365_FIXED: { numYears = bbldc::BasicActual365Fixed::yearsDiff(beginDate, endDate); } break; case DayCountConvention::e_ISDA_ACTUAL_ACTUAL: { numYears = bbldc::BasicIsdaActualActual::yearsDiff(beginDate, endDate); } break; case DayCountConvention::e_ISMA_30_360: { numYears = bbldc::BasicIsma30360::yearsDiff(beginDate, endDate); } break; case DayCountConvention::e_PSA_30_360_EOM: { numYears = bbldc::BasicPsa30360Eom::yearsDiff(beginDate, endDate); } break; case DayCountConvention::e_SIA_30_360_EOM: { numYears = bbldc::BasicSia30360Eom::yearsDiff(beginDate, endDate); } break; case DayCountConvention::e_SIA_30_360_NEOM: { numYears = bbldc::BasicSia30360Neom::yearsDiff(beginDate, endDate); } break; default: { BSLS_ASSERT_OPT(0 && "Unrecognized convention"); numYears = 0.0; } break; } return numYears; }
int SocketImpUtil_Util::mapErrorCode(int errorNumber) { switch ( #if defined(BTLSO_PLATFORM_WIN_SOCKETS) errorNumber #else BSLS_PERFORMANCEHINT_PREDICT_EXPECT(errorNumber, EAGAIN) #endif ) { #if defined(BTLSO_PLATFORM_WIN_SOCKETS) // Windows (WINSOCK) specific socket error codes // WSAEWOULDBLOCK is the most likely error for common use. case WSAEWOULDBLOCK: // FALL THROUGH case WSAEINPROGRESS: { return btlso::SocketHandle::e_ERROR_WOULDBLOCK; // RETURN } case WSAECONNABORTED: // FALL THROUGH case WSAECONNREFUSED: // FALL THROUGH case WSAECONNRESET: // FALL THROUGH case WSAEDISCON: // FALL THROUGH case WSAEHOSTDOWN: // FALL THROUGH case WSAEHOSTUNREACH: // FALL THROUGH case WSAENETDOWN: // FALL THROUGH case WSAENETRESET: // FALL THROUGH case WSAENETUNREACH: // FALL THROUGH case WSAENOTCONN: // FALL THROUGH case WSAEREFUSED: // FALL THROUGH case WSAETIMEDOUT: { return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } case WSAEINTR: { return btlso::SocketHandle::e_ERROR_INTERRUPTED; // RETURN } case WSAEACCES: // FALL THROUGH case WSAEADDRINUSE: // FALL THROUGH case WSAEADDRNOTAVAIL: // FALL THROUGH case WSAEISCONN: // FALL THROUGH case WSAELOOP: // FALL THROUGH case WSAEMFILE: // FALL THROUGH case WSAEMSGSIZE: // FALL THROUGH case WSAENOTSOCK: // FALL THROUGH case WSAESTALE: // FALL THROUGH case WSANOTINITIALISED: // FALL THROUGH case WSASYSNOTREADY: { return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } case WSAEAFNOSUPPORT: // FALL THROUGH case WSAEALREADY: // FALL THROUGH case WSAEBADF: // FALL THROUGH case WSAECANCELLED: // FALL THROUGH case WSAEDESTADDRREQ: // FALL THROUGH case WSAEDQUOT: // FALL THROUGH case WSAEFAULT: // FALL THROUGH case WSAEINVAL: // FALL THROUGH case WSAEINVALIDPROCTABLE: // FALL THROUGH case WSAEINVALIDPROVIDER: // FALL THROUGH case WSAENAMETOOLONG: // FALL THROUGH case WSAENOBUFS: // FALL THROUGH case WSAENOMORE: // FALL THROUGH case WSAENOPROTOOPT: // FALL THROUGH case WSAENOTEMPTY: // FALL THROUGH case WSAEOPNOTSUPP: // FALL THROUGH case WSAEPFNOSUPPORT: // FALL THROUGH case WSAEPROCLIM: // FALL THROUGH case WSAEPROTONOSUPPORT: // FALL THROUGH case WSAEPROTOTYPE: // FALL THROUGH case WSAEPROVIDERFAILEDINIT: // FALL THROUGH case WSAEREMOTE: // FALL THROUGH case WSAESHUTDOWN: // FALL THROUGH case WSAESOCKTNOSUPPORT: // FALL THROUGH case WSAETOOMANYREFS: // FALL THROUGH case WSAEUSERS: // FALL THROUGH case WSASERVICE_NOT_FOUND: // FALL THROUGH case WSASYSCALLFAILURE: // FALL THROUGH case WSATYPE_NOT_FOUND: // FALL THROUGH case WSAVERNOTSUPPORTED: // FALL THROUGH case WSA_E_CANCELLED: // FALL THROUGH case WSA_E_NO_MORE: { return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #else #if EAGAIN!=EWOULDBLOCK case EAGAIN: #endif case EWOULDBLOCK: { return btlso::SocketHandle::e_ERROR_WOULDBLOCK; // RETURN } #ifdef EACCES case EACCES: { // Search permission is denied for a component of the path prefix of // the pathname in name. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef EADDRINUSE case EADDRINUSE: { // The address is already in use. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef EADDRNOTAVAIL case EADDRNOTAVAIL: { // The specified address is not available on the remote // machine. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef EAFNOSUPPORT case EAFNOSUPPORT: { // Addresses in the specified address family cannot be // used with this socket. return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef EALREADY case EALREADY: { // The socket is non-blocking and a previous connection // attempt has not yet been completed. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef EBADF case EBADF: { // The descriptor is invalid. return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ECONNREFUSED case ECONNREFUSED: { // The attempt to connect was forcefully rejected. return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef EINPROGRESS case EINPROGRESS: { // The socket is non-blocking and the connection cannot be completed // immediately. return btlso::SocketHandle::e_ERROR_WOULDBLOCK; // RETURN } #endif case EINTR: { // The operation was interrupted by the delivery of a signal. return btlso::SocketHandle::e_ERROR_INTERRUPTED; // RETURN } #ifdef EIO case EIO: { // An I/O error occurred while reading from or writing to the file // system. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef EINVAL case EINVAL: { // tolen is not the size of a valid address for the specified // address family. return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef EISCONN case EISCONN: { // The socket is already connected. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef ELOOP case ELOOP: { // Too many symbolic links were encountered in translating the // pathname in name. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef ENETUNREACH case ENETUNREACH: { // The network is not reachable from this host. return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef EMSGSIZE case EMSGSIZE: { // The socket requires that message be sent atomically, and the // message was too long. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef EMFILE case EMFILE: { // The per-process descriptor table is full. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef ENFILE case ENFILE: { // The maximum number of file descriptors in the system are already // open. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef ENODEV case ENODEV: { // The protocol family and type corresponding to s could not be // found in the netconfig file. return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ENOMEM case ENOMEM: { // There was insufficient user memory available to complete the // operation. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef ENOSR case ENOSR: { // There were insufficient STREAMS resources available to complete // the operation. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef ENOENT case ENOENT: { // A component of the path prefix of the pathname in name does not // exist. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef ENXIO case ENXIO: { // The server exited before the connection was complete. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif case ETIMEDOUT: { // Connection establishment timed out without establishing a // connection. return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #ifdef ENOTSOCK case ENOTSOCK: { // The descriptor does not reference a socket. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #ifdef EOPNOTSUPP case EOPNOTSUPP: { // The referenced socket is not of type SOCK_STREAM. return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef EOPNOSUPPORT case EOPNOSUPPORT: { // The specified protocol does not support creation of socket // pairs. return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef EPIPE case EPIPE: { // An attempt is made to write to a socket that is not open for // reading, or that has only one end open or that is no longer // connected to a peer endpoint. A SIGPIPE signal will also be sent // to the process. The process dies unless special provisions were // taken to catch or ignore the signal. return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef EPROTONOSUPPORT case EPROTONOSUPPORT: { // The specified protocol is not supported on this machine. return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef EPROTO case EPROTO: { // A protocol error has occurred; return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ECONNABORTED case ECONNABORTED: { // Software caused connection abort return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef ECONNRESET case ECONNRESET: { // Connection reset by peer return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef EDESTADDRREQ case EDESTADDRREQ: { // Destination address required return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef EHOSTDOWN case EHOSTDOWN: { // Host is down return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef EHOSTUNREACH case EHOSTUNREACH: { // No route to host return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef ENETDOWN case ENETDOWN: { // Network is down return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef ENETRESET case ENETRESET: { // Network dropped connection because return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef ENOBUFS case ENOBUFS: { // No buffer space available return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ENOPROTOOPT case ENOPROTOOPT: { // Protocol not available return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ENOTCONN case ENOTCONN: { // Socket is not connected return btlso::SocketHandle::e_ERROR_CONNDEAD; // RETURN } #endif #ifdef EPFNOSUPPORT case EPFNOSUPPORT: { // Protocol family not supported return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef EPROTOTYPE case EPROTOTYPE: { // Protocol wrong type for socket return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ESHUTDOWN case ESHUTDOWN: { // Cant send after socket shutdown return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ESOCKTNOSUPPORT case ESOCKTNOSUPPORT: { // Socket type not supported return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ETOOMANYREFS case ETOOMANYREFS: { // Too many references: cant splice return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } #endif #ifdef ESTALE case ESTALE: { // A stale NFS file handle exists. return btlso::SocketHandle::e_ERROR_NORESOURCES; // RETURN } #endif #endif case 0: { return 0; // RETURN } default: { return btlso::SocketHandle::e_ERROR_UNCLASSIFIED; // RETURN } } BSLS_ASSERT_OPT("Unreachable" && 0); return 0; }