squawk/shared/info.cpp

/*
 * Squawk messenger.
 * Copyright (C) 2019  Yury Gubich <blue@macaw.me>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "info.h"

Shared::Info::Info(const QString &addr, EntryType tp):
type(tp),
address(addr),
vcard(nullptr),
activeKeys(nullptr),
inactiveKeys(nullptr) {
    switch (type) {
    case EntryType::none:
        break;
    case EntryType::contact:
    case EntryType::ownAccount:
        vcard = new VCard();
        activeKeys = new std::list<KeyInfo>();
        inactiveKeys = new std::list<KeyInfo>();
        break;
    default:
        throw 352;
    }
}

Shared::Info::Info():
type(EntryType::none),
address(""),
vcard(nullptr),
activeKeys(nullptr),
inactiveKeys(nullptr) {}

Shared::Info::Info(const Shared::Info &other):
type(other.type),
address(other.address),
vcard(nullptr),
activeKeys(nullptr),
inactiveKeys(nullptr) {
    switch (type) {
    case EntryType::none:
        break;
    case EntryType::contact:
    case EntryType::ownAccount:
        vcard = new VCard(other.getVCardRef());
        activeKeys = new std::list<KeyInfo>(other.getActiveKeysRef());
        inactiveKeys = new std::list<KeyInfo>(other.getInactiveKeysRef());
        break;
    default:
        throw 353;
    }
}

Shared::Info::Info(Info &&other):
type(other.type),
address(other.address),
vcard(other.vcard),
activeKeys(other.activeKeys),
inactiveKeys(other.inactiveKeys) {
    other.type = EntryType::none;
}

Shared::Info &Shared::Info::operator=(Info &&other) {
    type = other.type;
    address = other.address;
    vcard = other.vcard;
    activeKeys = other.activeKeys;
    inactiveKeys = other.inactiveKeys;

    other.type = EntryType::none;

    return *this;
}

Shared::Info &Shared::Info::operator=(const Info &other) {
    type = other.type;
    address = other.address;

    switch (type) {
    case EntryType::none:
        break;
    case EntryType::contact:
    case EntryType::ownAccount:
        vcard = new VCard(other.getVCardRef());
        activeKeys = new std::list<KeyInfo>(other.getActiveKeysRef());
        inactiveKeys = new std::list<KeyInfo>(other.getInactiveKeysRef());
        break;
    default:
        throw 351;
    }

    return *this;
}

Shared::Info::~Info() {
    turnIntoNone();
}

void Shared::Info::turnIntoNone() {
    switch (type) {
    case EntryType::none:
        break;
    case EntryType::contact:
    case EntryType::ownAccount:
        delete vcard;
        vcard = nullptr;
        delete activeKeys;
        activeKeys = nullptr;
        delete inactiveKeys;
        inactiveKeys = nullptr;
        break;
    default:
        break;
    }
    type = EntryType::none;
}

void Shared::Info::turnIntoContact(
    const Shared::VCard &crd, const std::list<KeyInfo> &aks, const std::list<KeyInfo> &iaks
) {
    switch (type) {
    case EntryType::none:
        vcard = new VCard(crd);
        activeKeys = new std::list<KeyInfo>(aks);
        inactiveKeys = new std::list<KeyInfo>(iaks);
        break;
    case EntryType::contact:
    case EntryType::ownAccount:
        *vcard = crd;
        *activeKeys = aks;
        *inactiveKeys = iaks;
        break;
    default:
        break;
    }

    type = EntryType::contact;
}

void Shared::Info::turnIntoContact(Shared::VCard *crd, std::list<KeyInfo> *aks, std::list<KeyInfo> *iaks) {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        delete vcard;
        delete activeKeys;
        delete inactiveKeys;
        [[fallthrough]];
    case EntryType::none:
        vcard = crd;
        activeKeys = aks;
        inactiveKeys = iaks;
        break;
    default:
        break;
    }

    type = EntryType::contact;
}

void Shared::Info::turnIntoOwnAccount(
    const Shared::VCard &crd, const std::list<KeyInfo> &aks, const std::list<KeyInfo> &iaks
) {
    switch (type) {
    case EntryType::none:
        vcard = new VCard(crd);
        activeKeys = new std::list<KeyInfo>(aks);
        inactiveKeys = new std::list<KeyInfo>(iaks);
        break;
    case EntryType::contact:
    case EntryType::ownAccount:
        *vcard = crd;
        *activeKeys = aks;
        *inactiveKeys = iaks;
        break;
    default:
        break;
    }

    type = EntryType::ownAccount;
}

void Shared::Info::turnIntoOwnAccount(Shared::VCard *crd, std::list<KeyInfo> *aks, std::list<KeyInfo> *iaks) {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        delete vcard;
        delete activeKeys;
        delete inactiveKeys;
        [[fallthrough]];
    case EntryType::none:
        vcard = crd;
        activeKeys = aks;
        inactiveKeys = iaks;
        break;
    default:
        break;
    }

    type = EntryType::ownAccount;
}

void Shared::Info::setAddress(const QString &addr) {
    address = addr;
}

QString Shared::Info::getAddress() const {
    return address;
}

const QString &Shared::Info::getAddressRef() const {
    return address;
}

Shared::EntryType Shared::Info::getType() const {
    return type;
}

std::list<Shared::KeyInfo> &Shared::Info::getActiveKeysRef() {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return *activeKeys;
        break;
    default:
        throw 354;
    }
}

const std::list<Shared::KeyInfo> &Shared::Info::getActiveKeysRef() const {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return *activeKeys;
        break;
    default:
        throw 355;
    }
}

std::list<Shared::KeyInfo> *Shared::Info::getActiveKeys() {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return activeKeys;
        break;
    default:
        throw 356;
    }
}

const std::list<Shared::KeyInfo> *Shared::Info::getActiveKeys() const {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return activeKeys;
        break;
    default:
        throw 357;
    }
}

std::list<Shared::KeyInfo> &Shared::Info::getInactiveKeysRef() {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return *inactiveKeys;
        break;
    default:
        throw 358;
    }
}

const std::list<Shared::KeyInfo> &Shared::Info::getInactiveKeysRef() const {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return *inactiveKeys;
        break;
    default:
        throw 359;
    }
}

std::list<Shared::KeyInfo> *Shared::Info::getInactiveKeys() {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return inactiveKeys;
        break;
    default:
        throw 360;
    }
}

const std::list<Shared::KeyInfo> *Shared::Info::getInactiveKeys() const {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return inactiveKeys;
        break;
    default:
        throw 361;
    }
}

const Shared::VCard &Shared::Info::getVCardRef() const {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return *vcard;
        break;
    default:
        throw 362;
    }
}

Shared::VCard &Shared::Info::getVCardRef() {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return *vcard;
        break;
    default:
        throw 363;
    }
}

const Shared::VCard *Shared::Info::getVCard() const {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return vcard;
        break;
    default:
        throw 364;
    }
}

Shared::VCard *Shared::Info::getVCard() {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        return vcard;
        break;
    default:
        throw 365;
    }
}

void Shared::Info::setActiveKeys(std::list<KeyInfo> *keys) {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        activeKeys = keys;
        break;
    default:
        throw 366;
    }
}

void Shared::Info::setVCard(Shared::VCard *card) {
    switch (type) {
    case EntryType::contact:
    case EntryType::ownAccount:
        vcard = card;
        break;
    default:
        throw 367;
    }
}