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;
}
Exemple #2
0
// PRIVATE ACCESSORS
bool
bdlc::IndexClerk::areInvariantsPreserved(const bsl::vector<int>& unusedStack,
                                         int                     nextNewIndex)
{
    int         indicesInvalid   = 0;
    int         indicesNotUnique = 0;
    bsl::size_t size             = unusedStack.size();

    bsl::vector<char> bin(nextNewIndex, 0);

    // Optimizing for the valid case.

    for (bsl::size_t i = 0; i < size; ++i) {
        indicesInvalid |= ((unsigned int) unusedStack[i] >=
                                                  (unsigned int) nextNewIndex);

        if (BSLS_PERFORMANCEHINT_PREDICT_LIKELY(!indicesInvalid)) {
            indicesNotUnique |= ++bin[unusedStack[i]];
        }
    }

    if (indicesInvalid || (indicesNotUnique & 0x2)) {
        return false;                                                 // RETURN
    }

    return true;
}
static inline
bool validIndex(const bsl::vector<TYPE>& vector, int index)
    // Return 'true' if the specified 'index' is within the range of valid
    // indices of the specified 'vector', and 'false' otherwise.
{
    return 0 <= index && (unsigned int) index < vector.size();
}
 // MANIPULATORS
 int pushBack(const TYPE& value)
     // Append the specified 'value' to this thread-enabled vector and
     // return the index of the new element.
 {
     bslmt::LockGuard<bslmt::Mutex> guard(&d_mutex);
     d_elements.push_back(value);
     return static_cast<int>(d_elements.size()) - 1;
 }
Exemple #5
0
// MANIPULATORS
void my_Logger::logMessage(const bsl::string& message, Severity severity)
{
    archive.push_back(message);
    switch (severity) {
      case TRACE: {
        // Do nothing beyond archiving the message.
      } break;
      case WARN: {
        ball::Context context(ball::Transmission::e_PASSTHROUGH, 0, 1);
        publish(message, context);
      } break;
      case ERROR: {
        int index  = 0;
        int length = (int)archive.size();
        ball::Context context(ball::Transmission::e_TRIGGER, index, length);
        while (length--) {
            publish(archive[length], context);
            context.setRecordIndexRaw(++index);
        }
        archive.clear();  // flush archive
      } break;
    }
}
static
int loadLocalTimeDescriptors(
                bsl::vector<baltzo::LocalTimeDescriptor> *descriptors,
                const bsl::vector<RawLocalTimeType>&      localTimeDescriptors,
                const bsl::vector<char>&                  abbreviationBuffer)
    // Load the specified 'descriptors' with the sequence of local time
    // descriptors described by the specified 'localTimeDescriptors' holding
    // raw information read from the file, and referring to null-terminated
    // abbreviations in the specified 'abbreviationBuffer'.  Return 0 on
    // success, and a non-zero value otherwise.
{
    BALL_LOG_SET_CATEGORY(LOG_CATEGORY);

    for (bsl::size_t i = 0; i < localTimeDescriptors.size(); ++i) {
        if (!validIndex(abbreviationBuffer,
                        localTimeDescriptors[i].d_abbreviationIndex)) {
            BALL_LOG_ERROR << "Invalid abbreviation buffer index "
                           << (int)localTimeDescriptors[i].d_abbreviationIndex
                           << " found in Zoneinfo file.  Expecting [0 .. "
                           << abbreviationBuffer.size() - 1
                           << "]."
                           << BALL_LOG_END;
            return -20;                                               // RETURN
        }

        const int utcOffset = decode32(localTimeDescriptors[i].d_offset);

        if (!baltzo::LocalTimeDescriptor::isValidUtcOffsetInSeconds(
                                                                  utcOffset)) {
            BALL_LOG_ERROR << "Invalid UTC offset "
                           << utcOffset
                           << " found in Zoneinfo file.  Expecting "
                           << "[-86399 .. 86399]."
                           << BALL_LOG_END;

            return -21;                                               // RETURN
        }
        const bool isDst = localTimeDescriptors[i].d_isDst;

        // Passing the address of the first character pointed by the index (C
        // string).

        const char *description =
              &abbreviationBuffer[localTimeDescriptors[i].d_abbreviationIndex];

        // Check if 'description' is null-terminated.

        const int maxLength = abbreviationBuffer.size()
                              - localTimeDescriptors[i].d_abbreviationIndex
                              - 1;
        if (maxLength < bdlb::String::strnlen(description, maxLength + 1)) {
            BALL_LOG_ERROR << "Abbreviation string is not null-terminated."
                           << BALL_LOG_END;
            return -22;                                               // RETURN
        }

        descriptors->push_back(baltzo::LocalTimeDescriptor(utcOffset,
                                                          isDst,
                                                          description));
    }

    return 0;
}
 int length() const
     // Return the number of elements in this thread-enabled vector.
 {
     bslmt::LockGuard<bslmt::Mutex> guard(&d_mutex);
     return static_cast<int>(d_elements.size());
 }
static inline int dispatchCallbacks(bsl::vector<struct ::pollfd>  *tmp,
                                    bsl::vector<struct ::pollfd>&  pollFds,
                                    CallbackMap                   *callbacks)
{
    BSLS_ASSERT(tmp);
    BSLS_ASSERT(0 == tmp->size()); // Internal invariant

    int numCallbacks = 0;

    // Implementation note: We need to make a local copy of signaled the
    // sockets because an invoked callback can potentially modify 'pollFds'
    // array thereby corrupting the iteration order.  In the worst case, a
    // full copy of 'pollFds' is made.

    typedef bsl::vector<struct ::pollfd>::size_type size_type;

    size_type numSockets = pollFds.size();
    for (size_type i = 0; i < numSockets; ++i) {
        const struct ::pollfd& data = pollFds[i];
        if (0 != data.revents) {
            tmp->push_back(data);
        }
    }

    numSockets = tmp->size();
    for (size_type i = 0; i < numSockets; ++i) {
        const struct ::pollfd& currData = (*tmp)[i];

        // READ/ACCEPT.

        enum { DEFAULT_MASK = POLLERR | POLLHUP | POLLNVAL };

        if (currData.revents & (POLLIN | DEFAULT_MASK)) {
            CallbackMap::iterator callbackIt, cbEnd = callbacks->end();

            if (cbEnd != (callbackIt = callbacks->find(
                                                     Event(currData.fd,
                                                           EventType::e_READ)))
             || cbEnd != (callbackIt = callbacks->find(
                                         Event(currData.fd,
                                               btlso::EventType::e_ACCEPT)))) {
                (callbackIt->second)();
                ++numCallbacks;
            }
        }

        // WRITE/CONNECT.

        if (currData.revents & (POLLOUT | DEFAULT_MASK)) {
            CallbackMap::iterator callbackIt, cbEnd = callbacks->end();

            if (cbEnd != (callbackIt = callbacks->find(
                                                    Event(currData.fd,
                                                          EventType::e_WRITE)))
             || cbEnd != (callbackIt = callbacks->find(
                                               Event(currData.fd,
                                                     EventType::e_CONNECT)))) {
                (callbackIt->second)();
                ++numCallbacks;
            }
        }
    }
    tmp->clear();
    return numCallbacks;
}
 inline
 int my_RecordBuffer::length() const
 {
     bslmt::LockGuard<bslmt::RecursiveMutex> guard(&d_mutex);
     return d_buffer.size();
 }