vyn/mirai
1
Fork 0
mirror of https://codeberg.org/vyn/mirai.git synced 2025-07-04 18:53:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[WIP] convert to snake_case

Browse source
This commit is contained in:
Vyn 2025-06-27 10:55:56 +02:00
parent 4bca7fac3e
commit 9de3972630
Signed by: vyn
GPG key ID: E1B2BE34E7A971E7
17 changed files with 335 additions and 336 deletions
Download patch file Download diff file Expand all files Collapse all files

8
external/mirai-core/src/Day.cpp vendored
View file

@ -29,11 +29,11 @@ Date Day::date() const
std::vector<Task> Day::tasks()
{
auto tasksData = data_->getTasksByDayId(id());
auto tasksData = data_->get_tasks_by_day_id(id());
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) {
[&](const task_data &taskData) {
return Task{data_, taskData};
}
);
@ -42,11 +42,11 @@ std::vector<Task> Day::tasks()
std::vector<Event> Day::events()
{
auto eventsData = data_->getEventsByDate(dayData_.date);
auto eventsData = data_->get_events_by_date(dayData_.date);
std::vector<Event> events;
std::transform(
eventsData.begin(), eventsData.end(), std::back_inserter(events),
[&](const EventData &eventData) {
[&](const event_data &eventData) {
return Event{data_, eventData};
}
);

12
external/mirai-core/src/Event.cpp vendored
View file

@ -38,11 +38,11 @@ Time Event::endsAt() const
std::vector<Task> Event::queryTasks() const
{
auto tasksData = data_->getTasksByEventId(eventData_.id);
auto tasksData = data_->get_tasks_by_event_id(eventData_.id);
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) {
[&](const task_data &taskData) {
return Task{data_, taskData};
}
);
@ -51,21 +51,21 @@ std::vector<Task> Event::queryTasks() const
void Event::setTitle(const std::string &newTitle)
{
data_->updateEvent(id(), {.title = newTitle});
data_->update_event(id(), {.title = newTitle});
}
void Event::setDay(const Day &day)
{
data_->updateEvent(id(), {.dayId = day.id()});
data_->update_event(id(), {.dayId = day.id()});
}
void Event::setStartTime(const Time &time)
{
data_->updateEvent(id(), {.startsAt = time});
data_->update_event(id(), {.startsAt = time});
}
void Event::setEndTime(const Time &time)
{
data_->updateEvent(id(), {.endsAt = time});
data_->update_event(id(), {.endsAt = time});
}
} // namespace mirai

51
external/mirai-core/src/MarkdownDataProvider.Parser.cpp vendored
View file

@ -37,16 +37,17 @@ std::string fieldWithSpace(const std::string &field)
return (field + " ");
}
TaskData stringToTask(const std::string &str, const std::string &date)
task_data stringToTask(const std::string &str, const std::string &date)
{
std::smatch matches;
std::regex regex("- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
std::regex regex(
"- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
);
std::regex_match(str, matches, regex);
std::string text = stringUtils::trim(matches[5]);
TaskData taskItem{
task_data taskItem{
.title = text,
.state = str.substr(0, 5) == "- [X]" ? DONE : TODO,
};
@ -69,7 +70,7 @@ Time stringToTime(const std::string &str)
return time;
}
EventData stringToEvent(const std::string &str, const std::string &dateString)
event_data stringToEvent(const std::string &str, const std::string &dateString)
{
std::smatch matches;
std::regex regex("> (([0-9]{2}h[0-9]{2})-([0-9]{2}h[0-9]{2}) )(.*?)( -- (.*))?");
@ -83,7 +84,7 @@ EventData stringToEvent(const std::string &str, const std::string &dateString)
throw std::runtime_error("Malformated date");
}
EventData eventData{
event_data eventData{
.title = text,
.startsAt = stringToTime(matches[2]),
.endsAt = stringToTime(matches[3]),
@ -91,23 +92,23 @@ EventData stringToEvent(const std::string &str, const std::string &dateString)
return eventData;
}
std::string taskToString(const TaskData &task)
std::string taskToString(const task_data &task)
{
std::string str = task.title;
str = (task.state == DONE ? "- [X] " : "- [ ] ") + str;
return str;
}
std::string MarkdownDataProvider::toMarkdown()
std::string markdown_data_provider::to_markdown()
{
const std::vector<DayData> days = getDays();
const std::vector<day_data> days = get_days();
std::string result = "# " + name() + "\n\n";
std::string currentDate = "";
for (const auto &day : days) {
auto &date = day.date;
auto tasks = getTasksByDayId(day.id);
auto events = getEventsByDate(date);
auto tasks = get_tasks_by_day_id(day.id);
auto events = get_events_by_date(date);
if (tasks.size() == 0 && events.size() == 0) {
continue;
}
@ -122,7 +123,7 @@ std::string MarkdownDataProvider::toMarkdown()
end.minute, event.title
) +
"\n";
for (const auto &task : getTasksByEventId(event.id)) {
for (const auto &task : get_tasks_by_event_id(event.id)) {
result += taskToString(task) + '\n';
}
result += '\n';
@ -133,7 +134,7 @@ std::string MarkdownDataProvider::toMarkdown()
result += '\n';
}
auto unscheduledTasks = getTasksWithoutDate();
auto unscheduledTasks = get_tasks_without_date();
if (unscheduledTasks.size() > 0) {
result += "## Unscheduled\n\n";
for (const auto &task : unscheduledTasks) {
@ -144,7 +145,7 @@ std::string MarkdownDataProvider::toMarkdown()
return result;
};
MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
markdown_data markdown_data_provider::parse_markdown(const std::string &content)
{
cpputils::debug::Timer readMdFormatDuration;
@ -156,13 +157,13 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
std::println("Couldn't find the task list name");
}
data.name = line.substr(2);
_data.name = line.substr(2);
std::string currentDateString = "";
std::vector<mirai::DayData> daysData;
std::vector<mirai::TaskData> unscheduledTasks;
std::vector<mirai::day_data> daysData;
std::vector<mirai::task_data> unscheduledTasks;
std::optional<Date> currentDate = std::nullopt;
std::optional<EventData> currentEvent = std::nullopt;
std::optional<event_data> currentEvent = std::nullopt;
cpputils::debug::Timer stringToTaskDuration;
stringToTaskDuration.reset();
@ -178,11 +179,11 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
if (!currentDate.has_value()) {
throw std::runtime_error("Malformated date (1)");
}
insertDay({.id = generateUniqueId(), .date = currentDate.value()});
insert_day({.id = generateUniqueId(), .date = currentDate.value()});
} else if (line.starts_with("> ")) {
auto event = stringToEvent(line, currentDateString);
if (currentDate.has_value()) {
auto day = getDayByDate(currentDate.value());
auto day = get_day_by_date(currentDate.value());
currentEvent = insertEvent(
{.id = generateUniqueId(),
.dayId = day->id,
@ -193,10 +194,10 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
}
} else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) {
stringToTaskDuration.start();
TaskData taskItemData = stringToTask(line, currentDateString);
task_data taskItemData = stringToTask(line, currentDateString);
stringToTaskDuration.stop();
if (currentEvent.has_value()) {
insertTask({
insert_task({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
@ -204,8 +205,8 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
.eventId = currentEvent.value().id,
});
} else if (currentDate.has_value()) {
auto day = getDayByDate(currentDate.value());
insertTask({
auto day = get_day_by_date(currentDate.value());
insert_task({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
@ -213,7 +214,7 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
.eventId = std::nullopt,
});
} else {
insertTask({
insert_task({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
@ -229,6 +230,6 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
gelinesDuration.printTimeElapsed("getlinesDuration");
stringToTaskDuration.printTimeElapsed("stringToTaskDuration");
readMdFormatDuration.printTimeElapsed("Reading MD File duration");
return data;
return _data;
}
} // namespace mirai

144
external/mirai-core/src/MarkdownDataProvider.cpp vendored
View file

@ -18,33 +18,33 @@
namespace mirai
{
std::string MarkdownDataProvider::path() const
std::string markdown_data_provider::path() const
{
return filePath_;
return _file_path;
}
std::string MarkdownDataProvider::name() const
std::string markdown_data_provider::name() const
{
return data.name;
return _data.name;
}
void MarkdownDataProvider::save()
void markdown_data_provider::save()
{
std::ofstream file(filePath_);
std::ofstream file(_file_path);
if (!file.is_open()) {
throw std::runtime_error("can't create " + filePath_);
throw std::runtime_error("can't create " + _file_path);
}
const std::string content = toMarkdown();
const std::string content = to_markdown();
file << content;
file.close();
setDirty(false);
set_dirty(false);
};
void MarkdownDataProvider::load()
void markdown_data_provider::load()
{
std::ifstream file(filePath_);
std::ifstream file(_file_path);
if (!file.is_open()) {
return;
}
@ -55,19 +55,19 @@ void MarkdownDataProvider::load()
content += line + "\n";
}
file.close();
data = parseMarkdown(content);
_data = parse_markdown(content);
};
TaskData MarkdownDataProvider::insertTask(const TaskData &taskData)
task_data markdown_data_provider::insert_task(const task_data &taskData)
{
data.tasks.push_back(taskData);
setDirty(true);
_data.tasks.push_back(taskData);
set_dirty(true);
return taskData;
}
void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
void markdown_data_provider::update_task(int taskId, updatable_task_data updateData)
{
auto taskData = ptrFindFirst(data.tasks, [&](const TaskData &task) {
auto taskData = ptrFindFirst(_data.tasks, [&](const task_data &task) {
return task.id == taskId;
});
assert(taskData != nullptr); // Shouldn't be possible
@ -83,122 +83,122 @@ void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
if (updateData.eventId.has_value()) {
taskData->eventId = updateData.eventId.value();
}
setDirty(true);
set_dirty(true);
}
std::optional<TaskData> MarkdownDataProvider::getTaskById(int taskId)
std::optional<task_data> markdown_data_provider::get_task_by_id(int taskId)
{
return findFirst(data.tasks, [&](const TaskData &task) {
return findFirst(_data.tasks, [&](const task_data &task) {
return task.id == taskId;
});
}
std::vector<TaskData> MarkdownDataProvider::getTasksByEventId(int eventId)
std::vector<task_data> markdown_data_provider::get_tasks_by_event_id(int eventId)
{
return findAll(data.tasks, [&](const TaskData &task) {
return findAll(_data.tasks, [&](const task_data &task) {
return task.eventId == eventId;
});
}
std::vector<TaskData> MarkdownDataProvider::getTasksByDayId(int dayId)
std::vector<task_data> markdown_data_provider::get_tasks_by_day_id(int dayId)
{
return findAll(data.tasks, [&](const TaskData &task) {
return findAll(_data.tasks, [&](const task_data &task) {
return task.dayId == dayId;
});
}
std::vector<TaskData> MarkdownDataProvider::getTasksWithoutDate()
std::vector<task_data> markdown_data_provider::get_tasks_without_date()
{
return findAll(data.tasks, [](const TaskData &t) {
return findAll(_data.tasks, [](const task_data &t) {
return t.dayId == std::nullopt && t.eventId == std::nullopt;
});
}
std::vector<TaskData> MarkdownDataProvider::getTasksByDate(Date date)
std::vector<task_data> markdown_data_provider::get_tasks_by_date(Date date)
{
auto day = getDayByDate(date);
auto day = get_day_by_date(date);
if (!day.has_value()) {
return {};
}
return findAll(data.tasks, [&](const TaskData &t) {
return findAll(_data.tasks, [&](const task_data &t) {
return t.dayId == day.value().id;
});
}
std::vector<TaskData> MarkdownDataProvider::getTasks()
std::vector<task_data> markdown_data_provider::get_tasks()
{
return data.tasks;
return _data.tasks;
}
void MarkdownDataProvider::removeTaskById(int taskId)
void markdown_data_provider::remove_task_by_id(int taskId)
{
data.tasks.erase(
_data.tasks.erase(
std::remove_if(
data.tasks.begin(), data.tasks.end(),
[&](const TaskData &task) {
_data.tasks.begin(), _data.tasks.end(),
[&](const task_data &task) {
return task.id == taskId;
}
),
data.tasks.end()
_data.tasks.end()
);
setDirty(true);
set_dirty(true);
}
DayData MarkdownDataProvider::insertDay(const DayData &dayData)
day_data markdown_data_provider::insert_day(const day_data &dayData)
{
data.days.push_back(dayData);
setDirty(true);
_data.days.push_back(dayData);
set_dirty(true);
return dayData;
}
void MarkdownDataProvider::updateDay(int dayId, UpdatableDayData updateData)
void markdown_data_provider::update_day(int dayId, updatable_day_data updateData)
{
auto dayData = ptrFindFirst(data.days, [&](const DayData &day) {
auto dayData = ptrFindFirst(_data.days, [&](const day_data &day) {
return day.id == dayId;
});
assert(dayData != nullptr); // Shouldn't be possible
if (updateData.date.has_value()) {
dayData->date = updateData.date.value();
}
setDirty(true);
set_dirty(true);
}
void MarkdownDataProvider::removeDayById(int dayId)
void markdown_data_provider::remove_day_by_id(int dayId)
{
data.days.erase(
_data.days.erase(
std::remove_if(
data.days.begin(), data.days.end(),
[&](const DayData &day) {
_data.days.begin(), _data.days.end(),
[&](const day_data &day) {
return day.id == dayId;
}
),
data.days.end()
_data.days.end()
);
setDirty(true);
set_dirty(true);
}
std::vector<DayData> MarkdownDataProvider::getDays()
std::vector<day_data> markdown_data_provider::get_days()
{
return data.days;
return _data.days;
}
std::optional<DayData> MarkdownDataProvider::getDayByDate(const Date &date)
std::optional<day_data> markdown_data_provider::get_day_by_date(const Date &date)
{
return findFirst(data.days, [&](const DayData &day) {
return findFirst(_data.days, [&](const day_data &day) {
return day.date == date;
});
}
EventData MarkdownDataProvider::insertEvent(const EventData &eventData)
event_data markdown_data_provider::insertEvent(const event_data &eventData)
{
data.events.push_back(eventData);
setDirty(true);
_data.events.push_back(eventData);
set_dirty(true);
return eventData;
}
void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateData)
void markdown_data_provider::update_event(int eventId, updatable_event_data updateData)
{
auto eventData = ptrFindFirst(data.events, [&](const EventData &event) {
auto eventData = ptrFindFirst(_data.events, [&](const event_data &event) {
return event.id == eventId;
});
assert(eventData != nullptr); // Shouldn't be possible
@ -214,43 +214,43 @@ void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateDat
if (updateData.endsAt.has_value()) {
eventData->endsAt = updateData.endsAt.value();
}
setDirty(true);
set_dirty(true);
}
void MarkdownDataProvider::removeEventById(int eventId)
void markdown_data_provider::remove_event_by_id(int eventId)
{
data.events.erase(
_data.events.erase(
std::remove_if(
data.events.begin(), data.events.end(),
[&](const EventData &event) {
_data.events.begin(), _data.events.end(),
[&](const event_data &event) {
return event.id == eventId;
}
),
data.events.end()
_data.events.end()
);
setDirty(true);
set_dirty(true);
}
std::optional<EventData> MarkdownDataProvider::getEventById(int eventId)
std::optional<event_data> markdown_data_provider::get_event_by_id(int eventId)
{
return findFirst(data.events, [&](const EventData &event) {
return findFirst(_data.events, [&](const event_data &event) {
return event.id == eventId;
});
}
std::vector<EventData> MarkdownDataProvider::getEventsByDate(Date date)
std::vector<event_data> markdown_data_provider::get_events_by_date(Date date)
{
auto day = getDayByDate(date);
auto day = get_day_by_date(date);
if (!day.has_value()) {
return {};
}
return findAll(data.events, [&](const EventData &event) {
return findAll(_data.events, [&](const event_data &event) {
return event.dayId == day.value().id;
});
}
std::vector<EventData> MarkdownDataProvider::getEvents()
std::vector<event_data> markdown_data_provider::get_events()
{
return data.events;
return _data.events;
}
} // namespace mirai

51
external/mirai-core/src/Mirai.cpp vendored
View file

@ -43,11 +43,11 @@ void Mirai::loadConfig(const std::string &path)
const auto name = filePath.asObject().getString("name");
const auto color = filePath.asObject().getString("color");
const auto path = filePath.asObject().getString("path");
std::unique_ptr<DataProvider> file = std::make_unique<MarkdownDataProvider>(path);
DataProvider *sourceDataProvider = file.release();
std::unique_ptr<data_provider> file = std::make_unique<markdown_data_provider>(path);
data_provider *sourceDataProvider = file.release();
sourceDataProvider->load();
sources_.push_back(
std::make_unique<Source>(SourceConstructor{
std::make_unique<source>(SourceConstructor{
.name = name, .color = color, .sourceDataProvider = sourceDataProvider
})
);
@ -69,7 +69,7 @@ void Mirai::saveConfig()
rei::json::JsonObject jsonSource;
jsonSource.set("name", source->name());
jsonSource.set("color", source->color());
auto dataProvider = dynamic_cast<MarkdownDataProvider *>(source->dataProvider());
auto dataProvider = dynamic_cast<markdown_data_provider *>(source->data_provider());
jsonSource.set("path", dataProvider->path());
jsonSource.set("type", "FileSystemMarkdown");
configJson.getArray("files").push(jsonSource);
@ -84,13 +84,13 @@ Mirai::Mirai(const std::string &configFilePath) : configPath_(configFilePath)
}
void Mirai::addSource(
const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source
const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&new_source
)
{
DataProvider *sourceDataProvider = source.release();
data_provider *sourceDataProvider = new_source.release();
sourceDataProvider->load();
sources_.push_back(
std::make_unique<Source>(
std::make_unique<source>(
SourceConstructor{.name = name, .sourceDataProvider = sourceDataProvider}
)
);
@ -103,21 +103,20 @@ void Mirai::editSource(
)
{
auto source = getSourceById(id);
source->setName(name);
source->setColor(color);
source->set_name(name);
source->set_color(color);
DataProvider *sourceDataProvider = source->dataProvider();
data_provider *sourceDataProvider = source->data_provider();
saveConfig();
sourceEdited.emit(nullptr);
}
void Mirai::deleteSource(int id)
{
auto source = getSourceById(id);
sources_.erase(
std::remove_if(
sources_.begin(), sources_.end(),
[&](const std::unique_ptr<Source> &source) {
[&](const std::unique_ptr<source> &source) {
return source->id == id;
}
),
@ -136,47 +135,47 @@ void Mirai::unloadAllSources()
void Mirai::save()
{
for (auto &source : sources_) {
if (source->isDirty()) {
if (source->is_dirty()) {
source->save();
}
}
}
std::vector<std::unique_ptr<Source>> &Mirai::getSources()
std::vector<std::unique_ptr<source>> &Mirai::getSources()
{
return sources_;
}
Source *Mirai::getSourceById(int id)
source *Mirai::getSourceById(int id)
{
auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
return source->id == id;
});
assert(source != sources_.end()); // This should not happen
if (source == sources_.end()) {
assert(source_found != sources_.end()); // This should not happen
if (source_found == sources_.end()) {
return nullptr;
}
return source->get();
return source_found->get();
}
Source *Mirai::getSourceByName(const std::string &name)
source *Mirai::getSourceByName(const std::string &name)
{
auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
return source->name() == name;
});
assert(source != sources_.end()); // This should not happen
if (source == sources_.end()) {
assert(source_found != sources_.end()); // This should not happen
if (source_found == sources_.end()) {
return nullptr;
}
return source->get();
return source_found->get();
}
void Mirai::onSourceAdded(std::function<void(Source *)> f)
void Mirai::onSourceAdded(std::function<void(source *)> f)
{
sourceAdded.registerCallback(f);
}
void Mirai::onSourceEdited(std::function<void(Source *)> f)
void Mirai::onSourceEdited(std::function<void(source *)> f)
{
sourceEdited.registerCallback(f);
}

76
external/mirai-core/src/Source.cpp vendored
View file

@ -16,20 +16,20 @@
namespace mirai
{
void Source::save()
void source::save()
{
data->save();
}
void Source::createTask(const createTaskParams &task)
void source::create_task(const createTaskParams &task)
{
std::optional<int> dayId = std::nullopt;
std::optional<int> eventId = std::nullopt;
if (!task.event.has_value() && task.date.has_value()) {
auto day = data->getDayByDate(task.date.value());
auto day = data->get_day_by_date(task.date.value());
if (!day.has_value() && task.date.has_value()) {
day = data->insertDay({.id = generateUniqueId(), .date = task.date.value()});
day = data->insert_day({.id = generateUniqueId(), .date = task.date.value()});
}
dayId = day->id;
}
@ -38,7 +38,7 @@ void Source::createTask(const createTaskParams &task)
eventId = task.event.value().id();
}
data->insertTask({
data->insert_task({
.id = generateUniqueId(),
.title = task.title,
.state = TODO,
@ -47,34 +47,34 @@ void Source::createTask(const createTaskParams &task)
});
};
std::vector<Day> Source::getDays()
std::vector<Day> source::get_days()
{
auto daysData = data->getDays();
auto daysData = data->get_days();
std::vector<Day> days;
std::transform(
daysData.begin(), daysData.end(), std::back_inserter(days), [&](const DayData &dayData) {
daysData.begin(), daysData.end(), std::back_inserter(days), [&](const day_data &dayData) {
return Day{data, dayData};
}
);
return days;
}
std::optional<Day> Source::getDayByDate(Date date)
std::optional<Day> source::get_day_by_date(Date date)
{
auto day = data->getDayByDate(date);
auto day = data->get_day_by_date(date);
if (!day.has_value()) {
return std::nullopt;
}
return Day{data, day.value()};
}
void Source::createEvent(const createEventParams &eventToCreate)
void source::create_event(const createEventParams &eventToCreate)
{
std::optional<int> dayId = std::nullopt;
auto day = data->getDayByDate(eventToCreate.date);
auto day = data->get_day_by_date(eventToCreate.date);
if (!day.has_value()) {
day = data->insertDay({.id = generateUniqueId(), .date = eventToCreate.date});
day = data->insert_day({.id = generateUniqueId(), .date = eventToCreate.date});
dayId = day->id;
}
@ -87,28 +87,28 @@ void Source::createEvent(const createEventParams &eventToCreate)
});
};
std::optional<Event> Source::getEventById(int evendId)
std::optional<Event> source::get_event_by_id(int evendId)
{
auto event = data->getEventById(evendId);
auto event = data->get_event_by_id(evendId);
if (!event.has_value()) {
return std::nullopt;
}
return Event{data, event.value()};
}
void Source::removeEvent(const Event &event)
void source::remove_event(const Event &event)
{
data->removeEventById(event.id());
data->remove_event_by_id(event.id());
}
void Source::removeTask(const Task &task)
void source::remove_task(const Task &task)
{
data->removeTaskById(task.id());
data->remove_task_by_id(task.id());
}
std::optional<Task> Source::getTaskById(int taskId)
std::optional<Task> source::get_task_by_id(int taskId)
{
auto taskData = data->getTaskById(taskId);
auto taskData = data->get_task_by_id(taskId);
if (!taskData.has_value()) {
return std::nullopt;
}
@ -116,59 +116,59 @@ std::optional<Task> Source::getTaskById(int taskId)
return task;
}
std::vector<Task> Source::getTasks()
std::vector<Task> source::get_tasks()
{
auto tasksData = data->getTasks();
auto tasksData = data->get_tasks();
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) {
[&](const task_data &taskData) {
return Task{data, taskData};
}
);
return tasks;
}
std::vector<Task> Source::getUnscheduledTasks()
std::vector<Task> source::get_unscheduled_tasks()
{
auto tasksData = data->getTasksWithoutDate();
auto tasksData = data->get_tasks_without_date();
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) {
[&](const task_data &taskData) {
return Task{data, taskData};
}
);
return tasks;
}
std::string Source::name() const
std::string source::name() const
{
return name_;
return _name;
}
std::string Source::color() const
std::string source::color() const
{
return color_;
return _color;
}
void Source::setName(const std::string &name)
void source::set_name(const std::string &name)
{
name_ = name;
_name = name;
}
void Source::setColor(const std::string &color)
void source::set_color(const std::string &color)
{
color_ = color;
_color = color;
}
std::string Source::type() const
std::string source::type() const
{
// There is only 1 type for now
return type_;
return _type;
}
DataProvider *Source::dataProvider()
data_provider *source::data_provider()
{
return data;
}

18
external/mirai-core/src/Task.cpp vendored
View file

@ -29,7 +29,7 @@ std::string Task::title() const
return task_.title;
}
mirai::TaskState Task::state() const
mirai::task_state Task::state() const
{
return task_.state;
}
@ -51,40 +51,40 @@ bool Task::hasDate() const
void Task::setTitle(const std::string &newTitle)
{
data_->updateTask(id(), {.title = newTitle});
data_->update_task(id(), {.title = newTitle});
}
void Task::setDay(const Day &day)
{
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = day.id(), .eventId = emptyEventId});
data_->update_task(id(), {.dayId = day.id(), .eventId = emptyEventId});
}
void Task::setDate(const Date &date)
{
auto day = data_->getDayByDate(date);
auto day = data_->get_day_by_date(date);
if (!day.has_value()) {
day = data_->insertDay({.id = generateUniqueId(), .date = date});
day = data_->insert_day({.id = generateUniqueId(), .date = date});
}
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = day.value().id, .eventId = emptyEventId});
data_->update_task(id(), {.dayId = day.value().id, .eventId = emptyEventId});
}
void Task::unschedule()
{
auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = emptyId, .eventId = emptyId});
data_->update_task(id(), {.dayId = emptyId, .eventId = emptyId});
}
void Task::setEvent(const Event &event)
{
auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = emptyDayId, .eventId = event.id()});
data_->update_task(id(), {.dayId = emptyDayId, .eventId = event.id()});
}
void Task::setChecked(bool checked)
{
data_->updateTask(id(), {.state = checked ? DONE : TODO});
data_->update_task(id(), {.state = checked ? DONE : TODO});
}
} // namespace mirai

17
external/mirai-core/src/View.cpp vendored
View file

@ -63,8 +63,8 @@ void View::update()
auto todayDate = Date(std::chrono::system_clock::now());
for (int sourceId : sourcesIds_) {
Source *source = mirai_->getSourceById(sourceId);
for (auto day : source->getDays()) {
source *source = mirai_->getSourceById(sourceId);
for (auto day : source->get_days()) {
// day's tasks
auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) {
if (day.date() >= todayDate) {
@ -102,7 +102,7 @@ void View::update()
}
}
// unscheduled tasks
auto tasks = source->getUnscheduledTasks();
auto tasks = source->get_unscheduled_tasks();
unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end());
}
@ -119,17 +119,16 @@ void View::removeSources()
sourcesIds_.clear();
}
void View::addSource(const Source &source)
void View::addSource(const source &source)
{
sourcesIds_.push_back(source.id);
}
void View::setSources(const std::vector<Source> &sources)
void View::setSources(const std::vector<source> &sources)
{
sourcesIds_.clear();
std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
[](const Source &source) {
sources.begin(), sources.end(), std::back_inserter(sourcesIds_), [](const source &source) {
return source.id;
}
);
@ -141,13 +140,13 @@ void View::setAllSources()
sourcesIds_.clear();
std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
[](const std::unique_ptr<Source> &source) {
[](const std::unique_ptr<source> &source) {
return source->id;
}
);
}
bool View::isSourceSelected(const Source &source) const
bool View::isSourceSelected(const source &source) const
{
for (auto &sourceId : sourcesIds_) {
if (sourceId == source.id) {