target.h

Go to the documentation of this file.

 
#ifndef DDL_MAPPING_RT_TARGET_HEADER
#define DDL_MAPPING_RT_TARGET_HEADER
 
#include <a_util/concurrency.h>
#include <a_util/result.h>
#include <ddl/codec/static_codec.h>
#include <ddl/mapping/legacy/configuration/map_source.h>
#include <ddl/mapping/legacy/configuration/map_target.h>
#include <ddl/mapping/legacy/engine/element.h>
#include <ddl/mapping/legacy/engine/mapping_environment_intf.h>
#include <ddl/mapping/legacy/engine/source.h>
 
#include <memory>
#include <vector>
 
namespace ddl {
namespace mapping {
namespace rt {
class Target {
public: // types
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic ignored                                                                     \
    "-Wattributes" // standard type attributes are ignored when used in templates
#endif

    typedef std::vector<std::pair<std::string, TargetElement*>> Assignments;
    typedef std::vector<std::pair<uint64_t, TargetElement*>> TriggerCounters;
    typedef std::vector<std::pair<std::string, TargetElement*>> Constants;
    typedef std::vector<uint8_t> MemoryBuffer;
 
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic warning                                                                     \
    "-Wattributes" // standard type attributes are ignored when used in templates
#endif
 
public:
    Target(IMappingEnvironment& env);

    ~Target();

    a_util::result::Result create(const MapConfiguration& map_config,
                                  const MapTarget& map_target,
                                  const std::string& target_description,
                                  SourceMap& sources);

    a_util::result::Result reset(const MapConfiguration& map_config);

    const std::string& getName() const;

    const std::string& getTypeName() const;

    const TargetElementList& getElementList() const;

    size_t getSize() const;

    a_util::result::Result getCurrentBuffer(void* target_buffer, size_t target_buffer_size);

    a_util::result::Result getBufferRef(const void*& buffer, size_t& target_buffer_size);

    a_util::result::Result updateAccessFunctionValues();

    a_util::result::Result updateTriggerFunctionValues();
 
private:
    std::string _name;
    std::string _type_name;
    TargetElementList _target_elements;
    std::vector<TargetElement*> _simulation_time_elements;
    TriggerCounters _counter_elements;
    Constants _constant_elements;
    uint64_t _counter;
    std::unique_ptr<ddl::codec::StaticCodec> _codec;
    MemoryBuffer _buffer;
    mutable a_util::concurrency::shared_mutex _buffer_mutex;
    IMappingEnvironment& _env;
 
public:
    inline void aquireWriteLock() const
    {
        _buffer_mutex.lock_shared();
    }

    inline void releaseWriteLock() const
    {
        _buffer_mutex.unlock_shared();
    }

    inline void aquireReadLock() const
    {
        _buffer_mutex.lock();
    }

    inline void releaseReadLock() const
    {
        _buffer_mutex.unlock();
    }
};

typedef std::map<std::string, Target*> TargetMap;
typedef std::set<Target*> TargetSet;
 
} // namespace rt
} // namespace mapping
} // namespace ddl
#endif // DDL_MAPPING_RT_TARGET_HEADER