timing compilation

Author: inetic

bindings/cpp/CMakeLists.txt

@@ -6,6 +6,10 @@ include(FetchContent)
 # Boost
 ############################
 
+#set_property(GLOBAL PROPERTY RULE_MESSAGES OFF)
+set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_CURRENT_SOURCE_DIR}/custom_output.sh")
+set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK "${CMAKE_CURRENT_SOURCE_DIR}/custom_output.sh")
+
 # TODO: Get rid of this
 # https://stackoverflow.com/a/71864590/273348
 set(Boost_NO_WARN_NEW_VERSIONS ON)

bindings/cpp/custom_output.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# shell script invoked with the following arguments
+# $(CXX) $(CXX_DEFINES) $(CXX_FLAGS) -o OBJECT_FILE -c SOURCE_FILE
+
+# extract parameters
+SOURCE_FILE="${@: -1:1}"
+OBJECT_FILE="${@: -3:1}"
+
+# invoke compiler
+TIME_BEFORE=`date +%s%N | cut -b1-13`
+"$@"
+TIME_AFTER=`date +%s%N | cut -b1-13`
+TIME=$(($TIME_AFTER-$TIME_BEFORE))
+
+echo " *** Built object `basename \"$OBJECT_FILE\"` from $SOURCE_FILE in $TIME ms."
+

bindings/cpp/ouisync/data.g.hpp

@@ -485,6 +485,334 @@ enum ErrorCode : uint16_t {
     OTHER = 65535,
 };
 
+namespace exception {
+    class Base {
+    public:
+        ErrorCode code;
+        std::string message;
+        std::list<std::string> sources;
+
+    private:
+        const char* _class_name;
+
+    public:
+        Base(ErrorCode code, const char* class_name, std::string message, std::list<std::string> sources) noexcept:
+            code(code),
+            _class_name(class_name),
+            message(std::move(message)),
+            sources(std::move(sources))
+        {}
+
+        std::string to_string() noexcept {
+            std::stringstream ss;
+            ss << _class_name;
+            // TODO: message and sources
+            return ss.str();
+        }
+    };
+
+    /**
+     * Insuficient permission to perform the intended operation
+     */
+    struct PermissionDenied : public Base {
+        PermissionDenied(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::PERMISSION_DENIED, "PermissionDenied", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Invalid input parameter
+     */
+    struct InvalidInput : public Base {
+        InvalidInput(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::INVALID_INPUT, "InvalidInput", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Invalid data (e.g., malformed incoming message, config file, etc...)
+     */
+    struct InvalidData : public Base {
+        InvalidData(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::INVALID_DATA, "InvalidData", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Entry already exists
+     */
+    struct AlreadyExists : public Base {
+        AlreadyExists(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::ALREADY_EXISTS, "AlreadyExists", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Entry not found
+     */
+    struct NotFound : public Base {
+        NotFound(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::NOT_FOUND, "NotFound", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Multiple matching entries found
+     */
+    struct Ambiguous : public Base {
+        Ambiguous(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::AMBIGUOUS, "Ambiguous", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * The indended operation is not supported
+     */
+    struct Unsupported : public Base {
+        Unsupported(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::UNSUPPORTED, "Unsupported", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * The operation was interrupted
+     */
+    struct Interrupted : public Base {
+        Interrupted(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::INTERRUPTED, "Interrupted", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Failed to establish connection to the server
+     */
+    struct ConnectionRefused : public Base {
+        ConnectionRefused(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::CONNECTION_REFUSED, "ConnectionRefused", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Connection aborted by the server
+     */
+    struct ConnectionAborted : public Base {
+        ConnectionAborted(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::CONNECTION_ABORTED, "ConnectionAborted", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Failed to send or receive message
+     */
+    struct TransportError : public Base {
+        TransportError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::TRANSPORT_ERROR, "TransportError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Listener failed to bind to the specified address
+     */
+    struct ListenerBindError : public Base {
+        ListenerBindError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::LISTENER_BIND_ERROR, "ListenerBindError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Listener failed to accept client connection
+     */
+    struct ListenerAcceptError : public Base {
+        ListenerAcceptError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::LISTENER_ACCEPT_ERROR, "ListenerAcceptError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Operation on the internal repository store failed
+     */
+    struct StoreError : public Base {
+        StoreError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::STORE_ERROR, "StoreError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Entry was expected to not be a directory but it is
+     */
+    struct IsDirectory : public Base {
+        IsDirectory(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::IS_DIRECTORY, "IsDirectory", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Entry was expected to be a directory but it isn't
+     */
+    struct NotDirectory : public Base {
+        NotDirectory(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::NOT_DIRECTORY, "NotDirectory", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Directory was expected to be empty but it isn't
+     */
+    struct DirectoryNotEmpty : public Base {
+        DirectoryNotEmpty(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::DIRECTORY_NOT_EMPTY, "DirectoryNotEmpty", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * File or directory is busy
+     */
+    struct ResourceBusy : public Base {
+        ResourceBusy(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::RESOURCE_BUSY, "ResourceBusy", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Failed to initialize runtime
+     */
+    struct RuntimeInitializeError : public Base {
+        RuntimeInitializeError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::RUNTIME_INITIALIZE_ERROR, "RuntimeInitializeError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Failed to read from or write into the config file
+     */
+    struct ConfigError : public Base {
+        ConfigError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::CONFIG_ERROR, "ConfigError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * TLS certificated not found
+     */
+    struct TlsCertificatesNotFound : public Base {
+        TlsCertificatesNotFound(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::TLS_CERTIFICATES_NOT_FOUND, "TlsCertificatesNotFound", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * TLS certificates failed to load
+     */
+    struct TlsCertificatesInvalid : public Base {
+        TlsCertificatesInvalid(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::TLS_CERTIFICATES_INVALID, "TlsCertificatesInvalid", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * TLS keys not found
+     */
+    struct TlsKeysNotFound : public Base {
+        TlsKeysNotFound(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::TLS_KEYS_NOT_FOUND, "TlsKeysNotFound", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Failed to create TLS config
+     */
+    struct TlsConfigError : public Base {
+        TlsConfigError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::TLS_CONFIG_ERROR, "TlsConfigError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Failed to install virtual filesystem driver
+     */
+    struct VfsDriverInstallError : public Base {
+        VfsDriverInstallError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::VFS_DRIVER_INSTALL_ERROR, "VfsDriverInstallError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Unspecified virtual filesystem error
+     */
+    struct VfsOtherError : public Base {
+        VfsOtherError(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::VFS_OTHER_ERROR, "VfsOtherError", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Another instance of the service is already running
+     */
+    struct ServiceAlreadyRunning : public Base {
+        ServiceAlreadyRunning(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::SERVICE_ALREADY_RUNNING, "ServiceAlreadyRunning", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Store directory is not specified
+     */
+    struct StoreDirUnspecified : public Base {
+        StoreDirUnspecified(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::STORE_DIR_UNSPECIFIED, "StoreDirUnspecified", std::move(message), std::move(sources)) {}
+    };
+
+    /**
+     * Mount directory is not specified
+     */
+    struct MountDirUnspecified : public Base {
+        MountDirUnspecified(std::string message = {}, std::list<std::string> sources = {}):
+            Base(ErrorCode::MOUNT_DIR_UNSPECIFIED, "MountDirUnspecified", std::move(message), std::move(sources)) {}
+    };
+
+    static std::unique_ptr<Base> dispatch(
+        ErrorCode code,
+        std::string message = {},
+        std::list<std::string> sources = {}
+    ) {
+        switch (code) {
+            case ErrorCode::PERMISSION_DENIED:
+                return std::make_unique<PermissionDenied>(std::move(message), std::move(sources));
+            case ErrorCode::INVALID_INPUT:
+                return std::make_unique<InvalidInput>(std::move(message), std::move(sources));
+            case ErrorCode::INVALID_DATA:
+                return std::make_unique<InvalidData>(std::move(message), std::move(sources));
+            case ErrorCode::ALREADY_EXISTS:
+                return std::make_unique<AlreadyExists>(std::move(message), std::move(sources));
+            case ErrorCode::NOT_FOUND:
+                return std::make_unique<NotFound>(std::move(message), std::move(sources));
+            case ErrorCode::AMBIGUOUS:
+                return std::make_unique<Ambiguous>(std::move(message), std::move(sources));
+            case ErrorCode::UNSUPPORTED:
+                return std::make_unique<Unsupported>(std::move(message), std::move(sources));
+            case ErrorCode::INTERRUPTED:
+                return std::make_unique<Interrupted>(std::move(message), std::move(sources));
+            case ErrorCode::CONNECTION_REFUSED:
+                return std::make_unique<ConnectionRefused>(std::move(message), std::move(sources));
+            case ErrorCode::CONNECTION_ABORTED:
+                return std::make_unique<ConnectionAborted>(std::move(message), std::move(sources));
+            case ErrorCode::TRANSPORT_ERROR:
+                return std::make_unique<TransportError>(std::move(message), std::move(sources));
+            case ErrorCode::LISTENER_BIND_ERROR:
+                return std::make_unique<ListenerBindError>(std::move(message), std::move(sources));
+            case ErrorCode::LISTENER_ACCEPT_ERROR:
+                return std::make_unique<ListenerAcceptError>(std::move(message), std::move(sources));
+            case ErrorCode::STORE_ERROR:
+                return std::make_unique<StoreError>(std::move(message), std::move(sources));
+            case ErrorCode::IS_DIRECTORY:
+                return std::make_unique<IsDirectory>(std::move(message), std::move(sources));
+            case ErrorCode::NOT_DIRECTORY:
+                return std::make_unique<NotDirectory>(std::move(message), std::move(sources));
+            case ErrorCode::DIRECTORY_NOT_EMPTY:
+                return std::make_unique<DirectoryNotEmpty>(std::move(message), std::move(sources));
+            case ErrorCode::RESOURCE_BUSY:
+                return std::make_unique<ResourceBusy>(std::move(message), std::move(sources));
+            case ErrorCode::RUNTIME_INITIALIZE_ERROR:
+                return std::make_unique<RuntimeInitializeError>(std::move(message), std::move(sources));
+            case ErrorCode::CONFIG_ERROR:
+                return std::make_unique<ConfigError>(std::move(message), std::move(sources));
+            case ErrorCode::TLS_CERTIFICATES_NOT_FOUND:
+                return std::make_unique<TlsCertificatesNotFound>(std::move(message), std::move(sources));
+            case ErrorCode::TLS_CERTIFICATES_INVALID:
+                return std::make_unique<TlsCertificatesInvalid>(std::move(message), std::move(sources));
+            case ErrorCode::TLS_KEYS_NOT_FOUND:
+                return std::make_unique<TlsKeysNotFound>(std::move(message), std::move(sources));
+            case ErrorCode::TLS_CONFIG_ERROR:
+                return std::make_unique<TlsConfigError>(std::move(message), std::move(sources));
+            case ErrorCode::VFS_DRIVER_INSTALL_ERROR:
+                return std::make_unique<VfsDriverInstallError>(std::move(message), std::move(sources));
+            case ErrorCode::VFS_OTHER_ERROR:
+                return std::make_unique<VfsOtherError>(std::move(message), std::move(sources));
+            case ErrorCode::SERVICE_ALREADY_RUNNING:
+                return std::make_unique<ServiceAlreadyRunning>(std::move(message), std::move(sources));
+            case ErrorCode::STORE_DIR_UNSPECIFIED:
+                return std::make_unique<StoreDirUnspecified>(std::move(message), std::move(sources));
+            case ErrorCode::MOUNT_DIR_UNSPECIFIED:
+                return std::make_unique<MountDirUnspecified>(std::move(message), std::move(sources));
+            default:
+                return std::make_unique<Base>(code, "Unknown", std::move(message), std::move(sources));
+        }
+    }
+} // namespace exception
+
 
 enum LogLevel : uint8_t {
     ERROR = 1,