Main.h

/*
 * qb - C++ Actor Framework
 * Copyright (C) 2011-2019 isndev (www.qbaf.io). All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 *         limitations under the License.
 */

#ifndef QB_MAIN_H
#define QB_MAIN_H
# include <iostream>
# include <vector>
# include <unordered_map>
// include from qb
# include <qb/system/lockfree/mpsc.h>
# include "Event.h"
# include "CoreSet.h"

namespace qb {

    class VirtualCore;

    class Main {
        friend class VirtualCore;
        constexpr static const uint64_t MaxRingEvents =
                (((std::numeric_limits<uint16_t>::max)()) / QB_LOCKFREE_CACHELINE_BYTES);
        using MPSCBuffer = lockfree::mpsc::ringbuffer<CacheLine, MaxRingEvents, 0>;

        static std::atomic<uint64_t> sync_start;
        static bool                  is_running;
        static void onSignal(int signal);

    private:
        CoreSet _core_set;
        std::vector<MPSCBuffer *> _mail_boxes;
        std::unordered_map<uint8_t, VirtualCore *> _cores;

        void __init__();
        bool send(Event const &event) const;
        MPSCBuffer &getMailBox(uint8_t const id) const;
        std::size_t getNbCore() const;
    public:

        class CoreBuilder {
        public:
            using ActorIdList = std::vector<ActorId>;
        private:
            friend class Main;

            const uint16_t _index;
            Main &_main;
            ActorIdList _ret_ids;
            bool _valid;

            CoreBuilder(Main &main, uint16_t const index)
                    : _index(index)
                    , _main(main)
                    , _valid(true)
            {}

            CoreBuilder() = delete;
        public:
            CoreBuilder(CoreBuilder const &rhs);

            template<typename _Actor, typename ..._Args>
            CoreBuilder &addActor(_Args &&...args);

            bool valid() const;
            operator bool() const;

            ActorIdList const &idList() const;
        };

        Main() = delete;
        explicit Main(CoreSet const &core_set);
        explicit Main(std::unordered_set<uint8_t> const &core_set);
        ~Main();

        void start(bool async = true) const;

        static bool hasError();

        static void stop();

        void join() const;

    public:

        template<typename _Actor, typename ..._Args>
        ActorId addActor(std::size_t index, _Args &&...args);

        CoreBuilder core(uint16_t const index);

    };

} // namespace qb

#endif //QB_MAIN_H