plugin_registry.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of nexuslua, see https://github.com/acrion/nexuslua and https://nexuslua.org
 
nexuslua is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
nexuslua is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
nexuslua is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with nexuslua. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include "plugin_install_result.hpp"
 
#include "nexuslua_export.h"
 
#include <cstddef>
#include <memory>
#include <string>
 
namespace nexuslua
{
    class Agent;
    class agents;

    class NEXUSLUA_EXPORT PluginRegistry
    {
        struct Impl;
        std::unique_ptr<Impl> _impl;
 
    public:
        struct NEXUSLUA_EXPORT Iterator
        {
            using iterator_category = std::input_iterator_tag;
            using difference_type   = std::ptrdiff_t;
            using value_type        = std::shared_ptr<Agent>;
            using pointer = struct
            {
                Impl*       impl;
                std::size_t pos;
            };

            explicit Iterator(pointer ptr)
                : m_ptr(ptr) {}

            value_type operator*() const;

            pointer operator->() { return m_ptr; }

            Iterator& operator++()
            {
                m_ptr.pos++;
                return *this;
            }

            const Iterator operator++(int) // NOLINT(readability-const-return-type)
            {
                Iterator tmp = *this;
                ++(*this);
                return tmp;
            }

            friend bool operator==(const Iterator& a, const Iterator& b) { return a.m_ptr.impl == b.m_ptr.impl && a.m_ptr.pos == b.m_ptr.pos; }

            friend bool operator!=(const Iterator& a, const Iterator& b) { return a.m_ptr.impl != b.m_ptr.impl || a.m_ptr.pos != b.m_ptr.pos; }
 
        private:
            pointer m_ptr;
        };
 
        explicit PluginRegistry(const std::shared_ptr<nexuslua::agents>& agents);
        ~PluginRegistry();
 
        PluginInstallResult    Install(std::string name, std::string& strError); 
        std::string            GetErrorMessage();                                
        std::shared_ptr<Agent> Get(const std::string& agentName);                
        std::size_t            Count() const;                                    
        void                   RescanInstalled();                                
 
        Iterator begin(); 
        Iterator end();   
    };
}