datamodel_streams.h

Go to the documentation of this file.

 
#ifndef DD_DATA_MODEL_STREAMS_H_INCLUDED
#define DD_DATA_MODEL_STREAMS_H_INCLUDED
 
#include <ddl/dd/datamodel/datamodel_base.h>
#include <ddl/dd/dd_common_types.h>
#include <ddl/utilities/access_list.h>
#include <ddl/utilities/access_map.h>
#include <ddl/utilities/access_observer.h>
#include <ddl/utilities/infomodel_base.h>
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace ddl {
 
namespace dd {
 
namespace datamodel {

class Stream : public ModelSubject<Stream>,
               public utility::TypeAccessMapSubject<Stream>,
               public InfoMap {
public:
    Stream() = delete;
    Stream(Stream&&);
    Stream& operator=(Stream&&);
    Stream(const Stream& other);
    Stream& operator=(const Stream& other);
    virtual ~Stream() = default;

    class Struct : public utility::TypeAccessListSubject<Struct>, public InfoMap {
    public:
        Struct(){};
        Struct(const Struct&) = default;
        Struct(Struct&&) = default;
        Struct& operator=(const Struct&) = default;
        Struct& operator=(Struct&&) = default;
        Struct(std::string name, std::string type_name, OptionalSize byte_pos = {});

        bool operator==(const Struct& other) const;
        bool operator!=(const Struct& other) const;

        const std::string& getName() const;
        void setName(const std::string& name);

        const std::string& getTypeName() const;
        void setTypeName(const std::string& type_name);

        OptionalSize getBytePos() const;
        void setBytePos(OptionalSize byte_pos);
 
    private:
        std::string _name;
        std::string _type_name;
        OptionalSize _byte_pos;
    };

    Stream(std::string name,
           std::string stream_type_name,
           std::string description = {},
           const std::vector<Struct>& structs = {});
    bool operator==(const Stream& other) const;
    bool operator!=(const Stream& other) const;

    void setName(const std::string& name);
    const std::string& getName() const;
    void setStreamTypeName(const std::string& stream_type_name);
    const std::string& getStreamTypeName() const;

    const std::string& getDescription() const;
    void setDescription(const std::string& description);
 
public:
    using Structs = utility::TypeAccessList<Struct, Stream>;
    friend Structs;

    const Structs& getStructs() const;
    Structs& getStructs();
 
private:
    void notify(ModelEventCode code,
                utility::TypeAccessMapEventCode map_code,
                const std::string& additional_info);
    bool validateContains(const Structs::access_type& stream_struct) const;
    void notifyChangedListContent(utility::TypeAccessListEventCode code,
                                  Structs::access_type& stream_struct,
                                  const std::string& additional_info);
    [[deprecated]]
    const Structs::container_named_type* getNamedItemList() const;
    [[deprecated]]
    Structs::container_named_type* getNamedItemList();
 
    const Structs::container_named_type* getNamedItemViewList() const;
    Structs::container_named_type* getNamedItemViewList();
 
    std::string _name;
    std::string _stream_type_name;
    std::string _description;
    Structs _structs;
};
 
} // namespace datamodel
} // namespace dd
} // namespace ddl
 
#endif // DD_DATA_MODEL_STREAMS_H_INCLUDED