/*
 * Copyright (C) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef HDC_SERIAL_STRUCT_H
#define HDC_SERIAL_STRUCT_H
#include "common.h"
#include "serial_struct_define.h"
#include "transfer.h"

namespace Hdc {
namespace SerialStruct {
    constexpr int fieldOne = 1;
    constexpr int fieldTwo = 2;
    constexpr int fieldThree = 3;
    constexpr int fieldFour = 4;
    constexpr int fieldFive = 5;
    constexpr int fieldSix = 6;
    constexpr int fieldSeven = 7;
    constexpr int fieldEight = 8;
    constexpr int fieldNine = 9;
    constexpr int fieldTen = 10;
    constexpr int field11 = 11;
    constexpr int field12 = 12;
    constexpr int field13 = 13;

    template<> struct Descriptor<Hdc::HdcTransferBase::TransferConfig> {
        static auto type()
        {
            return Message(Field<fieldOne, &Hdc::HdcTransferBase::TransferConfig::fileSize>("fileSize"),
                           Field<fieldTwo, &Hdc::HdcTransferBase::TransferConfig::atime>("atime"),
                           Field<fieldThree, &Hdc::HdcTransferBase::TransferConfig::mtime>("mtime"),
                           Field<fieldFour, &Hdc::HdcTransferBase::TransferConfig::options>("options"),
                           Field<fieldFive, &Hdc::HdcTransferBase::TransferConfig::path>("path"),
                           Field<fieldSix, &Hdc::HdcTransferBase::TransferConfig::optionalName>("optionalName"),
                           Field<fieldSeven, &Hdc::HdcTransferBase::TransferConfig::updateIfNew>("updateIfNew"),
                           Field<fieldEight, &Hdc::HdcTransferBase::TransferConfig::compressType>("compressType"),
                           Field<fieldNine, &Hdc::HdcTransferBase::TransferConfig::holdTimestamp>("holdTimestamp"),
                           Field<fieldTen, &Hdc::HdcTransferBase::TransferConfig::functionName>("functionName"),
                           Field<field11, &Hdc::HdcTransferBase::TransferConfig::clientCwd>("clientCwd"),
                           Field<field12, &Hdc::HdcTransferBase::TransferConfig::reserve1>("reserve1"),
                           Field<field13, &Hdc::HdcTransferBase::TransferConfig::reserve2>("reserve2"));
        }
    };

    template<> struct Descriptor<Hdc::HdcTransferBase::FileMode> {
        static auto type()
        {
            return Message(Field<fieldOne, &Hdc::HdcTransferBase::FileMode::perm>("perm"),
                           Field<fieldTwo, &Hdc::HdcTransferBase::FileMode::uId>("uId"),
                           Field<fieldThree, &Hdc::HdcTransferBase::FileMode::gId>("gId"),
                           Field<fieldFour, &Hdc::HdcTransferBase::FileMode::context>("context"),
                           Field<fieldFive, &Hdc::HdcTransferBase::FileMode::fullName>("fullName"));
        }
    };

    template<> struct Descriptor<Hdc::HdcTransferBase::TransferPayload> {
        static auto type()
        {
            return Message(Field<fieldOne, &Hdc::HdcTransferBase::TransferPayload::index>("index"),
                           Field<fieldTwo, &Hdc::HdcTransferBase::TransferPayload::compressType>("compressType"),
                           Field<fieldThree, &Hdc::HdcTransferBase::TransferPayload::compressSize>("compressSize"),
                           Field<fieldFour, &Hdc::HdcTransferBase::TransferPayload::uncompressSize>("uncompressSize"));
        }
    };

    template<> struct Descriptor<Hdc::HdcSessionBase::SessionHandShake> {
        static auto type()
        {
            return Message(Field<fieldOne, &Hdc::HdcSessionBase::SessionHandShake::banner>("banner"),
                           Field<fieldTwo, &Hdc::HdcSessionBase::SessionHandShake::authType>("authType"),
                           Field<fieldThree, &Hdc::HdcSessionBase::SessionHandShake::sessionId>("sessionId"),
                           Field<fieldFour, &Hdc::HdcSessionBase::SessionHandShake::connectKey>("connectKey"),
                           Field<fieldFive, &Hdc::HdcSessionBase::SessionHandShake::buf>("buf"),
                           Field<fieldSix, &Hdc::HdcSessionBase::SessionHandShake::version>("version"));
        }
    };

    template<> struct Descriptor<Hdc::HdcSessionBase::PayloadProtect> {
        static auto type()
        {
            return Message(Field<fieldOne, &Hdc::HdcSessionBase::PayloadProtect::channelId>("channelId"),
                           Field<fieldTwo, &Hdc::HdcSessionBase::PayloadProtect::commandFlag>("commandFlag"),
                           Field<fieldThree, &Hdc::HdcSessionBase::PayloadProtect::checkSum>("checkSum"),
                           Field<fieldFour, &Hdc::HdcSessionBase::PayloadProtect::vCode>("vCode"));
        }
    };

    template<> struct Descriptor<Hdc::HdcSessionBase::HeartbeatMsg> {
        static auto type()
        {
            return Message(
                Field<fieldOne, &Hdc::HdcSessionBase::HeartbeatMsg::heartbeatCount>("heartbeatCount"),
                Field<fieldTwo, &Hdc::HdcSessionBase::HeartbeatMsg::reserved>("reserved"));
        }
    };
}  // SerialStruct
}  // Hdc
#endif  // HDC_SERIAL_STRUCT_H