socket_server/transfer.cpp at master · PIesy/socket_server · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include "transfer.h"
#include "helpers.h"
#include <iostream>
#include <thread>
#include <chrono>

Transfer::Transfer() {}

Transfer::Transfer(const TransferFunction& recieve, const TransferFunction& send)
{
    this->recieve = recieve;
    this->send = send;
}

Transfer::~Transfer()
{
    End();
}

void Transfer::setRecieveFunction(const TransferFunction& recieve)
{
    this->recieve = recieve;
}

void Transfer::setSendFunction(const TransferFunction& send)
{
    this->send = send;
}

OperationResult Transfer::Start(TransferType type, size_t size, bool needsConfirmation)
{
    if (transferFinished)
    {
        this->type = type;
        transferFinished = false;
        confirmed = !needsConfirmation;
        transferSize = size;
        return OperationResult::Success;
    }
    return OperationResult::Error;
}

OperationResult Transfer::Start(TransferType type, size_t size, const ConfirmCondition& condition)
{
    if (transferFinished && confirmed)
    {
        this->type = type;
        transferFinished = false;
        confirmed = false;
        transferSize = size;
        confirmCondition = condition;
        return OperationResult::Success;
    }
    return OperationResult::Error;
}

OperationResult Transfer::Execute(Buffer& buff)
{
    if (transferFinished && confirmed)
        return OperationResult::Success;
    OperationResult result = OperationResult::Error;

    if (!transferFinished)
    {
        switch (type)
        {
        case TransferType::None:
            result = OperationResult::Success;
            break;
        case TransferType::Send:
            result = send(buff, transferSize - buff.getReadOffset());
            break;
        case TransferType::Recieve:
            result = recieve(buff, transferSize - buff.getWriteOffset());
            break;
        }
    }
    if (result == OperationResult::Success && !transferFinished)
        transferFinished = true;
    if (confirmCondition && transferFinished && !confirmed)
        confirmed = !confirmCondition(buff);
    if (transferFinished && !confirmed)
    {
        if ((result = confirm()) == OperationResult::Success)
            confirmed = true;
        else
        {
            std::cerr << "Confirmation error" << std::endl;
            End();
            buff.Clear();
        }
    }
    return result;
}

OperationResult Transfer::confirm()
{
    ServerResponcePackage responce(helpers::integral(ServerResponce::Success));
    Buffer buff(&responce);
    if (type == TransferType::Recieve)
        return send(buff, 1);
    //std::cerr << "Waiting for confirmation" << std::endl;
    if (recieve(buff, 1) != OperationResult::Success)
        return OperationResult::Error;
    return OperationResult::Success;
}

void Transfer::End(bool resetClient)
{
    if (resetClient)
    {
        ServerResponcePackage responce(helpers::integral(ServerResponce::Reset));
        Buffer buff(&responce);
        if (!transferFinished)
            send(buff, 1);
    }
    transferFinished = true;
    confirmed = true;
}