schema_editor/comdel/domain/value.cpp

#include "value.h"

#include <string>

namespace domain {

    std::string Value::string() {
        switch (type) {
            case INT:
                return std::to_string(intValue);
            case BOOL:
                return boolValue ? "true" : "false";
            case STRING:
                return stringValue;
            case NIL:
                return "null";
            case UNDEFINED:
                return "undefined";
            case ADDRESS_SPACE:
                return "AddressSpace::" + addressSpace->getName();
            case WIRE_REFERENCE:
                return "Wire::" + reference;
            case ADDRESS_SPACE_REFERENCE:
                return "AddressSpace::" + reference;
            case ATTRIBUTE_REFERENCE:
                return "Attribute::" + reference;
            case MEMORY_REFERENCE:
                if (memoryReference.has_value()) {
                    return "Memory::" + *memoryReference;
                } else {
                    return "Memory::null";
                }
            default:
                return "unknown";
        }
    }


    Value::ValueType Value::getType() {
        return type;
    }

    bool Value::isType(Value::ValueType _type) {
        return type == _type;
    }

    long long Value::asInt() {
        if (isType(Value::INT)) {
            return intValue;
        }
        throw std::exception();
    }

    std::string Value::asString() {
        if (isType(Value::STRING)) {
            return stringValue;
        }
        throw std::exception();
    }

    bool Value::asBool() {
        if (isType(Value::BOOL)) {
            return boolValue;
        }
        throw std::exception();
    }

    AddressSpace Value::asAddressSpace() {
        if (isType(Value::ADDRESS_SPACE)) {
            return *addressSpace;
        }
        throw std::exception();
    }

    std::string Value::asReference() {
        if (isType(Value::WIRE_REFERENCE) || isType(Value::ADDRESS_SPACE_REFERENCE) ||
            isType(Value::ATTRIBUTE_REFERENCE) || isType(Value::UNDEFINED)) {
            return reference;
        }
        throw std::exception();
    }

    std::optional<std::string> Value::asMemoryReference() {
        return memoryReference;
    }

    domain::ComponentInstance *Value::asMemory() {
        return memory;
    }


    void Value::setInt(long long value) {
        if (isType(Value::INT)) {
            this->intValue = value;
        } else {
            throw std::exception();
        }
    }

    void Value::setString(std::string value) {
        if (isType(Value::STRING)) {
            this->stringValue = value;
        } else {
            throw std::exception();
        }
    }

    void Value::setBool(bool value) {
        if (isType(Value::BOOL)) {
            this->boolValue = value;
        } else {
            throw std::exception();
        }
    }

    void Value::setReference(std::string value) {
        if (isType(Value::WIRE_REFERENCE)) {
            this->reference = value;
        } else {
            throw std::exception();
        }
    }


    Value Value::fromInt(long long value) {
        Value val;
        val.type = Value::INT;
        val.intValue = value;
        return val;
    }

    Value Value::fromString(std::string value) {
        Value val;
        val.type = Value::STRING;
        val.stringValue = value;
        return val;
    }

    Value Value::fromBool(bool value) {
        Value val;
        val.type = Value::BOOL;
        val.boolValue = value;
        return val;
    }

    Value Value::fromAddressSpace(AddressSpace addressSpace) {
        Value val;
        val.type = Value::ADDRESS_SPACE;
        val.addressSpace = addressSpace;
        return val;
    }

    Value Value::fromReference(std::string value, Value::ValueType type) {
        Value val;
        val.type = type;
        val.reference = value;
        return val;
    }

    Value Value::fromNull() {
        Value val;
        val.type = Value::NIL;
        return val;
    }

    Value Value::fromMemoryReference(std::optional<std::string> value) {
        Value val;
        val.type = MEMORY_REFERENCE;
        val.memoryReference = value;
        return val;
    }

    std::string Value::stringify() {
        switch (type) {
            case INT:
                return std::to_string(intValue);
            case BOOL:
                return boolValue ? "true" : "false";
            case STRING:
                return "\"" + stringValue + "\"";
            case NIL:
                return "null";
            case WIRE_REFERENCE:
            case ADDRESS_SPACE_REFERENCE:
            case ATTRIBUTE_REFERENCE:
                return reference;
            case MEMORY_REFERENCE:
                if (memoryReference.has_value()) {
                    return memoryReference.value();
                } else {
                    return "null";
                }
            default:
                throw std::exception();
        }
    }

    Value Value::ofType(Value::ValueType type) {
        Value val;
        val.type = type;
        return val;
    }

    bool Value::equals(Value value) {
        if (value.getType() == type) {
            switch (type) {
                case INT:
                    return value.asInt() == intValue;
                case STRING:
                    return value.asString() == stringValue;
                case NIL:
                case UNDEFINED:
                    return true;
                case WIRE_REFERENCE:
                case ATTRIBUTE_REFERENCE:
                case ADDRESS_SPACE_REFERENCE:
                    return value.asReference() == reference;
                case MEMORY_REFERENCE:
                    return value.asMemoryReference() == memoryReference;
                case MEMORY:
                    return value.asMemory() == memory;
                case BOOL:
                    return value.asBool() == boolValue;
                default:
                    return false;
            }
        }
        return false;
    }

} // namespace domain