DataStream/dataprototype.cpp

#include "dataprototype.h"

RuntimeItem::RuntimeItem(AssembleType t) : type_store(t) {}

RuntimeItem::RuntimeItem(const RuntimeItem &other) : RuntimeItem(other.baseType()) {
    this->listener_collection.append(other.listener_collection);
}

std::shared_ptr<const RuntimeItem> RuntimeItem::add(std::shared_ptr<ItemListener> inst) const
{
    if(this->listener_collection.contains(inst))
        return this->shared_from_this();
    
    auto ninst = std::const_pointer_cast<RuntimeItem>(this->clone());
    ninst->listener_collection.append(inst);
    itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
    return ninst;
}

std::shared_ptr<const RuntimeItem> RuntimeItem::del(std::shared_ptr<ItemListener> inst) const
{
    if(!this->listener_collection.contains(inst))
        return this->shared_from_this();
    
    auto ninst = std::const_pointer_cast<RuntimeItem>(this->clone());
    ninst->listener_collection.removeAll(inst);
    itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
    return ninst;
}

void RuntimeItem::itemNotify(std::function<void (std::shared_ptr<ItemListener>)> proc) const
{
    for(auto &lt : listener_collection)
        proc(lt);
}

AssembleType RuntimeItem::baseType() const { return type_store; }

qulonglong RuntimeItem::hashCode() const { return (qulonglong)this; }

std::shared_ptr<const RuntimeItem> RuntimeItem::clone() const{
    return std::make_shared<RuntimeItem>(*this);
}

TypeTemplate::TypeTemplate() : RuntimeItem(AssembleType::DATAS_ASSEMBLE) {}

TypeTemplate::TypeTemplate(const TypeTemplate &other)
: RuntimeItem(other)
{
    this->name_store = other.name_store;
    this->type_store = other.type_store;
    this->io_type = other.io_type;
    this->comps_store = other.comps_store;
}

QString TypeTemplate::name() const { return this->name_store; }

std::shared_ptr<const TypeTemplate> TypeTemplate::setName(const QString &val) const{
    auto ninst = std::static_pointer_cast<TypeTemplate>(std::const_pointer_cast<RuntimeItem>(this->clone()));
    ninst->name_store = val;
    ninst->itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
    return ninst;
}

QString TypeTemplate::type() const { return this->type_store; }

std::shared_ptr<const TypeTemplate> TypeTemplate::setType(const QString &val) const
{
    auto ninst = std::static_pointer_cast<TypeTemplate>(std::const_pointer_cast<RuntimeItem>(this->clone()));
    ninst->name_store = val;
    ninst->itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
    return ninst;
}

DataOritation TypeTemplate::oritation() const { return io_type; }

std::shared_ptr<const TypeTemplate> TypeTemplate::setOritation(DataOritation t) const
{
    auto ninst = std::static_pointer_cast<TypeTemplate>(std::const_pointer_cast<RuntimeItem>(this->clone()));
    ninst->io_type = t;
    ninst->itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
    return ninst;
}

std::shared_ptr<const RuntimeItem> TypeTemplate::clone() const
{
    return std::make_shared<TypeTemplate>(*this);
}

DownAccess::DownAccess(std::shared_ptr<const RuntimeItem> peer) : runtime_item(peer) {}

DownAccess::DownAccess(const DownAccess &other)
{
    this->runtime_item = other.runtime_item;
    this->children_store = other.children_store;
}

std::shared_ptr<const RuntimeItem> DownAccess::itemPeer() const { return this->runtime_item; }

QList<std::shared_ptr<const DownAccess> > DownAccess::members() const { return this->children_store; }

std::shared_ptr<const DownAccess> DownAccess::append(std::shared_ptr<const DownAccess> child_inst) const{
    if(this->children_store.contains(child_inst))
        return this->shared_from_this();
    
    auto ninst = std::const_pointer_cast<DownAccess>(this->clone());
    ninst->children_store.append(child_inst);
    itemPeer()->itemNotify(
        [this, child_inst](std::shared_ptr<ItemListener> inst) {
            inst->memberHasbeenAppended(*this->itemPeer(), child_inst->itemPeer());
        });
    
    return ninst;
}

std::shared_ptr<const DownAccess> DownAccess::remove(std::shared_ptr<const DownAccess> child_inst) const {
    if(!this->children_store.contains(child_inst))
        return this->shared_from_this();
    
    auto ninst = std::const_pointer_cast<DownAccess>(this->clone());
    itemPeer()->itemNotify(
        [this, child_inst](std::shared_ptr<ItemListener> inst) {
            inst->memberAboutToBeRemove(*this->itemPeer(), child_inst->itemPeer());
        });
    
    ninst->children_store.removeAll(child_inst);
    return ninst;
}

std::shared_ptr<const DownAccess> DownAccess::replace(std::shared_ptr<const DownAccess> current, std::shared_ptr<const DownAccess> previous) const
{
    return this->remove(previous)->append(current);
}

std::shared_ptr<const DownAccess> DownAccess::clone() const {
    return std::make_shared<DownAccess>(*this);
}

UpAccess::UpAccess(std::shared_ptr<const UpAccess> parent, std::shared_ptr<const DownAccess> down):runtime_downward(down), parent_ptr(parent){}

UpAccess::UpAccess(const UpAccess &other) { runtime_downward = other.runtime_downward; }

std::shared_ptr<const DownAccess> UpAccess::downwardPeers() const
{
    return this->runtime_downward;
}

std::shared_ptr<const UpAccess> UpAccess::parent() const { return parent_ptr; }

std::shared_ptr<const UpAccess> UpAccess::clone() const { return std::make_shared<const UpAccess>(*this); }