カテゴリー: C++

#include <sys/stat.h>

string getCreationTime(const char* filePath) {
    struct stat attr;
    if (stat(filePath, &attr) == -1) {
        return "";
    }

    char buffer[16];
    strftime(buffer, sizeof(buffer), "%y%m%d_%H%M%S", localtime(&attr.st_birthtimespec.tv_sec));

    return buffer;
}

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <nlohmann/json.hpp>

using namespace std;
using json = nlohmann::json;

int main() {
    ifstream ifs("test.md");
    string line;
    vector<string> user_messages;
    vector<string> assistant_messages;
    bool is_user = false;
    string assistant_msg;
    string user_msg;

    cout << "初期化通過" << endl;

    while (getline(ifs, line)) {
        cout << "while通過" << endl;

        if (line.empty()) {
            if (is_user) {
                is_user = false;
            }
            cout << "empty通過" << endl;
        } else if (line[0] == '>') { // user
            if (assistant_msg != ""){
                assistant_messages.push_back(assistant_msg);
                cout << "assistantベクター追加" << endl;
                assistant_msg = "";
            }

            is_user = true;
            cout << "user : " << line.substr(2) << endl;
            string user_msg = line.substr(2) + "\n";
            user_messages.push_back(user_msg);
        } else {
            if (is_user) {
                cout << "user2行目以降 : " << line << endl;
                user_msg += line + "\n";
                cout << "user文字列追加" << endl;

            } else {
                if (user_msg != ""){
                    user_messages.push_back(user_msg);
                    cout << "userベクター追加" << endl;
                    user_msg = "";
                }

                cout << "assistant : " << line << endl;
                assistant_msg += line + "\n";
                cout << "assistant文字列追加" << endl;
            }
        }
    }
    assistant_messages.push_back(assistant_msg);
    cout << "assistantベクター最終追加" << endl;

    cout << "getline通過" << endl;

    json root;
    json messages = json::array();
    for (int i = 0; i < user_messages.size(); i++) {
        json message;
        message["content"] = user_messages[i];
        message["role"] = "user";
        messages.push_back(message);
        message["content"] = assistant_messages[i];
        message["role"] = "assistant";
        messages.push_back(message);
    }
    root["messages"] = messages;
    root["model"] = "gpt-3.5-turbo";
    root["temperature"] = 0.0;

    ofstream ofs("output.json");
    ofs << root.dump(4);

    return 0;
}

#include <iostream>
#include <string>
#include <codecvt>

void convertCB(Fl_Widget*, void*) {
    std::stringstream unicode;
    const char* chr = convertInput -> value();

    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
    std::wstring unicode_str = converter.from_bytes(chr);
    for (wchar_t c : unicode_str) {
        unicode << std::hex << std::uppercase << static_cast<int>(c) << " ";
    }

    browser->add((unicode.str()).c_str());
}

void convertCB(Fl_Widget*, void*) {
    std::stringstream unicode;
    const char* chr = convertInput -> value();
    for (int i = 0; chr[i] != '\0'; i++) {
        unicode << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (int)chr[i];
    }

    browser->add((unicode.str()).c_str());
}

// 最新回答contentをoutputに表示
Fl_Text_Buffer* buffer = new Fl_Text_Buffer();
output -> buffer(buffer);
buffer -> append(content0.c_str());
buffer -> append("\n");             // ここが余計だった
output -> wrap_mode(Fl_Text_Display::WRAP_AT_BOUNDS, 5);

namespace fs = std::filesystem;

void moveFile(fs::path srcDir, fs::path destDir, const char* str){
    try {
        // 移動元のディレクトリ内のファイルを順に処理
        for (const auto& entry : fs::directory_iterator(srcDir)) {
            // ファイル名にstrを含む場合は移動
            if (entry.path().filename().string().find(str) != std::string::npos) {
                fs::rename(entry.path(), destDir / entry.path().filename());
                std::cout << entry.path() << "を移動しました。" << std::endl;
            }
        }
    } catch (const std::filesystem::filesystem_error& e) {
        std::cerr << "ファイルの移動に失敗しました。" << std::endl;
        std::cerr << e.what() << std::endl;
        return;
    }
    
}

void removeFile(fs::path dirPath, string str){
     try {
        // ディレクトリ内のファイルを順に処理
        for (const auto& entry : fs::directory_iterator(dirPath)) {
            // ファイル名にstrを含む場合は削除
            if (entry.path().filename().string().find(str) != std::string::npos) {
                fs::remove(entry.path());
                std::cout << entry.path() << "を削除しました。" << std::endl;
            }
        }
    } catch (const std::filesystem::filesystem_error& e) {
        std::cerr << "ファイルの削除に失敗しました。" << std::endl;
        std::cerr << e.what() << std::endl;
        return;
    }
}

// データを描画する関数
void draw_data(cairo_t* cr, vector<vector<double>> data, double x_min, double x_max, double y_min, double y_max, double width, double height) {
    // 背景色を白に設定
    cairo_set_source_rgb(cr, 1, 1, 1);
    cairo_paint(cr);

    // 折れ線の幅を設定
    cairo_set_line_width(cr, 2);

    // グラフの周囲に20pixelの余白を設ける
    double x_margin = 20;
    double y_margin = 20;

    // 7*24時間より前のデータを削除
    time_t current_time = time(NULL);
    time_t threshold_time = current_time - 7 * 24 * 3600;
    vector<vector<double>> filtered_data;
    for (int i = 0; i < data.size(); i++) {
        if (data[i][0] >= threshold_time) {
            filtered_data.push_back(data[i]);
        }
    }
    data = filtered_data;

    // x_minをx_maxの7*24時間前とする
    x_min = x_max - 7 * 24 * 3600;

    // x軸とy軸のスケールを計算
    double x_scale = (width - 2 * x_margin) / (x_max - x_min);
    double y_scale = (height - 2 * y_margin) / 30;

    // x軸の描画と目盛り
    cairo_set_source_rgb(cr, 0, 0, 0); // 黒色に設定
    cairo_move_to(cr, x_margin, height - y_margin);
    cairo_line_to(cr, width - x_margin, height - y_margin);
    cairo_stroke(cr);

    cairo_select_font_face(cr, "Arial", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
    cairo_set_font_size(cr, 10);

    int num_ticks = 7; // 1目盛り24時間
    double x_tick_interval = (x_max - x_min) / num_ticks;
    for (int i = 0; i <= num_ticks; i++) {
        double x = x_margin + i * x_tick_interval * x_scale;
        cairo_set_source_rgb(cr, 0.5, 0.5, 0.5); // 灰色に設定
        cairo_move_to(cr, x, height - y_margin + 5);
        cairo_line_to(cr, x, y_margin);
        cairo_set_line_width(cr, 0.5);
        cairo_stroke(cr);

        time_t t = x_min + i * x_tick_interval;
        struct tm* timeinfo = localtime(&t);
        char buffer[80];
        strftime(buffer, 80, "%H:%M", timeinfo); // hh:mm形式に変更
        cairo_text_extents_t extents;
        cairo_text_extents(cr, buffer, &extents);
        cairo_move_to(cr, x - extents.width / 2, height - y_margin + 15);
        cairo_set_source_rgb(cr, 0, 0, 0); // 黒色に設定
        cairo_show_text(cr, buffer);
    }

    // y軸の描画と目盛り
    int num_ticksY = 6;
    cairo_set_source_rgb(cr, 0, 0, 0); // 描画色を黒色に設定します
    cairo_move_to(cr, x_margin, height - y_margin); // 描画開始位置を指定します
    cairo_line_to(cr, x_margin, y_margin); // 描画終了位置を指定します
    cairo_set_line_width(cr, 1);
    cairo_stroke(cr); // 描画を行います

    // y軸の目盛りに関する設定を行います
    double y_tick_interval = 5; // 目盛りの間隔を指定します
    for (int i = 0; i <= num_ticksY; i++) { // 目盛りの数だけループします
        double y = height - y_margin - i * y_tick_interval * y_scale; // 目盛りの位置を計算します
        cairo_move_to(cr, x_margin, y); // 描画開始位置を指定します
        cairo_line_to(cr, x_margin - 5, y); // 描画終了位置を指定します
        cairo_set_line_width(cr, 0.5);
        cairo_stroke(cr); // 描画を行います

        char buffer[80]; // 文字列を格納するためのバッファを用意します
        sprintf(buffer, "%d", i * 5); // 目盛りの値を文字列に変換します
        cairo_text_extents_t extents; // テキストの描画範囲を格納するための変数を用意します
        cairo_text_extents(cr, buffer, &extents); // テキストの描画範囲を計算します
        cairo_move_to(cr, x_margin - extents.width - 10, y + extents.height / 2); // テキストの描画位置を指定します
        cairo_show_text(cr, buffer); // テキストを描画します
    }

    // X2軸の描画
    cairo_set_source_rgb(cr, 0.5, 0.5, 0.5); // 灰色に設定
    cairo_set_line_width(cr, 0.5);
    cairo_move_to(cr, x_margin, y_margin);
    cairo_line_to(cr, width - x_margin, y_margin);
    cairo_stroke(cr);

    // Y2軸の描画
    cairo_set_source_rgb(cr, 0.5, 0.5, 0.5); // 灰色に設定
    cairo_set_line_width(cr, 0.5);
    cairo_move_to(cr, width - x_margin, height - y_margin);
    cairo_line_to(cr, width - x_margin, y_margin);
    cairo_stroke(cr);

    // 折れ線を描画
    cairo_set_source_rgb(cr, 1, 0, 1); // マゼンタに設定
    cairo_set_line_width(cr, 1);
    cairo_move_to(cr, x_margin, height - y_margin - (data[0][1]) * y_scale);
    for (int i = 1; i < data.size(); i++) {
        double x = x_margin + (data[i][0] - x_min) * x_scale;
        double y = height - y_margin - (data[i][1]) * y_scale;
        cairo_line_to(cr, x, y);
    }
    cairo_stroke(cr);

    // yの最大値と最小値の表示
    cairo_select_font_face(cr, "Arial", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
    cairo_set_font_size(cr, 12);
    char buffer[80];
    sprintf(buffer, "y_min: %.2f", y_min);
    cairo_text_extents_t extents;
    cairo_text_extents(cr, buffer, &extents);
    cairo_move_to(cr, x_margin + 5, height - y_margin - y_min * y_scale);
    cairo_set_source_rgb(cr, 0, 0.5, 0); // 濃緑に設定
    cairo_show_text(cr, buffer);

    sprintf(buffer, "y_max: %.2f", y_max);
    cairo_text_extents(cr, buffer, &extents);
    cairo_move_to(cr, x_margin + 5, height - y_margin - y_max * y_scale);
    cairo_set_source_rgb(cr, 0, 0.5, 0); // 濃緑に設定
    cairo_show_text(cr, buffer);
}

// Set up a curl session
    CURL* curl = curl_easy_init();
    if (curl) {
        // Set the request options
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, requestData.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &responseData);

        // Set timeout options
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 120L); // 120秒でタイムアウト
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 120L);

        // Send the request
        CURLcode res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << endl;

            Fl_Text_Buffer* bufferError = new Fl_Text_Buffer();
            bufferError -> text(curl_easy_strerror(res));
            noticeDisplay -> buffer(bufferError);
            noticeDisplay -> wrap_mode(Fl_Text_Display::WRAP_AT_BOUNDS, 5);

            return {};
        }

        // Clean up
        curl_easy_cleanup(curl);

    } else {
        cerr << "curl_easy_init() failed" << endl;

        const char* error = "curl_easy_init() failed";
        Fl_Text_Buffer* bufferError = new Fl_Text_Buffer();
        bufferError -> text(error);
        noticeDisplay -> buffer(bufferError);
        noticeDisplay -> wrap_mode(Fl_Text_Display::WRAP_AT_BOUNDS, 5);

        return {};
    }