schema_editor/comdel/domain/value.h

#ifndef DOMAIN_VALUE_H
#define DOMAIN_VALUE_H

#include "addressspace.h"

#include <string>
#include <optional>


namespace domain {

    class ComponentInstance;

class Value
{
public:
    enum ValueType {
        INT,
        STRING,
        BOOL,
        ADDRESS_SPACE,
        ADDRESS_SPACE_REFERENCE,
        ATTRIBUTE_REFERENCE,
        MEMORY_REFERENCE,
        MEMORY,
        WIRE_REFERENCE,
        NIL,
        UNDEFINED,
    };

private:
    long long intValue = 0;
    std::string stringValue;
    bool boolValue = false;
    std::optional<AddressSpace> addressSpace = std::nullopt;
    std::string reference;
    domain::ComponentInstance *memory = nullptr;

    std::optional<std::string> memoryReference = std::nullopt;

    ValueType type = UNDEFINED;

public:

    Value() {}

    bool 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;
    }

    std::string string();

    ValueType getType();
    bool isType(ValueType type);

    long long asInt();
    std::string asString();
    bool asBool();
    std::string asReference();
    std::optional<std::string> asMemoryReference();
    domain::ComponentInstance* asMemory();
    AddressSpace asAddressSpace();

    void setInt(long long intValue);
    void setString(std::string value);
    void setBool(bool value);
    void setReference(std::string value);

    std::string stringify();

    static Value fromInt(long long value);
    static Value fromString(std::string value);
    static Value fromBool(bool value);
    static Value fromNull();
    static Value fromAddressSpace(AddressSpace addressSpace);
    static Value fromReference(std::string value, ValueType type);
    static Value ofType(ValueType type);
    static Value fromMemoryReference(std::optional<std::string> memoryReference);
    static Value fromMemory(domain::ComponentInstance *memory);
};

} // namespace domain

#endif // DOMAIN_VALUE_H