Page MenuHomePhabricator
Differential D12799

[lib] Rename `deprecatedMinimallyEncodeRawThreadInfo` -> `minimallyEncodeRawThreadInfoWithMemberPermissions`
ClosedPublic
Actions

Authored by atul on Jul 18 2024, 2:48 PM.
Tags
None
Referenced Files
F6168354: D12799.id.diff
Wed, Apr 23, 1:12 AM
Unknown Object (File)
Mon, Apr 21, 3:34 PM
Unknown Object (File)
Mon, Apr 21, 3:34 PM
Unknown Object (File)
Mon, Apr 21, 3:34 PM
Unknown Object (File)
Sun, Apr 20, 3:38 PM
Unknown Object (File)
Sun, Apr 20, 2:57 PM
Unknown Object (File)
Sun, Apr 20, 3:34 AM
Unknown Object (File)
Sat, Apr 19, 5:09 AM
View All 90 Files
Subscribers
tomek

Details

Reviewers
ashoat
Commits
rCOMMd25e29a0be1e: [lib] Rename `deprecatedMinimallyEncodeRawThreadInfo` ->…
Summary

Based on feedback here: https://phab.comm.dev/D12779?id=42418#inline-74380

Test Plan

NA, simple rename using IDE refactor feature.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

Diff 42562

View Options

lib/permissions/minimally-encoded-thread-permissions.test.js

#pragma once #pragma once
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <mutex>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
enum class ReactorState { enum class ReactorState {
NONE = 0, NONE = 0,
RUNNING = 1, RUNNING = 1,
TERMINATED = 2, TERMINATED = 2,
DONE = 3, DONE = 3,
}; };
class BaseReactor { class BaseReactor {
private:
grpc::Status status = grpc::Status::OK;
std::mutex statusAccessMutex;
protected: protected:
ReactorState state = ReactorState::NONE; ReactorState state = ReactorState::NONE;
public: public:
grpc::Status getStatus() {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
return this->status;
}
void setStatus(const grpc::Status &status) {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
this->status = status;
}
ReactorState getState() const { ReactorState getState() const {
return this->state; return this->state;
} }
virtual void terminate(const grpc::Status &status){}; virtual void terminate(const grpc::Status &status){};
virtual void validate(){}; virtual void validate(){};
virtual void doneCallback(){}; virtual void doneCallback(){};
virtual void terminateCallback(){}; virtual void terminateCallback(){};
}; };
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

lib/shared/redux/deprecated-update-roles-and-permissions.js

#pragma once #pragma once
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <mutex>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
enum class ReactorState { enum class ReactorState {
NONE = 0, NONE = 0,
RUNNING = 1, RUNNING = 1,
TERMINATED = 2, TERMINATED = 2,
DONE = 3, DONE = 3,
}; };
class BaseReactor { class BaseReactor {
private:
grpc::Status status = grpc::Status::OK;
std::mutex statusAccessMutex;
protected: protected:
ReactorState state = ReactorState::NONE; ReactorState state = ReactorState::NONE;
public: public:
grpc::Status getStatus() {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
return this->status;
}
void setStatus(const grpc::Status &status) {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
this->status = status;
}
ReactorState getState() const { ReactorState getState() const {
return this->state; return this->state;
} }
virtual void terminate(const grpc::Status &status){}; virtual void terminate(const grpc::Status &status){};
virtual void validate(){}; virtual void validate(){};
virtual void doneCallback(){}; virtual void doneCallback(){};
virtual void terminateCallback(){}; virtual void terminateCallback(){};
}; };
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

lib/shared/thread-utils.js

#pragma once #pragma once
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <mutex>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
enum class ReactorState { enum class ReactorState {
NONE = 0, NONE = 0,
RUNNING = 1, RUNNING = 1,
TERMINATED = 2, TERMINATED = 2,
DONE = 3, DONE = 3,
}; };
class BaseReactor { class BaseReactor {
private:
grpc::Status status = grpc::Status::OK;
std::mutex statusAccessMutex;
protected: protected:
ReactorState state = ReactorState::NONE; ReactorState state = ReactorState::NONE;
public: public:
grpc::Status getStatus() {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
return this->status;
}
void setStatus(const grpc::Status &status) {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
this->status = status;
}
ReactorState getState() const { ReactorState getState() const {
return this->state; return this->state;
} }
virtual void terminate(const grpc::Status &status){}; virtual void terminate(const grpc::Status &status){};
virtual void validate(){}; virtual void validate(){};
virtual void doneCallback(){}; virtual void doneCallback(){};
virtual void terminateCallback(){}; virtual void terminateCallback(){};
}; };
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

lib/types/minimally-encoded-thread-permissions-types.js

#pragma once #pragma once
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <mutex>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
enum class ReactorState { enum class ReactorState {
NONE = 0, NONE = 0,
RUNNING = 1, RUNNING = 1,
TERMINATED = 2, TERMINATED = 2,
DONE = 3, DONE = 3,
}; };
class BaseReactor { class BaseReactor {
private:
grpc::Status status = grpc::Status::OK;
std::mutex statusAccessMutex;
protected: protected:
ReactorState state = ReactorState::NONE; ReactorState state = ReactorState::NONE;
public: public:
grpc::Status getStatus() {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
return this->status;
}
void setStatus(const grpc::Status &status) {
const std::unique_lock<std::mutex> lock(this->statusAccessMutex);
this->status = status;
}
ReactorState getState() const { ReactorState getState() const {
return this->state; return this->state;
} }
virtual void terminate(const grpc::Status &status){}; virtual void terminate(const grpc::Status &status){};
virtual void validate(){}; virtual void validate(){};
virtual void doneCallback(){}; virtual void doneCallback(){};
virtual void terminateCallback(){}; virtual void terminateCallback(){};
}; };
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

native/redux/persist.js

Loading...