folly/folly/io/async/AsyncBase.cpp

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <folly/io/async/AsyncBase.h>

#include <cerrno>
#include <ostream>
#include <stdexcept>
#include <string>

#include <boost/intrusive/parent_from_member.hpp>
#include <glog/logging.h>

#include <folly/Exception.h>
#include <folly/Format.h>
#include <folly/Likely.h>
#include <folly/String.h>
#include <folly/portability/Filesystem.h>
#include <folly/portability/Unistd.h>

namespace folly {

AsyncBaseOp::AsyncBaseOp(NotificationCallback cb)
    : … { … }

void AsyncBaseOp::reset(NotificationCallback cb) { … }

AsyncBaseOp::~AsyncBaseOp() { … }

void AsyncBaseOp::start() { … }

void AsyncBaseOp::unstart() { … }

void AsyncBaseOp::complete(ssize_t result) { … }

void AsyncBaseOp::cancel() { … }

ssize_t AsyncBaseOp::result() const { … }

void AsyncBaseOp::init() { … }

std::string AsyncBaseOp::fd2name(int fd) { … }

AsyncBase::AsyncBase(size_t capacity, PollMode pollMode)
    : … { … }

AsyncBase::~AsyncBase() { … }

void AsyncBase::decrementPending(size_t n) { … }

void AsyncBase::submit(Op* op) { … }

int AsyncBase::submit(Range<Op**> ops) { … }

Range<AsyncBase::Op**> AsyncBase::wait(size_t minRequests) { … }

Range<AsyncBase::Op**> AsyncBase::cancel() { … }

Range<AsyncBase::Op**> AsyncBase::pollCompleted() { … }

AsyncBaseQueue::AsyncBaseQueue(AsyncBase* asyncBase) : … { … }

AsyncBaseQueue::~AsyncBaseQueue() { … }

void AsyncBaseQueue::submit(AsyncBaseOp* op) { … }

void AsyncBaseQueue::submit(OpFactory op) { … }

void AsyncBaseQueue::onCompleted(AsyncBaseOp* /* op */) { … }

void AsyncBaseQueue::maybeDequeue() { … }

// debugging helpers:

namespace {

#define X …

const char* asyncIoOpStateToString(AsyncBaseOp::State state) { … }
#undef X
} // namespace

std::ostream& operator<<(std::ostream& os, const AsyncBaseOp& op) { … }

std::ostream& operator<<(std::ostream& os, AsyncBaseOp::State state) { … }

} // namespace folly