#include <grpcpp/server_context.h>

#include <algorithm>

#include <mutex>

#include <utility>

#include <grpc/compression.h>

#include <grpc/grpc.h>

#include <grpc/load_reporting.h>

#include <grpc/support/alloc.h>

#include <grpc/support/log.h>

#include <grpcpp/completion_queue.h>

#include <grpcpp/impl/call.h>

#include <grpcpp/support/time.h>

#include "src/core/lib/surface/call.h"

namespace grpc {

class ServerContext::CompletionOp final : public internal::CallOpSetInterface {

public:

// initial refs: one in the server context, one in the cq

CompletionOp()

cancelled_(0) {}

void FillOps(grpc_call* call, grpc_op* ops, size_t* nops) override;

bool FinalizeResult(void** tag, bool* status) override;

bool CheckCancelled(CompletionQueue* cq) {

cq->TryPluck(this);

return CheckCancelledNoPluck();

}

bool CheckCancelledAsync() { return CheckCancelledNoPluck(); }

void set_tag(void* tag) {

has_tag_ = true;

tag_ = tag;

}

void Unref();

private:

bool CheckCancelledNoPluck() {

std::lock_guard<std::mutex> g(mu_);

return finalized_ ? (cancelled_ != 0) : false;

}

bool has_tag_;

void* tag_;

std::mutex mu_;

int refs_;

bool finalized_;

int cancelled_;

};

void ServerContext::CompletionOp::Unref() {

std::unique_lock<std::mutex> lock(mu_);

if (--refs_ == 0) {

lock.unlock();

delete this;

}

}

void ServerContext::CompletionOp::FillOps(grpc_call* call, grpc_op* ops,

size_t* nops) {

ops->op = GRPC_OP_RECV_CLOSE_ON_SERVER;

ops->data.recv_close_on_server.cancelled = &cancelled_;

ops->flags = 0;

ops->reserved = nullptr;

*nops = 1;

}

bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) {

std::unique_lock<std::mutex> lock(mu_);

finalized_ = true;

bool ret = false;

if (has_tag_) {

*tag = tag_;

ret = true;

}

if (!*status) cancelled_ = 1;

if (--refs_ == 0) {

lock.unlock();

delete this;

}

return ret;

}

ServerContext::ServerContext()

has_pending_ops_(false) {}

ServerContext::ServerContext(gpr_timespec deadline, grpc_metadata_array* arr)

}

ServerContext::~ServerContext() {

if (call_) {

grpc_call_unref(call_);

}

if (completion_op_) {

completion_op_->Unref();

}

}

void ServerContext::BeginCompletionOp(internal::Call* call) {

}

internal::CompletionQueueTag* ServerContext::GetCompletionOpTag() {

return static_cast<internal::CompletionQueueTag*>(completion_op_);

}

void ServerContext::AddInitialMetadata(const grpc::string& key,

const grpc::string& value) {

initial_metadata_.insert(std::make_pair(key, value));

}

void ServerContext::AddTrailingMetadata(const grpc::string& key,

const grpc::string& value) {

trailing_metadata_.insert(std::make_pair(key, value));

}

void ServerContext::TryCancel() const {

}

bool ServerContext::IsCancelled() const {

}

void ServerContext::set_compression_algorithm(

}

grpc::string ServerContext::peer() const {

}

const struct census_context* ServerContext::census_context() const {

return grpc_census_call_get_context(call_);

}

void ServerContext::SetLoadReportingCosts(

}

} // namespace grpc