hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

hikyuu/include/hikyuu/utilities/db_connect/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/utilities/db_connect/mysql/MySQLConnect.h

@@ -0,0 +1,60 @@
+/*
+ * MySQLConnect.h
+ *
+ *  Copyright (c) 2019, hikyuu.org
+ *
+ *  Created on: 2019-8-17
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIYUU_DB_CONNECT_MYSQL_MYSQLCONNECT_H
+#define HIYUU_DB_CONNECT_MYSQL_MYSQLCONNECT_H
+
+#include "../DBConnectBase.h"
+#include "MySQLStatement.h"
+
+#if defined(_MSC_VER)
+#include <mysql.h>
+#else
+#include <mysql/mysql.h>
+#endif
+
+namespace hku {
+
+class HKU_UTILS_API MySQLConnect : public DBConnectBase {
+public:
+    explicit MySQLConnect(const Parameter &param);
+    virtual ~MySQLConnect();
+
+    MySQLConnect(const MySQLConnect &) = delete;
+    MySQLConnect &operator=(const MySQLConnect &) = delete;
+
+    virtual bool ping() override;
+
+    virtual int64_t exec(const std::string &sql_string) override;
+    virtual SQLStatementPtr getStatement(const std::string &sql_statement) override;
+    virtual bool tableExist(const std::string &tablename) override;
+    virtual void resetAutoIncrement(const std::string &tablename) override;
+
+    virtual void transaction() override;
+    virtual void commit() override;
+    virtual void rollback() noexcept override;
+
+public:
+    MYSQL *getRawMYSQL() const noexcept {
+        return m_mysql;
+    }
+
+private:
+    bool tryConnect() noexcept;
+    void connect();
+    void close();
+
+private:
+    MYSQL *m_mysql;
+};
+
+}  // namespace hku
+
+#endif /* HIYUU_DB_CONNECT_MYSQL_MYSQLCONNECT_H */

hikyuu/include/hikyuu/utilities/db_connect/mysql/MySQLStatement.h

@@ -0,0 +1,88 @@
+/*
+ * MySQLStatement.h
+ *
+ *  Copyright (c) 2019, hikyuu.org
+ *
+ *  Created on: 2019-8-17
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIYUU_DB_CONNECT_MYSQL_MYSQLSTATEMENT_H
+#define HIYUU_DB_CONNECT_MYSQL_MYSQLSTATEMENT_H
+
+#include <string>
+#include <vector>
+#include <boost/any.hpp>
+#include "../SQLStatementBase.h"
+
+#if defined(_MSC_VER)
+#include <mysql.h>
+#else
+#include <mysql/mysql.h>
+#endif
+
+#if MYSQL_VERSION_ID >= 80000
+typedef bool my_bool;
+#endif
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
+namespace hku {
+
+class HKU_UTILS_API MySQLStatement : public SQLStatementBase {
+public:
+    MySQLStatement() = delete;
+    MySQLStatement(DBConnectBase *driver, const std::string &sql_statement);
+    virtual ~MySQLStatement();
+
+    virtual void sub_exec() override;
+    virtual bool sub_moveNext() override;
+    virtual uint64_t sub_getLastRowid() override;
+
+    virtual void sub_bindNull(int idx) override;
+    virtual void sub_bindInt(int idx, int64_t value) override;
+    virtual void sub_bindDouble(int idx, double item) override;
+    virtual void sub_bindDatetime(int idx, const Datetime &item) override;
+    virtual void sub_bindText(int idx, const std::string &item) override;
+    virtual void sub_bindText(int idx, const char *item, size_t len) override;
+    virtual void sub_bindBlob(int idx, const std::string &item) override;
+    virtual void sub_bindBlob(int idx, const std::vector<char> &item) override;
+
+    virtual int sub_getNumColumns() const override;
+    virtual void sub_getColumnAsInt64(int idx, int64_t &item) override;
+    virtual void sub_getColumnAsDouble(int idx, double &item) override;
+    virtual void sub_getColumnAsDatetime(int idx, Datetime &item) override;
+    virtual void sub_getColumnAsText(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::vector<char> &item) override;
+
+private:
+    void _prepare(DBConnectBase *driver);
+    void _reset();
+    void _bindResult();
+
+private:
+    MYSQL *m_db;
+    MYSQL_STMT *m_stmt;
+    MYSQL_RES *m_meta_result;
+    bool m_needs_reset;
+    bool m_has_bind_result;
+    std::vector<MYSQL_BIND> m_param_bind;
+    std::vector<MYSQL_BIND> m_result_bind;
+    std::vector<boost::any> m_param_buffer;
+    std::vector<boost::any> m_result_buffer;
+    std::vector<unsigned long> m_result_length;
+    std::vector<char> m_result_is_null;
+    std::vector<char> m_result_error;
+};
+
+inline uint64_t MySQLStatement::sub_getLastRowid() {
+    return mysql_stmt_insert_id(m_stmt);
+}
+
+}  // namespace hku
+
+#endif /* HIYUU_DB_CONNECT_MYSQL_MYSQLSTATEMENT_H */

hikyuu/include/hikyuu/utilities/db_connect/mysql/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteConnect.h

@@ -0,0 +1,89 @@
+/*
+ * SQLiteConnect.h
+ *
+ *  Copyright (c) 2019, hikyuu.org
+ *
+ *  Created on: 2019-7-1
+ *      Author: fasiondog
+ */
+#pragma once
+#ifndef HIYUU_DB_CONNECT_SQLITE_SQLITECONNECT_H
+#define HIYUU_DB_CONNECT_SQLITE_SQLITECONNECT_H
+
+#include <sqlite3.h>
+#include "../DBConnectBase.h"
+#include "SQLiteStatement.h"
+
+namespace hku {
+
+/**
+ * @defgroup SQLite SQLite3 driver SQLITE3 数据驱动
+ * @ingroup DBConnect
+ */
+
+/**
+ * SQLite连接
+ * @ingroup SQLite
+ */
+class HKU_UTILS_API SQLiteConnect : public DBConnectBase {
+public:
+    /**
+     * 构造函数
+     * @param param 数据库连接参数,支持如下参数：
+     * <pre>
+     * string db - 数据库文件名
+     * int flags - SQLite连接方式：SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX
+     *            （具体可参考 SQLite 帮助）
+     * string key - sqlcipher 加密口令 (仅在使用 sqlcipher 引擎时生效)
+     * </pre>
+     */
+    explicit SQLiteConnect(const Parameter &param);
+
+    /** 析构函数 */
+    virtual ~SQLiteConnect();
+
+    /** 如果 sqlite 文件无效，返回false */
+    virtual bool ping() override;
+
+    virtual void transaction() override;
+    virtual void commit() override;
+    virtual void rollback() noexcept override;
+    virtual int64_t exec(const std::string &sql_string) override;
+    virtual SQLStatementPtr getStatement(const std::string &sql_statement) override;
+    virtual bool tableExist(const std::string &tablename) override;
+    virtual void resetAutoIncrement(const std::string &tablename) override;
+
+    /**
+     * @brief 对数据库进行检查
+     * @note 该函数不能区分是因为文件并非sqlite文件，还是sqlite本身损坏的情况
+     *       如有判断文件本身是否为有效sqlite文件，请使用 isValidSqliteFile 方法
+     * @param quick true 快速检查 | false 完整性检查
+     * @return true 检测成功
+     * @return false 检测失败
+     */
+    bool check(bool quick = false) noexcept;
+
+    /**
+     * @brief 在线备份数据库，不影响其他数据库连接进行操作
+     * @param zFilename 备份数据库名称
+     * @param n_page 分批备份时每次循环备份的 page 数，小于等于0时，一次性备份，不进行分批备份
+     * @param step_sleep 分批备份时每次循环后，休眠间隔时长（毫秒），以便让出cpu
+     * @return true 成功
+     * @return false 失败
+     */
+    bool backup(const char *zFilename, int n_page = -1, int step_sleep = 250) noexcept;
+
+private:
+    void close();
+
+private:
+    friend class SQLiteStatement;
+    std::string m_dbname;
+    sqlite3 *m_db;
+};
+
+typedef std::shared_ptr<SQLiteConnect> SQLiteConnectPtr;
+
+}  // namespace hku
+
+#endif /* HIYUU_DB_MANAGER_SQLITE_SQLITECONNECT_H */

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteStatement.h

@@ -0,0 +1,71 @@
+/*
+ * SQLiteStatement.h
+ *
+ *  Copyright (c) 2019, hikyuu.org
+ *
+ *  Created on: 2019-7-11
+ *      Author: fasiondog
+ */
+#pragma once
+#ifndef HIKYUU_DB_CONNECT_SQLITE_SQLITESTATEMENT_H
+#define HIKYUU_DB_CONNECT_SQLITE_SQLITESTATEMENT_H
+
+#include <sqlite3.h>
+#include "../SQLStatementBase.h"
+
+namespace hku {
+
+/**
+ * SQLite Statemen
+ * @ingroup DBConnect
+ */
+class HKU_UTILS_API SQLiteStatement : public SQLStatementBase {
+public:
+    SQLiteStatement() = delete;
+
+    /**
+     * 构造函数
+     * @param driver 数据库连接
+     * @param sql_statement SQL语句
+     */
+    SQLiteStatement(DBConnectBase *driver, const std::string &sql_statement);
+
+    /** 析构函数 */
+    virtual ~SQLiteStatement();
+
+    virtual void sub_exec() override;
+    virtual bool sub_moveNext() override;
+    virtual uint64_t sub_getLastRowid() override;
+
+    virtual void sub_bindNull(int idx) override;
+    virtual void sub_bindInt(int idx, int64_t value) override;
+    virtual void sub_bindDouble(int idx, double item) override;
+    virtual void sub_bindDatetime(int idx, const Datetime &item) override;
+    virtual void sub_bindText(int idx, const std::string &item) override;
+    virtual void sub_bindText(int idx, const char *item, size_t len) override;
+    virtual void sub_bindBlob(int idx, const std::string &item) override;
+    virtual void sub_bindBlob(int idx, const std::vector<char> &item) override;
+
+    virtual int sub_getNumColumns() const override;
+    virtual void sub_getColumnAsInt64(int idx, int64_t &item) override;
+    virtual void sub_getColumnAsDouble(int idx, double &item) override;
+    virtual void sub_getColumnAsDatetime(int idx, Datetime &item) override;
+    virtual void sub_getColumnAsText(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::vector<char> &item) override;
+
+private:
+    void _reset();
+
+private:
+    bool m_needs_reset;  // true if sqlite3_step() has been called more recently than
+                         // sqlite3_reset()
+    int m_step_status;
+    bool m_at_first_step;
+    sqlite3 *m_db;
+    sqlite3_stmt *m_stmt;
+};
+
+}  // namespace hku
+
+#endif /* HIKYUU_DB_CONNECT_SQLITE_SQLITESTATEMENT_H */

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteUtil.h

@@ -0,0 +1,80 @@
+/*
+ *  Copyright (c) 2019~2023 hikyuu.org
+ *
+ *  Created on: 2023/01/04
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "SQLiteConnect.h"
+
+namespace hku {
+
+/**
+ * @brief SQLite 其他相关操作方法集合
+ * @ingroup DBConnect
+ */
+class HKU_UTILS_API SQLiteUtil {
+public:
+    SQLiteUtil() = default;
+    ~SQLiteUtil() = default;
+
+    enum BackupResult {
+        BACKUP_SUCCESS = 0,             ///< 备份成功
+        BACKUP_FAILED_INVALID_SRC = 1,  ///< 指定的待备份源数据无效
+        BACKUP_FAILED_EXECUTE = 2,      ///< 执行备份出错
+        BACKUP_FAILED_OTHER = 3,        ///< 其他原因导致备份失败原因
+    };
+
+    enum RecoverResult {
+        RECOVER_SUCCESS = 0,              ///< 恢复成功
+        RECOVER_FAILED_BACKUP_NOT_EXIST,  ///< 指定的备份文件不存在
+        RECOVER_FAILED_BACKUP_INVALID,    ///< 指定的备份文件不是有效的数据库文件
+        RECOVER_FAILED_INVALID_DST,  ///< 无效的指定的恢复目标文件名或文件被占用无法删除
+        RECOVER_FAILED_EXECUTE,  ///< 执行恢复失败
+        RECOVER_FAILED_OTHER,    ///< 其他原因导致的恢复失败
+    };
+
+    /**
+     * @brief 在线备份数据库，不影响其他数据库连接进行操作
+     * @param conn 待备份数据库连接
+     * @param dst 备份数据库名称
+     * @param n_page 分批备份时每次循环备份的 page 数，小于等于0时，一次性备份，不进行分批备份
+     * @param step_sleep 分批备份时每次循环后，休眠间隔时长（毫秒），以便让出cpu
+     */
+    static BackupResult onlineBackup(const std::shared_ptr<SQLiteConnect> &conn,
+                                     const std::string &dst, int n_page = -1,
+                                     int step_sleep = 250) noexcept;
+    /**
+     * @brief 在线备份数据库，不影响其他数据库连接进行操作
+     * @param src 待备份数据库名称
+     * @param dst 备份数据库名称
+     * @param n_page 分批备份时每次循环备份的 page 数，小于等于0时，一次性备份，不进行分批备份
+     * @param step_sleep 分批备份时每次循环后，休眠间隔时长（毫秒），以便让出cpu
+     */
+    static BackupResult onlineBackup(const std::string &src, const std::string &dst,
+                                     int n_page = -1, int step_sleep = 250) noexcept;
+
+    /**
+     * @brief 从指定的备份文件恢复数据库
+     * @note
+     * 待恢复的数据库文件在恢复过程中，可能先进行删除，如需保存损坏的数据库，请指定 save_bad 参数
+     * @param backup 指定的备份文件
+     * @param dst 待恢复的数据
+     * @param save_bad 是否保存损坏的数据，将 dst 及 dst-journal 加上后缀 .bad 另存
+     * @return RecoverResult
+     */
+    static RecoverResult recoverFromBackup(const std::string &backup, const std::string &dst,
+                                           bool save_bad = false) noexcept;
+
+    /**
+     * @brief 尝试删除数据库相关文件（主文件及日志文件）
+     * @param dbfilename 数据库文件名
+     * @return true 指定的数据库文件及其日志文件都被成功删除或都不存在时，返回成功
+     * @return false 指定的数据文件及其日志文件，其中一个删除失败都会返回删除失败
+     */
+    static bool removeDBFile(const std::string &dbfilename);
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/db_connect/sqlite/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/utilities/exception.h

@@ -0,0 +1,52 @@
+/*
+ * exception.h
+ *
+ *  Copyright (c) 2019, hikyuu.org
+ *
+ *  Created on: 2019-6-23
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_UTILITIES_EXCEPTION_H
+#define HIKYUU_UTILITIES_EXCEPTION_H
+
+#include <string>
+#include <exception>
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
+namespace hku {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4275)
+#endif
+
+/**
+ * @ingroup Utilities
+ * @addtogroup Exception Exception 异常处理
+ * @{
+ */
+
+class HKU_UTILS_API exception : public std::exception {
+public:
+    exception() : m_msg("Unknown exception!") {}
+    exception(const char *msg) : m_msg(msg) {}         // cppcheck-suppress noExplicitConstructor
+    exception(const std::string &msg) : m_msg(msg) {}  // cppcheck-suppress noExplicitConstructor
+    virtual ~exception() noexcept {}
+    virtual const char *what() const noexcept;
+
+protected:
+    std::string m_msg;
+};
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+} /* namespace hku */
+
+#endif /* HIKYUU_UTILITIES_EXCEPTION_H */

hikyuu/include/hikyuu/utilities/http_client/HttpClient.h

@@ -0,0 +1,229 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-07-26
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_HTTP_CLIENT_H
+#define HKU_UTILS_HTTP_CLIENT_H
+
+#include "hikyuu/utilities/config.h"
+#if !HKU_ENABLE_HTTP_CLIENT
+#error "Don't enable http client, please config with --http_client=y"
+#endif
+
+#include <string>
+#include <nlohmann/json.hpp>
+#include "nng_wrap.h"
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
+namespace hku {
+
+using json = nlohmann::json;
+
+class HKU_UTILS_API HttpClient;
+
+class HKU_UTILS_API HttpResponse final {
+    friend class HKU_UTILS_API HttpClient;
+
+public:
+    HttpResponse();
+    ~HttpResponse();
+
+    HttpResponse(const HttpResponse&) = delete;
+    HttpResponse& operator=(const HttpResponse&) = delete;
+
+    HttpResponse(HttpResponse&& rhs);
+    HttpResponse& operator=(HttpResponse&& rhs);
+
+    const std::string& body() const noexcept {
+        return m_body;
+    }
+
+    hku::json json() const {
+        return json::parse(m_body);
+    }
+
+    int status() const noexcept {
+        return nng_http_res_get_status(m_res);
+    }
+
+    std::string reason() noexcept {
+        return nng_http_res_get_reason(m_res);
+    }
+
+    std::string getHeader(const std::string& key) noexcept {
+        const char* hdr = nng_http_res_get_header(m_res, key.c_str());
+        return hdr ? std::string(hdr) : std::string();
+    }
+
+    size_t getContentLength() noexcept {
+        std::string slen = getHeader("Content-Length");
+        return slen.empty() ? 0 : std::stoi(slen);
+    }
+
+private:
+    void _resizeBody(size_t len) {
+        m_body.resize(len);
+    }
+
+    nng_http_res* get() const noexcept {
+        return m_res;
+    }
+
+    void reset();
+
+private:
+    nng_http_res* m_res{nullptr};
+    std::string m_body;
+};
+
+class HKU_UTILS_API HttpClient {
+public:
+    HttpClient() = default;
+    explicit HttpClient(const std::string& url, int32_t timeout_ms = NNG_DURATION_DEFAULT)
+    : m_url(nng::url(url)), m_timeout_ms(timeout_ms) {};
+    virtual ~HttpClient();
+
+    HttpClient(const HttpClient&) = delete;
+    HttpClient& operator=(const HttpClient&) = delete;
+
+    HttpClient(HttpClient&& rhs)
+    : m_default_headers(std::move(rhs.m_default_headers)),
+      m_url(std::move(rhs.m_url)),
+      m_client(std::move(rhs.m_client)),
+      m_aio(std::move(rhs.m_aio)),
+      m_conn(std::move(rhs.m_conn)),
+#if HKU_ENABLE_HTTP_CLIENT_SSL
+      m_tls_cfg(std::move(rhs.m_tls_cfg)),
+      m_ca_file(std::move(rhs.m_ca_file)),
+#endif
+      m_timeout_ms(rhs.m_timeout_ms) {
+    }
+
+    HttpClient& operator=(HttpClient&& rhs) {
+        if (this != &rhs) {
+            m_default_headers = std::move(rhs.m_default_headers);
+            m_url = std::move(rhs.m_url);
+            m_client = (std::move(rhs.m_client));
+            m_aio = std::move(rhs.m_aio);
+            m_conn = std::move(rhs.m_conn);
+#if HKU_ENABLE_HTTP_CLIENT_SSL
+            m_tls_cfg = std::move(rhs.m_tls_cfg);
+            m_ca_file = std::move(rhs.m_ca_file);
+#endif
+            m_timeout_ms = rhs.m_timeout_ms;
+            rhs.m_timeout_ms = NNG_DURATION_DEFAULT;
+        }
+        return *this;
+    }
+
+    bool valid() const noexcept {
+        return m_url.valid();
+    }
+
+    const std::string& url() const noexcept {
+        return m_url.raw_url();
+    }
+
+    void setUrl(const std::string& url) noexcept {
+        m_url = nng::url(url);
+        reset();
+    }
+
+    // #define NNG_DURATION_INFINITE (-1)
+    // #define NNG_DURATION_DEFAULT (-2)
+    // #define NNG_DURATION_ZERO (0)
+    void setTimeout(int32_t ms) {
+        if (m_timeout_ms != ms) {
+            m_timeout_ms = ms;
+            reset();
+        }
+    }
+
+    void setDefaultHeaders(const HttpHeaders& headers) {
+        m_default_headers = headers;
+    }
+
+    void setDefaultHeaders(HttpHeaders&& headers) {
+        m_default_headers = std::move(headers);
+    }
+
+    void setCaFile(const std::string& filename);
+
+    void reset();
+
+    HttpResponse request(const std::string& method, const std::string& path,
+                         const HttpParams& params, const HttpHeaders& headers, const char* body,
+                         size_t body_len, const std::string& content_type);
+
+    HttpResponse get(const std::string& path, const HttpHeaders& headers = HttpHeaders()) {
+        return request("GET", path, HttpParams(), headers, nullptr, 0, "");
+    }
+
+    HttpResponse get(const std::string& path, const HttpParams& params,
+                     const HttpHeaders& headers) {
+        return request("GET", path, params, headers, nullptr, 0, "");
+    }
+
+    HttpResponse post(const std::string& path, const HttpParams& params, const HttpHeaders& headers,
+                      const char* body, size_t len, const std::string& content_type) {
+        return request("POST", path, params, headers, body, len, content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpHeaders& headers, const char* body,
+                      size_t len, const std::string& content_type) {
+        return request("POST", path, HttpParams(), headers, body, len, content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpParams& params, const HttpHeaders& headers,
+                      const std::string& content, const std::string& content_type = "text/plaint") {
+        return post(path, params, headers, content.data(), content.size(), content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpHeaders& headers,
+                      const std::string& content, const std::string& content_type = "text/plaint") {
+        return post(path, HttpParams(), headers, content, content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpParams& params, const HttpHeaders& headers,
+                      const json& body) {
+        return post(path, params, headers, body.dump(), "application/json");
+    }
+
+    HttpResponse post(const std::string& path, const HttpHeaders& headers, const json& body) {
+        return post(path, HttpParams(), headers, body);
+    }
+
+    HttpResponse post(const std::string& path, const json& body) {
+        return post(path, HttpHeaders(), body);
+    }
+
+private:
+    void _connect();
+    HttpResponse _readResChunk(const std::string& method, const std::string& uri,
+                               const HttpHeaders& headers, const char* body, size_t body_len,
+                               const std::string& content_type);
+
+private:
+    HttpHeaders m_default_headers;
+    nng::url m_url;
+    nng::http_client m_client;
+    nng::aio m_aio;
+    nng::http_conn m_conn;
+#if HKU_ENABLE_HTTP_CLIENT_SSL
+    nng::tls_config m_tls_cfg;
+    std::string m_ca_file;
+#endif
+
+    int32_t m_timeout_ms{NNG_DURATION_DEFAULT};
+};
+
+}  // namespace hku
+
+#endif

hikyuu/include/hikyuu/utilities/http_client/__init__.py

@@ -0,0 +1 @@
+