QuasarApp Heart

QuasarApp Heart - it is base backend for C++/Qt projects. This library support work with databases and work with lite network requests.

Futures

This library consists of two levels (AbstractNode level and DataBaseNode level).

• Support ssl sockets
• Support initialize database
• Support work in database

Build and Include

For cmake projects

• cd yourRepo

• git submodule add https://github.com/QuasarApp/Heart.git # add the repository of Heart into your repo like submodule

• git submodule update --init --recursive

• Include in your CMakeLists.txt file the main CMakeLists.txt file of Heart library

  add_subdirectory(Heart)

• link the Heart library to your target

  target_link_libraries(yourLib PUBLIC Heart)

• rebuild yuor project

Usage

Create a own package class and override some basic methods.

class MyPackage: public QH::AbstractData
{
public:
    MyPackage();

    // override this method for validation your package class
    bool isValid() const {
        return AbstractData::isValid();
    };                     

    // your data for for server of client
    std::string _data = "";

protected:
    // StreamBase interface override this methods for serialization your package
    QDataStream &fromStream(QDataStream &stream) {
        stream >> _data;
        return stream;
    }
    QDataStream &toStream(QDataStream &stream) const {
        stream << _data;
        return stream;
    }

};

Create your parser api class.

*
* class MyParser: public QH::iParser {
   public:
       MyParser(QH::AbstractNode* parentNode): QH::iParser(parentNode) {
           registerPackageType<MyPackage>();
           data = new BigPackage();
   }

   // iParser interface
   public:

   // override this method for processed received data.
   ParserResult parsePackage(const Package &pkg,
                             const AbstractNodeInfo *sender) {

       auto parentResult = AbstractNode::parsePackage(pkg, sender);
       if (parentResult != ParserResult::NotProcessed) {
           return parentResult;
       }

       auto result = commandHandler<MyPackage>(this, &MyClass::processMyPackage, pkg, sender, pkgHeader);
       if (result != QH::ParserResult::NotProcessed) {
           return result;
       }

       return ParserResult::NotProcessed;
   }

   bool processMyPackage(const QSharedPointer<MyPackage> &cardrequest,
                         const QH::AbstractNodeInfo *sender, const QH::Header &hdr) {

       BaseId requesterId = getSender(sender, &cardrequest);

       if (!cardrequest.isValid()) {
           badRequest(sender->networkAddress(), hdr);
           return ParserResult::Error;
       }

       cardrequest._data = "responce for client "

       // responce only for servers.
       if (nodeType() == QH::AbstractNode::NodeType::Server)
           sendData(cardrequest, sender->networkAddress(), &pkg.hdr);

       return ParserResult::Processed;
   }

   // This vesion of the parser (any digital value.) .
   int version() const override {return 0;};
   QString parserId() const override {return "MyParser";};

   };

Create a server class and add supported parsers to work with packages.

class TestingServer: public QH::AbstractNode {
Q_OBJECT
public:
    TestingServer() {
        addApiParser<MyParser>();
    }

    QH::AbstractNode::NodeType nodeType() const override {
        return QH::AbstractNode::NodeType::Server;
    }
};

Create a client class and add supported parsers to work with packages.

class TestingClient: public QH::AbstractNode {

public:
    TestingClient() {
        addApiParser<MyParser>();
    }

    QH::AbstractNode::NodeType nodeType() const override {
        return QH::AbstractNode::NodeType::Client;
    }
};

For more information, see our QuasarApp Heart Code Documentation.