SYMBOL INDEX (222 symbols across 34 files)

FILE: foxglove_bridge_base/include/foxglove_bridge/base64.hpp
  type foxglove_ws (line 8) | namespace foxglove_ws {

FILE: foxglove_bridge_base/include/foxglove_bridge/callback_queue.hpp
  type foxglove_ws (line 13) | namespace foxglove_ws {
    class CallbackQueue (line 15) | class CallbackQueue {
      method CallbackQueue (line 17) | CallbackQueue(LogCallback logCallback, size_t numThreads = 1)
      method stop (line 29) | void stop() {
      method addCallback (line 37) | void addCallback(std::function<void(void)> cb) {
      method doWork (line 47) | void doWork() {

FILE: foxglove_bridge_base/include/foxglove_bridge/common.hpp
  type foxglove_ws (line 10) | namespace foxglove_ws {
    type BinaryOpcode (line 36) | enum class BinaryOpcode : uint8_t {
    type ClientBinaryOpcode (line 43) | enum class ClientBinaryOpcode : uint8_t {
    type WebSocketLogLevel (line 48) | enum class WebSocketLogLevel {
    type ChannelWithoutId (line 56) | struct ChannelWithoutId {
    type Channel (line 69) | struct Channel : ChannelWithoutId {
      method Channel (line 72) | Channel() = default;
      method Channel (line 73) | Channel(ChannelId id, ChannelWithoutId ch)
    type ClientAdvertisement (line 82) | struct ClientAdvertisement {
    type ClientMessage (line 90) | struct ClientMessage {
      method ClientMessage (line 98) | ClientMessage(uint64_t logTime, uint64_t publishTime, uint32_t seque...
      method getLength (line 114) | std::size_t getLength() const {
    type ServiceWithoutId (line 119) | struct ServiceWithoutId {
    type Service (line 126) | struct Service : ServiceWithoutId {
      method Service (line 129) | Service() = default;
      method Service (line 130) | Service(const ServiceWithoutId& s, const ServiceId& id)
    type ServiceResponse (line 135) | struct ServiceResponse {
      method size (line 141) | size_t size() const {
    type FetchAssetStatus (line 155) | enum class FetchAssetStatus : uint8_t {
    type FetchAssetResponse (line 160) | struct FetchAssetResponse {

FILE: foxglove_bridge_base/include/foxglove_bridge/foxglove_bridge.hpp
  type foxglove (line 3) | namespace foxglove {

FILE: foxglove_bridge_base/include/foxglove_bridge/message_definition_cache.hpp
  type foxglove (line 9) | namespace foxglove {
    type MessageDefinitionFormat (line 19) | enum struct MessageDefinitionFormat {
    type MessageSpec (line 24) | struct MessageSpec {
    type DefinitionIdentifier (line 31) | struct DefinitionIdentifier {
    class DefinitionNotFoundError (line 40) | class DefinitionNotFoundError : public std::exception {
      method DefinitionNotFoundError (line 45) | explicit DefinitionNotFoundError(std::string name)
    class MessageDefinitionCache (line 53) | class MessageDefinitionCache final {
      type DefinitionIdentifierHash (line 67) | struct DefinitionIdentifierHash {

FILE: foxglove_bridge_base/include/foxglove_bridge/parameter.hpp
  type foxglove_ws (line 9) | namespace foxglove_ws {
    type ParameterSubscriptionOperation (line 11) | enum class ParameterSubscriptionOperation {
    type ParameterType (line 16) | enum class ParameterType {
    class ParameterValue (line 27) | class ParameterValue {
      method ParameterType (line 40) | inline ParameterType getType() const {
      method T (line 45) | inline const T& getValue() const {
    class Parameter (line 54) | class Parameter {
      method ParameterType (line 64) | inline ParameterType getType() const {
      method ParameterValue (line 68) | inline const ParameterValue& getValue() const {

FILE: foxglove_bridge_base/include/foxglove_bridge/regex_utils.hpp
  type foxglove_ws (line 8) | namespace foxglove_ws {
    function isWhitelisted (line 10) | inline bool isWhitelisted(const std::string& name, const std::vector<s...

FILE: foxglove_bridge_base/include/foxglove_bridge/serialization.hpp
  type foxglove_ws (line 10) | namespace foxglove_ws {
    function WriteUint64LE (line 12) | inline void WriteUint64LE(uint8_t* buf, uint64_t val) {
    function WriteUint32LE (line 27) | inline void WriteUint32LE(uint8_t* buf, uint32_t val) {
    function ReadUint32LE (line 38) | inline uint32_t ReadUint32LE(const uint8_t* buf) {

FILE: foxglove_bridge_base/include/foxglove_bridge/server_factory.hpp
  type foxglove_ws (line 11) | namespace foxglove_ws {
    class ServerFactory (line 13) | class ServerFactory {

FILE: foxglove_bridge_base/include/foxglove_bridge/server_interface.hpp
  type foxglove_ws (line 14) | namespace foxglove_ws {
    class ExeptionWithId (line 21) | class ExeptionWithId : public std::runtime_error {
      method ExeptionWithId (line 23) | explicit ExeptionWithId(IdType id, const std::string& what_arg)
      method IdType (line 27) | IdType id() const {
    class ChannelError (line 35) | class ChannelError : public ExeptionWithId<ChannelId> {
    class ClientChannelError (line 38) | class ClientChannelError : public ExeptionWithId<ClientChannelId> {
    class ServiceError (line 41) | class ServiceError : public ExeptionWithId<ServiceId> {
    type ServerOptions (line 45) | struct ServerOptions {
    type ServerHandlers (line 59) | struct ServerHandlers {
    class ServerInterface (line 80) | class ServerInterface {

FILE: foxglove_bridge_base/include/foxglove_bridge/test/test_client.hpp
  type foxglove_ws (line 12) | namespace foxglove_ws {
    class Client<websocketpp::config::asio_client> (line 30) | class Client<websocketpp::config::asio_client>

FILE: foxglove_bridge_base/include/foxglove_bridge/websocket_client.hpp
  type foxglove_ws (line 19) | namespace foxglove_ws {
    function to_json (line 21) | inline void to_json(nlohmann::json& j, const ClientAdvertisement& p) {
    class ClientInterface (line 32) | class ClientInterface {
    class Client (line 60) | class Client : public ClientInterface {
      method Client (line 66) | Client() {
      method connect (line 85) | void connect(const std::string& uri,
      method connect (line 108) | std::future<void> connect(const std::string& uri) override {
      method close (line 119) | void close() override {
      method messageHandler (line 129) | void messageHandler(websocketpp::connection_hdl hdl, MessagePtr msg) {
      method subscribe (line 152) | void subscribe(const std::vector<std::pair<SubscriptionId, ChannelId...
      method unsubscribe (line 163) | void unsubscribe(const std::vector<SubscriptionId>& subscriptionIds)...
      method advertise (line 169) | void advertise(const std::vector<ClientAdvertisement>& channels) ove...
      method unadvertise (line 174) | void unadvertise(const std::vector<ClientChannelId>& channelIds) ove...
      method publish (line 180) | void publish(ClientChannelId channelId, const uint8_t* buffer, size_...
      method sendServiceRequest (line 188) | void sendServiceRequest(const ServiceRequest& request) override {
      method getParameters (line 195) | void getParameters(const std::vector<std::string>& parameterNames,
      method setParameters (line 204) | void setParameters(const std::vector<Parameter>& parameters,
      method subscribeParameterUpdates (line 213) | void subscribeParameterUpdates(const std::vector<std::string>& param...
      method unsubscribeParameterUpdates (line 219) | void unsubscribeParameterUpdates(const std::vector<std::string>& par...
      method fetchAsset (line 225) | void fetchAsset(const std::string& uri, uint32_t requestId) override {
      method setTextMessageHandler (line 230) | void setTextMessageHandler(TextMessageHandler handler) override {
      method setBinaryMessageHandler (line 235) | void setBinaryMessageHandler(BinaryMessageHandler handler) override {
      method sendText (line 240) | void sendText(const std::string& payload) {
      method sendBinary (line 245) | void sendBinary(const uint8_t* data, size_t dataLength) {

FILE: foxglove_bridge_base/include/foxglove_bridge/websocket_logging.hpp
  type foxglove_ws (line 10) | namespace foxglove_ws {
    function IPAddressToString (line 14) | inline std::string IPAddressToString(const websocketpp::lib::asio::ip:...
    function NoOpLogCallback (line 21) | inline void NoOpLogCallback(WebSocketLogLevel, char const*) {}
    class CallbackLogger (line 23) | class CallbackLogger {
      method CallbackLogger (line 27) | CallbackLogger(channel_type_hint::value hint = channel_type_hint::ac...
      method CallbackLogger (line 33) | CallbackLogger(websocketpp::log::level channels,
      method set_callback (line 40) | void set_callback(LogCallback callback) {
      method set_channels (line 44) | void set_channels(websocketpp::log::level channels) {
      method clear_channels (line 53) | void clear_channels(websocketpp::log::level channels) {
      method write (line 57) | void write(websocketpp::log::level channel, std::string const& msg) {
      method write (line 61) | void write(websocketpp::log::level channel, char const* msg) {
      method static_test (line 85) | constexpr bool static_test(websocketpp::log::level channel) const {
      method dynamic_test (line 89) | bool dynamic_test(websocketpp::log::level channel) {

FILE: foxglove_bridge_base/include/foxglove_bridge/websocket_notls.hpp
  type foxglove_ws (line 9) | namespace foxglove_ws {
    type WebSocketNoTls (line 11) | struct WebSocketNoTls : public websocketpp::config::core {
      type transport_config (line 29) | struct transport_config : public base::transport_config {
      type permessage_deflate_config (line 40) | struct permessage_deflate_config {}

FILE: foxglove_bridge_base/include/foxglove_bridge/websocket_server.hpp
  function StringHash (line 43) | constexpr uint32_t StringHash(const std::string_view str) {
  type foxglove_ws (line 64) | namespace foxglove_ws {
    type StatusLevel (line 96) | enum class StatusLevel : uint8_t {
    function StatusLevelToLogLevel (line 102) | constexpr websocketpp::log::level StatusLevelToLogLevel(StatusLevel le...
    class Server (line 116) | class Server final : public ServerInterface<ConnHandle> {
      method Server (line 126) | Server(const Server&) = delete;
      method Server (line 127) | Server(Server&&) = delete;
      method Server (line 128) | Server& operator=(const Server&) = delete;
      method Server (line 129) | Server& operator=(Server&&) = delete;
      type ClientInfo (line 158) | struct ClientInfo {
        method ClientInfo (line 165) | explicit ClientInfo(const std::string& name, ConnHandle handle)
        method ClientInfo (line 169) | ClientInfo(const ClientInfo&) = delete;
        method ClientInfo (line 170) | ClientInfo& operator=(const ClientInfo&) = delete;
        method ClientInfo (line 172) | ClientInfo(ClientInfo&&) = default;
        method ClientInfo (line 173) | ClientInfo& operator=(ClientInfo&&) = default;

FILE: foxglove_bridge_base/include/foxglove_bridge/websocket_tls.hpp
  type foxglove_ws (line 8) | namespace foxglove_ws {
    type WebSocketTls (line 10) | struct WebSocketTls : public websocketpp::config::core {
      type transport_config (line 28) | struct transport_config : public base::transport_config {
      type permessage_deflate_config (line 39) | struct permessage_deflate_config {}

FILE: foxglove_bridge_base/src/base64.cpp
  type foxglove_ws (line 5) | namespace foxglove_ws {
    function base64Encode (line 10) | std::string base64Encode(const std::string_view& input) {
    function base64Decode (line 47) | std::vector<unsigned char> base64Decode(const std::string& input) {

FILE: foxglove_bridge_base/src/foxglove_bridge.cpp
  type foxglove (line 5) | namespace foxglove {

FILE: foxglove_bridge_base/src/parameter.cpp
  type foxglove_ws (line 3) | namespace foxglove_ws {

FILE: foxglove_bridge_base/src/serialization.cpp
  type foxglove_ws (line 4) | namespace foxglove_ws {
    function to_json (line 6) | void to_json(nlohmann::json& j, const Channel& c) {
    function from_json (line 19) | void from_json(const nlohmann::json& j, Channel& c) {
    function to_json (line 31) | void to_json(nlohmann::json& j, const ParameterValue& p) {
    function from_json (line 55) | void from_json(const nlohmann::json& j, ParameterValue& p) {
    function to_json (line 75) | void to_json(nlohmann::json& j, const Parameter& p) {
    function from_json (line 93) | void from_json(const nlohmann::json& j, Parameter& p) {
    function to_json (line 128) | void to_json(nlohmann::json& j, const Service& service) {
    function from_json (line 138) | void from_json(const nlohmann::json& j, Service& p) {

FILE: foxglove_bridge_base/src/server_factory.cpp
  type foxglove_ws (line 8) | namespace foxglove_ws {

FILE: foxglove_bridge_base/src/test/test_client.cpp
  type foxglove_ws (line 9) | namespace foxglove_ws {
    function waitForChannelMsg (line 11) | std::future<std::vector<uint8_t>> waitForChannelMsg(ClientInterface* c...
    function waitForParameters (line 31) | std::future<std::vector<Parameter>> waitForParameters(std::shared_ptr<...
    function waitForServiceResponse (line 51) | std::future<ServiceResponse> waitForServiceResponse(std::shared_ptr<Cl...
    function waitForService (line 68) | std::future<Service> waitForService(std::shared_ptr<ClientInterface> c...
    function waitForChannel (line 92) | std::future<Channel> waitForChannel(std::shared_ptr<ClientInterface> c...
    function waitForFetchAssetResponse (line 115) | std::future<FetchAssetResponse> waitForFetchAssetResponse(std::shared_...
    class Client<websocketpp::config::asio_client> (line 145) | class Client<websocketpp::config::asio_client>

FILE: foxglove_bridge_base/tests/base64_test.cpp
  function TEST (line 5) | TEST(Base64Test, EncodingTest) {
  function TEST (line 12) | TEST(Base64Test, DecodeTest) {
  function TEST (line 17) | TEST(Base64Test, DecodeInvalidStringTest) {
  function main (line 24) | int main(int argc, char** argv) {

FILE: foxglove_bridge_base/tests/serialization_test.cpp
  function TEST (line 5) | TEST(SerializationTest, ServiceRequestSerialization) {
  function main (line 24) | int main(int argc, char** argv) {

FILE: foxglove_bridge_base/tests/version_test.cpp
  function TEST (line 7) | TEST(VersionTest, TestWebSocketVersion) {
  function main (line 13) | int main(int argc, char** argv) {

FILE: ros1_foxglove_bridge/include/foxglove_bridge/generic_service.hpp
  type foxglove_bridge (line 9) | namespace foxglove_bridge {
    type GenericService (line 11) | struct GenericService {
      method write (line 17) | inline void write(Stream& stream) const {
      method read (line 22) | inline void read(Stream& stream) {
  type ros::service_traits (line 30) | namespace ros::service_traits {
    type MD5Sum<foxglove_bridge::GenericService> (line 32) | struct MD5Sum<foxglove_bridge::GenericService> {
    type DataType<foxglove_bridge::GenericService> (line 43) | struct DataType<foxglove_bridge::GenericService> {
  type ros::serialization (line 54) | namespace ros::serialization {
    type Serializer<foxglove_bridge::GenericService> (line 57) | struct Serializer<foxglove_bridge::GenericService> {
      method write (line 59) | inline static void write(Stream& stream, const foxglove_bridge::Gene...
      method read (line 64) | inline static void read(Stream& stream, foxglove_bridge::GenericServ...
      method serializedLength (line 68) | inline static uint32_t serializedLength(const foxglove_bridge::Gener...

FILE: ros1_foxglove_bridge/include/foxglove_bridge/param_utils.hpp
  type foxglove_bridge (line 11) | namespace foxglove_bridge {

FILE: ros1_foxglove_bridge/include/foxglove_bridge/service_utils.hpp
  type foxglove_bridge (line 6) | namespace foxglove_bridge {

FILE: ros1_foxglove_bridge/src/param_utils.cpp
  type foxglove_bridge (line 7) | namespace foxglove_bridge {
    function fromRosParam (line 9) | foxglove_ws::ParameterValue fromRosParam(const XmlRpc::XmlRpcValue& va...
    function fromRosParam (line 39) | foxglove_ws::Parameter fromRosParam(const std::string& name, const Xml...
    function toRosParam (line 43) | XmlRpc::XmlRpcValue toRosParam(const foxglove_ws::ParameterValue& para...
    function parseRegexPatterns (line 75) | std::vector<std::regex> parseRegexPatterns(const std::vector<std::stri...

FILE: ros1_foxglove_bridge/src/ros1_foxglove_bridge_node.cpp
  function main (line 4) | int main(int argc, char** argv) {

FILE: ros1_foxglove_bridge/src/ros1_foxglove_bridge_nodelet.cpp
  function rpcValueToStringSet (line 31) | inline std::unordered_set<std::string> rpcValueToStringSet(const XmlRpc:...
  type foxglove_bridge (line 41) | namespace foxglove_bridge {
    class FoxgloveBridge (line 60) | class FoxgloveBridge : public nodelet::Nodelet {
      method FoxgloveBridge (line 62) | FoxgloveBridge() = default;
      method onInit (line 63) | virtual void onInit() {
      type PairHash (line 210) | struct PairHash {
      method subscribe (line 217) | void subscribe(foxglove_ws::ChannelId channelId, ConnectionHandle cl...
      method unsubscribe (line 267) | void unsubscribe(foxglove_ws::ChannelId channelId, ConnectionHandle ...
      method clientAdvertise (line 305) | void clientAdvertise(const foxglove_ws::ClientAdvertisement& channel,
      method clientUnadvertise (line 360) | void clientUnadvertise(foxglove_ws::ClientChannelId channelId, Conne...
      method clientMessage (line 393) | void clientMessage(const foxglove_ws::ClientMessage& clientMsg, Conn...
      method updateAdvertisedTopicsAndServices (line 427) | void updateAdvertisedTopicsAndServices(const ros::TimerEvent&) {
      method updateAdvertisedTopics (line 491) | void updateAdvertisedTopics() {
      method updateAdvertisedServices (line 589) | void updateAdvertisedServices(const std::vector<std::string>& servic...
      method getParameters (line 652) | void getParameters(const std::vector<std::string>& parameters,
      method setParameters (line 723) | void setParameters(const std::vector<foxglove_ws::Parameter>& parame...
      method subscribeParameters (line 771) | void subscribeParameters(const std::vector<std::string>& parameters,
      method parameterUpdates (line 801) | void parameterUpdates(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcVal...
      method logHandler (line 825) | void logHandler(foxglove_ws::WebSocketLogLevel level, char const* ms...
      method rosMessageHandler (line 845) | void rosMessageHandler(
      method serviceRequest (line 853) | void serviceRequest(const foxglove_ws::ServiceRequest& request, Conn...
      method fetchAsset (line 898) | void fetchAsset(const std::string& uri, uint32_t requestId, Connecti...
      method hasCapability (line 929) | bool hasCapability(const std::string& capability) {

FILE: ros1_foxglove_bridge/src/service_utils.cpp
  type foxglove_bridge (line 13) | namespace foxglove_bridge {
    function retrieveServiceType (line 24) | std::string retrieveServiceType(const std::string& serviceName, std::c...

FILE: ros1_foxglove_bridge/tests/smoke_test.cpp
  class ParameterTest (line 22) | class ParameterTest : public ::testing::Test {
    method SetUp (line 33) | void SetUp() override {
  class ServiceTest (line 46) | class ServiceTest : public ::testing::Test {
    method SetUp (line 51) | void SetUp() override {
  function TEST (line 66) | TEST(SmokeTest, testConnection) {
  function TEST (line 71) | TEST(SmokeTest, testSubscription) {
  function TEST (line 102) | TEST(SmokeTest, testSubscriptionParallel) {
  function TEST (line 142) | TEST(SmokeTest, testPublishing) {
  function TEST_F (line 173) | TEST_F(ParameterTest, testGetAllParams) {
  function TEST_F (line 183) | TEST_F(ParameterTest, testGetNonExistingParameters) {
  function TEST_F (line 194) | TEST_F(ParameterTest, testGetParameters) {
  function TEST_F (line 220) | TEST_F(ParameterTest, testSetParameters) {
  function TEST_F (line 256) | TEST_F(ParameterTest, testSetParametersWithReqId) {
  function TEST_F (line 271) | TEST_F(ParameterTest, testUnsetParameter) {
  function TEST_F (line 285) | TEST_F(ParameterTest, testParameterSubscription) {
  function TEST_F (line 303) | TEST_F(ParameterTest, testGetParametersParallel) {
  function TEST_F (line 336) | TEST_F(ServiceTest, testCallServiceParallel) {
  function TEST (line 376) | TEST(FetchAssetTest, fetchExistingAsset) {
  function TEST (line 405) | TEST(FetchAssetTest, fetchNonExistingAsset) {
  function main (line 423) | int main(int argc, char** argv) {

FILE: scripts/format.py
  function main (line 12) | def main(dirs: List[str], fix: bool):