#pragma once

#include <iostream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define SIZE 1024

#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4

#define Screen 1
#define Onefile 2
#define Classfile 3

#define LogFile "log.txt"
class Log
{
public:
    Log()
    {
        printMethod = Screen;
        path = "./log/";
    }
    void Enable(int method)
    {
        printMethod = method;
    }
    std::string levelToString(int level)
    {
        switch (level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Warning:
            return "Warning";
        case Error:
            return "Error";
        case Fatal:
            return "Fatal";
        default:
            return "None";
        }
    }

    // void logmessage(int level， const char *format， ...)
    // {
    //     time_t t = time(nullptr);
    //     struct tm *ctime = localtime(&t);
    //     char leftbuffer[SIZE];
    //     snprintf(leftbuffer， sizeof(leftbuffer)， "[%s][%d-%d-%d %d:%d:%d]"， levelToString(level).c_str()，
    //              ctime->tm_year + 1900， ctime->tm_mon + 1， ctime->tm_mday，
    //              ctime->tm_hour， ctime->tm_min， ctime->tm_sec);

    //     // va_list s;
    //     // va_start(s， format);
    //     char rightbuffer[SIZE];
    //     vsnprintf(rightbuffer， sizeof(rightbuffer)， format， s);
    //     // va_end(s);

    //     // 格式：默認(rèn)部分+自定義部分
    //     char logtxt[SIZE * 2];
    //     snprintf(logtxt， sizeof(logtxt)， "%s %s\n"， leftbuffer， rightbuffer);

    //     // printf("%s"， logtxt); // 暫時(shí)打印
    //     printLog(level， logtxt);
    // }
    void printLog(int level， const std::string &logtxt)
    {
        switch (printMethod)
        {
        case Screen:
            std::cout << logtxt << std::endl;
            break;
        case Onefile:
            printOneFile(LogFile， logtxt);
            break;
        case Classfile:
            printClassFile(level， logtxt);
            break;
        default:
            break;
        }
    }
    void printOneFile(const std::string &logname， const std::string &logtxt)
    {
        std::string _logname = path + logname;
        int fd = open(_logname.c_str()， O_WRONLY | O_CREAT | O_APPEND， 0666); // "log.txt"
        if (fd < 0)
            return;
        write(fd， logtxt.c_str()， logtxt.size());
        close(fd);
    }
    void printClassFile(int level， const std::string &logtxt)
    {
        std::string filename = LogFile;
        filename += ".";
        filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"
        printOneFile(filename， logtxt);
    }

    ~Log()
    {
    }
    void operator()(int level， const char *format， ...)
    {
        time_t t = time(nullptr);
        struct tm *ctime = localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer， sizeof(leftbuffer)， "[%s][%d-%d-%d %d:%d:%d]"， levelToString(level).c_str()，
                 ctime->tm_year + 1900， ctime->tm_mon + 1， ctime->tm_mday，
                 ctime->tm_hour， ctime->tm_min， ctime->tm_sec);

        va_list s;
        va_start(s， format);
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer， sizeof(rightbuffer)， format， s);
        va_end(s);

        // 格式：默認(rèn)部分+自定義部分
        char logtxt[SIZE * 2];
        snprintf(logtxt， sizeof(logtxt)， "%s %s"， leftbuffer， rightbuffer);

        // printf("%s"， logtxt); // 暫時(shí)打印
        printLog(level， logtxt);
    }

private:
    int printMethod;
    std::string path;
};

// int sum(int n， ...)
// {
//     va_list s; // char*
//     va_start(s， n);

//     int sum = 0;
//     while(n)
//     {
//         sum += va_arg(s， int); // printf("hello %d， hello %s， hello %c， hello %d，"， 1， "hello"， 'c'， 123);
//         n--;
//     }

//     va_end(s); //s = NULL
//     return sum;
// }
Log lg; // 命令對(duì)象 用來打印日志信息

#pragma once
//寫一個(gè)套接字的小組件 這樣我們未來就可以直接用
#include <iostream>
#include <string>
#include <unistd.h>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include "Log.hpp"

enum {
    SocketError = 1，
    BindError =2，
    ListenError = 3，
    AcceptError = 4
};
const int defaultbacklog = 10;//監(jiān)聽隊(duì)列默認(rèn)長度
class Sock
{
public:
    Sock(){}
    ~Sock(){}
    void Socket()//創(chuàng)建套接字
    {
        _sockfd = socket(AF_INET， SOCK_STREAM， 0);
        if (_sockfd<0)
        {
            lg(Fatal，"socket error，%s:%d"，strerror(errno)，errno);
            exit(SocketError);
        }
    }
    void Bind(uint16_t port)//綁定套接字
    {
        struct sockaddr_in addr;
        bzero(&addr， sizeof(struct sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = INADDR_ANY;
        if(bind(_sockfd， (struct sockaddr*)&addr， sizeof(addr))<0)
        {
            lg(Fatal，"bind error，%s:%d"，strerror(errno)，errno);
            exit(BindError);
        }
    }
    void Listen(int backlog=defaultbacklog)//監(jiān)聽套接字
    {
        if(listen(_sockfd， backlog)<0)
        {
            lg(Fatal，"listen error，%s:%d"，strerror(errno)，errno);
            exit(ListenError);
        }
    }

    int Accept(std::string *clientip，uint16_t *clientport)//接受套接字并把客戶端的ip和端口返回（輸出型參數(shù)）
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int connfd = accept(_sockfd， (struct sockaddr*)&client， &len);
        if(connfd<0)
        {
            lg(Error，"accept error，%s:%d"，strerror(errno)，errno);//如果接受失敗 打印錯(cuò)誤信息并退出程序
            exit(AcceptError);
        }
         char ipstr[64];
        inet_ntop(AF_INET， &client.sin_addr，ipstr， sizeof(ipstr));
        *clientip = ipstr;
        *clientport = ntohs(client.sin_port);
        lg(Info，"accept a client %s:%d"，*clientip，*clientport);//表示接受成功了并打印客戶端的ip和端口
        return connfd;
    }
    int GetSockfd()//獲取套接字
    {
        return _sockfd;
    }
    void Close()//關(guān)閉套接字
    {
        close(_sockfd);
    }
    bool Connect(const std::string &ip，const uint16_t &port)//連接套接字
    {
        struct sockaddr_in addr;
        bzero(&addr， sizeof(struct sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        inet_pton(AF_INET， ip.c_str()， &addr.sin_addr) ;//將ip地址轉(zhuǎn)換為網(wǎng)絡(luò)字節(jié)序
        if(connect(_sockfd， (struct sockaddr*)&addr， sizeof(addr))<0)
        {
            lg(Warning，"connect error，%s:%d"，strerror(errno)，errno);
            return false;
        }
        return true;
    }

private:
    int _sockfd;
};

#pragma once
#include <functional>
#include <signal.h>
#include "Socket.hpp"

using func_t = std::function<std::string(std::string &package)>; // 回調(diào)函數(shù)

class TcpServer
{
public:
    TcpServer(uint16_t port， func_t callback) : _port(port)， _callback(callback)， _isrunning(false)
    {
    }
    ~TcpServer() {}

    void InitServer()
    {
        _listensock.Socket();
        _listensock.Bind(_port);
        _listensock.Listen(10);
        lg(Info， "Server is running on port %d"， _port); // 看看服務(wù)器在哪個(gè)端口上運(yùn)行
    }
    void Start() // 啟動(dòng)服務(wù)器
    {
        _isrunning = true;
        signal(SIGCHLD， SIG_IGN); // 忽略子進(jìn)程結(jié)束信號(hào) 因?yàn)樽舆M(jìn)程結(jié)束時(shí)會(huì)產(chǎn)生SIGCHLD信號(hào)
        signal(SIGPIPE， SIG_IGN); // 忽略管道錯(cuò)誤信號(hào) 因?yàn)楫?dāng)網(wǎng)絡(luò)連接中某個(gè)套接字被關(guān)閉或者重啟時(shí)，該套接字已經(jīng)發(fā)送緩沖區(qū)中的數(shù)據(jù)都發(fā)送完畢了，但是它仍然可以接收數(shù)據(jù) 此時(shí)該套接字就會(huì)產(chǎn)生SIGPIPE信號(hào)
        while (_isrunning)
        {
            std::string clientip;
            uint16_t clientport;
            int sockfd = _listensock.Accept(&clientip， &clientport); // 接受客戶端連接并返回套接字描述符
            if (sockfd < 0)
                continue;       // 連接失敗就繼續(xù)嘗試重連
            pid_t pid = fork(); // 創(chuàng)建子進(jìn)程 幫助我們處理每個(gè)客戶端的請(qǐng)求
            if (pid < 0)        // 出錯(cuò)
            {
                lg(Error， "Fork error");
                continue;
            }
            if (pid == 0) // 子進(jìn)程
            {
                _listensock.Close();          // 關(guān)閉監(jiān)聽套接字 防止accept阻塞
                std::string inbuffer_stream; // 用來獲取客戶端發(fā)來的所有數(shù)據(jù)
                while (true)
                {
                    char buffer[1024];
                    ssize_t n = read(sockfd， buffer， sizeof(buffer)); // 讀取客戶端數(shù)據(jù)
                    if (n == 0)                                       // 客戶端斷開了
                    {
                        lg(Info， "Client %s:%d disconnected"， clientip.c_str()， clientport);
                        break;
                    }
                    if (n < 0) // 讀取出錯(cuò)
                    {
                        lg(Error， "Read error");
                        break;
                    }
                    // 拼接所有數(shù)據(jù)
                    buffer[n]=0;
                    inbuffer_stream+=buffer;
                    lg(Debug， "debug:\n%s"， inbuffer_stream.c_str());// 調(diào)試看看整個(gè)流的信息
                    //有可能一個(gè)流里面有多個(gè)報(bào)文，所以我們要循環(huán)去處理
                    while(1)
                    {
                        std::string info =_callback(inbuffer_stream);// 調(diào)用回調(diào)函數(shù)獲取服務(wù)端需要的數(shù)據(jù)
                        //看看剩余的報(bào)文信息
                        if(info.empty()) break;//說明讀不到完整報(bào)文了
                        lg(Debug， "debug:\n%s"， inbuffer_stream.c_str());// 調(diào)試看看整個(gè)流的信息
                        lg(Debug， "debug，response:\n%s"，info.c_str());// 調(diào)試看看發(fā)給客戶端數(shù)據(jù)
                        write(sockfd， info.c_str()， info.size()); // 發(fā)送數(shù)據(jù)給客戶端
                    }
                }
                exit(0); // 子進(jìn)程結(jié)束
            }
            close(sockfd); // 關(guān)閉套接字
        }
    }

private:
    uint16_t _port;   // 端口號(hào)
    Sock _listensock; // 監(jiān)聽套接字
    func_t _callback; // 回調(diào)函數(shù) 用來提供服務(wù)
    // ip模式是0
    bool _isrunning; // 是否運(yùn)行
};

#pragma once

#include <iostream>
#include <string>

// #define MySelf 1

const std::string blank_space_sep = " ";
const std::string protocol_sep = "\n";

std::string Encode(std::string &content)
{
    std::string package = std::to_string(content.size());
    package += protocol_sep;
    package += content;
    package += protocol_sep;

    return package;
}

// "len"\n"x op y"\nXXXXXX
// "protocolnumber"\n"len"\n"x op y"\nXXXXXX
bool Decode(std::string &package， std::string *content)
{
    std::size_t pos = package.find(protocol_sep);
    if(pos == std::string::npos) return false;
    std::string len_str = package.substr(0， pos);
    std::size_t len = std::stoi(len_str);
    // package = len_str + content_str + 2
    std::size_t total_len = len_str.size() + len + 2;
    if(package.size() < total_len) return false;

    *content = package.substr(pos+1， len);
    // earse 移除報(bào)文 package.erase(0， total_len);
    package.erase(0， total_len);

    return true;
}


// json， protobuf
class Request
{
public:
    Request(int data1， int data2， char oper) : _x(data1)， _y(data2)，_op(oper)
    {
    }
    Request()
    {}
public:
    bool Serialize(std::string *out)
    {
        // 構(gòu)建報(bào)文的有效載荷
        // struct => string， "x op y"
        std::string s = std::to_string(_x);
        s += blank_space_sep;
        s += _op;
        s += blank_space_sep;
        s += std::to_string(_y);
        *out = s;
        return true;
    }
    bool Deserialize(const std::string &in) // "x op y"
    {
        std::size_t left = in.find(blank_space_sep);
        if (left == std::string::npos)
            return false;
        std::string part_x = in.substr(0， left);

        std::size_t right = in.rfind(blank_space_sep);
        if (right == std::string::npos)
            return false;
        std::string part_y = in.substr(right + 1);

        if (left + 2 != right)
            return false;
        _op = in[left + 1];
        _x = std::stoi(part_x);
        _y = std::stoi(part_y);
        return true;
    }
    void DebugPrint()
    {
        std::cout << "新請(qǐng)求構(gòu)建完成:  " << _x << _op << _y << "=?" << std::endl;
    }
public:
    // x op y
    int _x;
    int _y;
    char _op; // + - * / %
};

class Response
{
public:
    Response(int res， int c) : _result(res)， _code(c)
    {
    }

    Response()
    {}
public:
    bool Serialize(std::string *out)
    {
        // "result code"
        // 構(gòu)建報(bào)文的有效載荷
        std::string s = std::to_string(_result);
        s += blank_space_sep;
        s += std::to_string(_code);
        *out = s;
        return true;
    }
    bool Deserialize(const std::string &in) // "result code"
    {
        std::size_t pos = in.find(blank_space_sep);
        if (pos == std::string::npos)
            return false;
        std::string part_left = in.substr(0， pos);
        std::string part_right = in.substr(pos+1);

        _result = std::stoi(part_left);
        _code = std::stoi(part_right);

        return true;

    }
    void DebugPrint()
    {
        std::cout << "結(jié)果響應(yīng)完成， result: " << _result << "， code: "<< _code << std::endl;
    }
public:
    int _result;
    int _code; // 0，可信，否則!0具體是幾，表明對(duì)應(yīng)的錯(cuò)誤原因
};

// 計(jì)算器服務(wù)

#include <iostream>
#include "Protocol.hpp" //協(xié)議頭文件 必須遵守

enum
{
    Div_Zero = 1，
    Mod_Zero = 2，
    Other_Oper = 3
};


class ServerCal
{
public:
    ServerCal() {}
    ~ServerCal() {}

Response Calhelper(const Request&req)
{
   Response resp(0，0);
   switch (req._op)
   {
   case '+':
       resp._result = req._x + req._y;
       break;
   case '-':
       resp._result = req._x - req._y;
       break;
   case '*':
       resp._result = req._x * req._y;
       break;
   case '/':
       if (req._y == 0) resp._code = Div_Zero;
       else resp._result = req._x / req._y;
       break;
   case '%':
       if (req._y == 0) resp._code = Mod_Zero;
       else resp._result = req._x % req._y;
       break;
   default:
       resp._code=Other_Oper;
       break;
   }
 return resp;
}

//設(shè)計(jì)一個(gè)回調(diào)方法 來幫助我們計(jì)算
std::string Cal(std::string package) //回調(diào)方法  到時(shí)傳過去
{
    std::string content;//返回的內(nèi)容
    bool r=Decode(package，&content);
    if(!r)  return "";//報(bào)文不完整
    //我們要將這個(gè)報(bào)文反序列化拿到數(shù)據(jù) 然后計(jì)算成respond 然后再序列化發(fā)給客戶端
    Request req;
    r=req.Deserialize(content); //"10 + 20 " ->
    if(!r) return ""; //解析失敗
    content=""; //清空再利用
    Response resp=Calhelper(req);
    resp.Serialize(&content);
    content=Encode(content);//把報(bào)頭加上去
    return content;
}

};

#include"ServerCal.hpp"
#include"TcpServer.hpp"

static void Usage(const std::string &proc)
{
    std::cout << "\nUsage: " << proc << " port\n" << std::endl; 
}

int main(int argc， char *argv[])//./servercal 8080
{
   if(argc != 2)
   {
       Usage(argv[0]);
       exit(0);
   }
   uint16_t port = atoi(argv[1]);
   ServerCal cal;//用來做計(jì)算請(qǐng)求的對(duì)象
   TcpServer *tsvp = new TcpServer(port，std::bind(&ServerCal::Cal， &cal， std::placeholders::_1));//bind
   tsvp->InitServer();
 // Daemon();
    daemon(0， 0);
   tsvp->Start();

   
   return 0;
}

#include <iostream>
#include <string>
#include <ctime>
#include <cassert>
#include <unistd.h>
#include "Socket.hpp"
#include "Protocol.hpp" //客戶端也得知道協(xié)議

static void Usage(const std::string &proc)
{
    std::cout << "\nUsage: " << proc << " serverip serverport\n"
              << std::endl;
}

//./client 127.0.0.1 8080
int main(int argc， char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        return -1;
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);
    Sock sockfd;
    sockfd.Socket();
    bool r=sockfd.Connect(serverip， serverport);//嘗試和服務(wù)端連接
    if(!r)
    {
        std::cout<<"連接失敗"<<std::endl;
        return -1;
    }
    //否則就是連接成功
    srand(time(nullptr) ^ getpid());
    int cnt = 1;
    const std::string opers = "+-*/%=-=&^";

    std::string inbuffer_stream;
    while(cnt <= 10)
    {
        std::cout << "===============第" << cnt << "次測試.....， " << "===============" << std::endl;
        int x = rand() % 100 + 1;
        usleep(1234);
        int y = rand() % 100;
        usleep(4321);
        char oper = opers[rand()%opers.size()];
        Request req(x， y， oper);
        req.DebugPrint();

        std::string package;
        req.Serialize(&package);

        package = Encode(package);

        write(sockfd.GetSockfd()， package.c_str()， package.size());
        // std::cout << "這是最新的發(fā)出去的請(qǐng)求: " << n << "\n" << package;
        // n = write(sockfd.Fd()， package.c_str()， package.size());
        // std::cout << "這是最新的發(fā)出去的請(qǐng)求: \n" << n << "\n" << package;
        // n = write(sockfd.Fd()， package.c_str()， package.size());
        // std::cout << "這是最新的發(fā)出去的請(qǐng)求: \n" << n << "\n" << package;
        // n = write(sockfd.Fd()， package.c_str()， package.size());
        // std::cout << "這是最新的發(fā)出去的請(qǐng)求: \n" << n << "\n" << package;


        char buffer[128];
        ssize_t n = read(sockfd.GetSockfd()， buffer， sizeof(buffer)); // 我們也無法保證我們能讀到一個(gè)完整的報(bào)文
        if(n > 0)
        {
            buffer[n] = 0;
            inbuffer_stream += buffer; // "len"\n"result code"\n
            std::cout << inbuffer_stream << std::endl;
            std::string content;
            bool r = Decode(inbuffer_stream， &content); // "result code"
            assert(r);

            Response resp;
            r = resp.Deserialize(content);
            assert(r);

            resp.DebugPrint();
        }

        std::cout << "=================================================" << std::endl;
        sleep(1);

        cnt++;
    }


    sockfd.Close();
    return 0;
}

#pragma once

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

const std::string nullfile = "/dev/null";

void Daemon(const std::string &cwd = "")
{
    // 1. 忽略其他異常信號(hào)
    signal(SIGCLD， SIG_IGN);
    signal(SIGPIPE， SIG_IGN);
    signal(SIGSTOP， SIG_IGN);

    // 2. 將自己變成獨(dú)立的會(huì)話
    if (fork() > 0)
        exit(0);
    setsid();

    // 3. 更改當(dāng)前調(diào)用進(jìn)程的工作目錄
    if (!cwd.empty())
        chdir(cwd.c_str());

    // 4. 標(biāo)準(zhǔn)輸入，標(biāo)準(zhǔn)輸出，標(biāo)準(zhǔn)錯(cuò)誤重定向至/dev/null
    int fd = open(nullfile.c_str()， O_RDWR);
    if(fd > 0)
    {
        dup2(fd， 0);
        dup2(fd， 1);
        dup2(fd， 2);
        close(fd);
    }
}

#include <iostream>
#include <jsoncpp/json/json.h>
#include <unistd.h>

// {a:120， b:"123"}
int main()
{
    Json::Value part1;
    part1["haha"] = "haha";
    part1["hehe"] = "hehe";


    Json::Value root;
    root["x"] = 100;
    root["y"] = 200;
    root["op"] = '+';
    root["desc"] = "this is a + oper";
    root["test"] = part1;

    //Json::FastWriter w;
    Json::StyledWriter w;
    std::string res = w.write(root);

    std::cout << res << std::endl;

    sleep(3);

    Json::Value v;
    Json::Reader r;
    r.parse(res， v);

    int x = v["x"].asInt();
    int y = v["y"].asInt();
    char op = v["op"].asInt();
    std::string desc = v["desc"].asString();
    Json::Value temp = v["test"];
    std::cout << x << std::endl;
    std::cout << y << std::endl;
    std::cout << op << std::endl;
    std::cout << desc << std::endl;



    return 0;
}

#pragma once

#include <iostream>
#include <string>
#include<jsoncpp/json/json.h>
// #define MySelf 1

const std::string blank_space_sep = " ";
const std::string protocol_sep = "\n";

std::string Encode(std::string &content)
{
    std::string package = std::to_string(content.size());
    package += protocol_sep;
    package += content;
    package += protocol_sep;

    return package;
}

// "len"\n"x op y"\nXXXXXX
// "protocolnumber"\n"len"\n"x op y"\nXXXXXX
bool Decode(std::string &package， std::string *content)
{
    std::size_t pos = package.find(protocol_sep);
    if(pos == std::string::npos) return false;
    std::string len_str = package.substr(0， pos);
    std::size_t len = std::stoi(len_str);
    // package = len_str + content_str + 2
    std::size_t total_len = len_str.size() + len + 2;
    if(package.size() < total_len) return false;

    *content = package.substr(pos+1， len);
    // earse 移除報(bào)文 package.erase(0， total_len);
    package.erase(0， total_len);

    return true;
}


// json， protobuf
class Request
{
public:
    Request(int data1， int data2， char oper) : _x(data1)， _y(data2)，_op(oper)
    {
    }
    Request()
    {}
public:
    bool Serialize(std::string *out)
    {
#ifdef MySelf
        // 構(gòu)建報(bào)文的有效載荷
        // struct => string， "x op y"
        std::string s = std::to_string(_x);
        s += blank_space_sep;
        s += _op;
        s += blank_space_sep;
        s += std::to_string(_y);
        *out = s;
        return true;
#else
        Json::Value root;
        root["x"] = _x;
        root["y"] = _y;
        root["op"] = _op;
        // Json::FastWriter w;
        Json::StyledWriter w;
        *out = w.write(root);
        return true;
#endif
    }
    bool Deserialize(const std::string &in) // "x op y"
    {
#ifdef MySelf
        std::size_t left = in.find(blank_space_sep);
        if (left == std::string::npos)
            return false;
        std::string part_x = in.substr(0， left);

        std::size_t right = in.rfind(blank_space_sep);
        if (right == std::string::npos)
            return false;
        std::string part_y = in.substr(right + 1);

        if (left + 2 != right)
            return false;
        _op = in[left + 1];
        _x = std::stoi(part_x);
        _y = std::stoi(part_y);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in， root);

        _x = root["x"].asInt();
        _y = root["y"].asInt();
        _op = root["op"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        std::cout << "新請(qǐng)求構(gòu)建完成:  " << _x << _op << _y << "=?" << std::endl;
    }
public:
    // x op y
    int _x;
    int _y;
    char _op; // + - * / %
};

class Response
{
public:
    Response(int res， int c) : _result(res)， _code(c)
    {
    }

    Response()
    {}
public:
    bool Serialize(std::string *out)
    {
  #ifdef MySelf
        // "result code"
        // 構(gòu)建報(bào)文的有效載荷
        std::string s = std::to_string(_result);
        s += blank_space_sep;
        s += std::to_string(_code);
        *out = s;
        return true;
#else
        Json::Value root;
        root["result"] = _result;
        root["code"] = _code;
        // Json::FastWriter w;
        Json::StyledWriter w;
        *out = w.write(root);
        return true;
#endif
    }
    bool Deserialize(const std::string &in) // "result code"
    {
#ifdef MySelf
        std::size_t pos = in.find(blank_space_sep);
        if (pos == std::string::npos)
            return false;
        std::string part_left = in.substr(0， pos);
        std::string part_right = in.substr(pos+1);

        _result = std::stoi(part_left);
        _code = std::stoi(part_right);

        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in， root);

        _result = root["result"].asInt();
        _code = root["code"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        std::cout << "結(jié)果響應(yīng)完成， result: " << _result << "， code: "<< _code << std::endl;
    }
public:
    int _result;
    int _code; // 0，可信，否則!0具體是幾，表明對(duì)應(yīng)的錯(cuò)誤原因
};

.PHONY:all
all:servercal clientcal

Flag=#-DMySelf=1
Lib=-ljsoncpp

servercal:ServerCal.cc
	g++ -o $@ $^ -std=c++11 $(Lib) $(Flag)
clientcal:ClientCal.cc
	g++ -o $@ $^ -std=c++11 -g $(Lib) $(Flag)


.PHONY:clean
clean:
	rm -f clientcal servercal