srab/исх/форматы/джесон/типы.tri

модуль джесон

импорт "исх/строка"
импорт "исх/спринтф"

тип ДжесонЗначение* = класс {
    
}

фн (значение: ДжесонЗначение) в строку*(): Строка {
    вернуть "пустое значение"
}

фн (значение: ДжесонЗначение) в токены(): ДжесонТокены {
    авария("попытка преобразовать в токены базовое значение")
}

фн (значение: ДжесонЗначение) пустое*(): Лог {
    вернуть истина
}

фн (значение: ДжесонЗначение) строка*(): мб Строка {
    вернуть пусто
}

фн (значение: ДжесонЗначение) число*(): мб ДжесонЧисло {
    вернуть пусто
}

тип ДжесонЗначения* = []ДжесонЗначение

тип ДжесонСтрока* = класс(ДжесонЗначение) {
    значение*: Строка := ""
}

фн (строка: ДжесонСтрока) в строку*(): Строка {
    вернуть спринтф.ф("\"$стр\"", строка.значение)
}

фн (строка: ДжесонСтрока) в токены(): ДжесонТокены {
    вернуть ДжесонТокены[ТокенСтрока{значение: строка.значение}]
}

фн (строка: ДжесонСтрока) пустое*(): Лог {
    вернуть ложь
}

фн (строка: ДжесонСтрока) строка*(): мб Строка {
    вернуть строка.значение
}

тип ДжесонЧисло* = класс(ДжесонЗначение) {
    значение*: Цел64 := 0
}

фн (число: ДжесонЧисло) в строку*(): Строка {
    вернуть спринтф.ф("$цел", число.значение)
}

фн (число: ДжесонЧисло) в токены(): ДжесонТокены {
    вернуть ДжесонТокены[ТокенЧисло{значение: число.значение}]
}

фн (число: ДжесонЧисло) пустое*(): Лог {
    вернуть ложь
}

фн (число: ДжесонЧисло) число*(): мб ДжесонЧисло {
    вернуть число
}

тип ДжесонЛог* = класс(ДжесонЗначение) {
    значение*: Лог := ложь
}

фн (лог: ДжесонЛог) в строку*(): Строка {
    если лог.значение {
        вернуть "истина"
    }

    вернуть "ложб"
}

фн (лог: ДжесонЛог) в токены(): ДжесонТокены {
    вернуть ДжесонТокены[ТокенБульБуль{значение: лог.значение}]
}

фн (лог: ДжесонЛог) пустое*(): Лог {
    вернуть ложь
}

тип ДжесонМногоЗначений* = класс(ДжесонЗначение) {
    значения*: ДжесонЗначения = ДжесонЗначения[]
}

фн (значения: ДжесонМногоЗначений) в строку*(): Строка {
    пусть выходная строка := ""

    цикл [номер]значение среди значения.значения {
        если номер > 0 {
            выходная строка := спринтф.ф("$стр, ", выходная строка)
        }

        выходная строка := строка.собрать(выходная строка, значение.в строку())
    }

    вернуть спринтф.ф("[$стр]", выходная строка)
}

фн (значения: ДжесонМногоЗначений) в токены(): ДжесонТокены {
    пусть токены = ДжесонТокены[ТокенКвадратнаяСкобка{закрывающая: ложь}]

    цикл [номер]значение среди значения.значения {
        если номер > 0 {
            токены.добавить(ТокенЗапятая{})
        }

        токены.добавить(значение.в токены()...)
    }

    токены.добавить(ТокенКвадратнаяСкобка{закрывающая: истина})

    вернуть токены
}

фн (значения: ДжесонМногоЗначений) пустое*(): Лог {
    вернуть длина(значения.значения) = 0
}

тип ДжесонОбъект* = класс(ДжесонЗначение) {
    значения*: ДжесонКлючЗначения := ДжесонКлючЗначения[]
}

фн (объект: ДжесонОбъект) в строку*(): Строка {
    пусть выходная строка := ""

    цикл [номер]значение среди объект.значения {
        если номер > 0 {
            выходная строка := спринтф.ф("$стр,\n", выходная строка)
        } иначе {
            выходная строка := спринтф.ф("\n$стр", выходная строка)
        }

        выходная строка := строка.собрать(выходная строка, спринтф.ф("\"$стр\": $стр", значение.ключ, значение.значение.в строку()))
    }

    вернуть спринтф.ф("{$стр\n}", выходная строка)
}

фн (объект: ДжесонОбъект) в токены(): ДжесонТокены {
    пусть токены = ДжесонТокены[ТокенФигурнаяСкобка{закрывающая: ложь}]

    цикл [номер]значение среди объект.значения {
        если номер > 0 {
            токены.добавить(ТокенЗапятая{})
        }

        токены.добавить(ТокенСтрока{значение: значение.ключ})
        токены.добавить(ТокенДвоеточие{})
        токены.добавить(значение.значение.в токены()...)
    }

    токены.добавить(ТокенФигурнаяСкобка{закрывающая: истина})

    вернуть токены
}

фн (объект: ДжесонОбъект) пустое*(): Лог {
    вернуть ложь
}

фн (объект: ДжесонОбъект) получить*(ключ: Строка): ДжесонЗначение {
    пусть количество = длина(объект.значения)
    пусть ай := количество - 1

    пока ай >= 0 {
        пусть значение = объект.значения[ай]

        если значение.ключ = ключ {
            вернуть значение.значение
        }

        ай := ай - 1
    }

    вернуть ДжесонЗначение{}
}

фн (объект: ДжесонОбъект) вставить*(ключ: Строка, новое значение: ДжесонЗначение) {
    цикл [номер]значение среди объект.значения {
        если значение.ключ = ключ {
            объект.значения[номер].значение := новое значение
            вернуть
        }
    }

    объект.значения.добавить(ДжесонКлючЗначение{ключ: ключ, значение: новое значение})
}

тип ДжесонКлючЗначение* = класс {
    ключ*: Строка := ""
    значение*: ДжесонЗначение := позже
}

тип ДжесонКлючЗначения* = []ДжесонКлючЗначение