uORBManager.hpp

/****************************************************************************
 *
 *   Copyright (c) 2012-2015 PX4 Development Team. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name PX4 nor the names of its contributors may be
 *    used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/

#ifndef _uORBManager_hpp_
#define _uORBManager_hpp_

#include "uORBCommon.hpp"
#include "uORBDeviceMaster.hpp"

#include <stdint.h>

#ifdef __PX4_NUTTX
#include "ORBSet.hpp"
#else
#include <string>
#include <set>
#define ORBSet std::set<std::string>
#endif

#ifdef ORB_COMMUNICATOR
#include "uORBCommunicator.hpp"
#endif /* ORB_COMMUNICATOR */

namespace uORB
{
class Manager;
}

class uORB::Manager
#ifdef ORB_COMMUNICATOR
    : public uORBCommunicator::IChannelRxHandler
#endif /* ORB_COMMUNICATOR */
{
public:
    // public interfaces for this class.

    static bool initialize();

    static uORB::Manager *get_instance() { return _Instance; }

    uORB::DeviceMaster *get_device_master();

    // ==== uORB interface methods ====
    orb_advert_t orb_advertise(const struct orb_metadata *meta, const void *data, unsigned int queue_size = 1)
    {
        return orb_advertise_multi(meta, data, nullptr, ORB_PRIO_DEFAULT, queue_size);
    }

    orb_advert_t orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance,
                     int priority, unsigned int queue_size = 1);

    int orb_unadvertise(orb_advert_t handle);

    int  orb_publish(const struct orb_metadata *meta, orb_advert_t handle, const void *data);

    int  orb_subscribe(const struct orb_metadata *meta);

    int  orb_subscribe_multi(const struct orb_metadata *meta, unsigned instance);

    int  orb_unsubscribe(int handle);

    int  orb_copy(const struct orb_metadata *meta, int handle, void *buffer);

    int  orb_check(int handle, bool *updated);

    int  orb_stat(int handle, uint64_t *time);

    int  orb_exists(const struct orb_metadata *meta, int instance);

    int  orb_priority(int handle, int32_t *priority);

    int  orb_set_interval(int handle, unsigned interval);


    int orb_get_interval(int handle, unsigned *interval);

#ifdef ORB_COMMUNICATOR

    void set_uorb_communicator(uORBCommunicator::IChannel *comm_channel);

    uORBCommunicator::IChannel *get_uorb_communicator();

    bool is_remote_subscriber_present(const char *messageName);
#endif /* ORB_COMMUNICATOR */

private: // class methods
    int node_advertise(const struct orb_metadata *meta, int *instance = nullptr, int priority = ORB_PRIO_DEFAULT);

    int node_open(const struct orb_metadata *meta, bool advertiser, int *instance = nullptr,
              int priority = ORB_PRIO_DEFAULT);

private: // data members
    static Manager *_Instance;

#ifdef ORB_COMMUNICATOR
    // the communicator channel instance.
    uORBCommunicator::IChannel *_comm_channel{nullptr};

    ORBSet _remote_subscriber_topics;
    ORBSet _remote_topics;
#endif /* ORB_COMMUNICATOR */

    DeviceMaster *_device_master{nullptr};

private: //class methods
    Manager();
    ~Manager();

#ifdef ORB_COMMUNICATOR

    virtual int16_t process_remote_topic(const char *topic_name, bool isAdvertisement);

    virtual int16_t process_add_subscription(const char *messageName, int32_t msgRateInHz);

    virtual int16_t process_remove_subscription(const char *messageName);

    virtual int16_t process_received_message(const char *messageName, int32_t length, uint8_t *data);
#endif /* ORB_COMMUNICATOR */

#ifdef ORB_USE_PUBLISHER_RULES

    struct PublisherRule {
        const char **topics; //null-terminated list of topic names
        const char *module_name; //only this module is allowed to publish one of the topics
        bool ignore_other_topics;
    };

    bool startsWith(const char *pre, const char *str);

    bool findTopic(const PublisherRule &rule, const char *topic_name);

    void strTrim(const char **str);

    int readPublisherRulesFromFile(const char *file_name, PublisherRule &rule);

    PublisherRule _publisher_rule;
    bool _has_publisher_rules = false;

#endif /* ORB_USE_PUBLISHER_RULES */

};

#endif /* _uORBManager_hpp_ */