source.h

Go to the documentation of this file.

 
#ifndef DDL_MAPPING_RT_SOURCE_HEADER
#define DDL_MAPPING_RT_SOURCE_HEADER
 
#include <a_util/result.h>
#include <ddl/codec/codec_factory.h>
#include <ddl/mapping/configuration/map_source.h>
#include <ddl/mapping/engine/element.h>
#include <ddl/mapping/engine/mapping_environment_intf.h>
 
#include <memory>
 
namespace ddl {
namespace mapping {
namespace rt {
struct AssignmentStruct {
    size_t buffer_size;
    uint32_t type32;
    uintptr_t element_ptr_offset;
 
    AssignmentStruct() : buffer_size(0), type32(0), element_ptr_offset(static_cast<uintptr_t>(-1))
    {
    }
 
    bool operator==(const AssignmentStruct& other) const
    {
        return (element_ptr_offset == other.element_ptr_offset);
    }
};
 
} // namespace rt
} // namespace mapping
} // namespace ddl
 
namespace ddl {
namespace mapping {
namespace rt {
class TriggerBase;
class Target;
class TargetElement;
class Source : public ISignalListener {
public: // types
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic ignored                                                                     \
    "-Wattributes" // standard type attributes are ignored when used in templates
#endif
 
    // Map of source elements and a vector of target elements
    typedef std::vector<std::pair<AssignmentStruct, TargetElementList>> Assignments;
    typedef std::vector<std::pair<TriggerBase*, AssignmentStruct>> Triggers;
    typedef std::vector<uint8_t> MemoryBuffer;
    typedef std::set<const Target*> TargetRefList;
 
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic warning                                                                     \
    "-Wattributes" // standard type attributes are ignored when used in templates
#endif
 
public:
    Source(IMappingEnvironment& env);
 
    Source(const Source&) = delete;
 
    Source& operator=(const Source&) = delete;
 
    ~Source();
 
    a_util::result::Result create(const mapping::MapSource& map_source,
                                  const std::string& type_description);
 
    a_util::result::Result addAssignment(const ddl::mapping::MapConfiguration& map_config,
                                         const std::string& source_element,
                                         TargetElement* target_element);
 
    a_util::result::Result addTrigger(const MapConfiguration& map_config, TriggerBase* trigger);
 
    a_util::result::Result removeAssignmentsFor(const Target* target);
 
    const std::string& getTypeName() const;
 
    const Assignments& getAssigmentList() const;
 
    a_util::result::Result onSampleReceived(const void* data, size_t size);
 
private:
    IMappingEnvironment& _env;
    handle_t _handle;
    std::string _name;
    std::string _type_name;
    std::string _type_description;
    Assignments _assignments;
    TargetRefList _targets;
    std::unique_ptr<ddl::codec::CodecFactory> _codec_factory;
    TypeMap _type_map;
    TargetElementList _received_elements;
    Triggers _triggers;
};
 
typedef std::map<std::string, Source*> SourceMap;
 
} // namespace rt
} // namespace mapping
} // namespace ddl
 
#endif // DDL_MAPPING_RT_SOURCE_HEADER