mirror of
https://github.com/Expand-sys/CCash
synced 2025-12-17 00:22:14 +11:00
932 lines
30 KiB
C++
932 lines
30 KiB
C++
//------------------------------------------------------------------------------
|
|
// Automatically generated by the Fast Binary Encoding compiler, do not modify!
|
|
// https://github.com/chronoxor/FastBinaryEncoding
|
|
// Source: user_model.fbe
|
|
// FBE version: 1.14.1.0
|
|
//------------------------------------------------------------------------------
|
|
|
|
#include "bank_dom_models.h"
|
|
|
|
namespace FBE {
|
|
|
|
FieldModel<::bank_dom::Transaction>::FieldModel(FBEBuffer& buffer, size_t offset) noexcept : _buffer(buffer), _offset(offset)
|
|
, counterparty(buffer, 4 + 4)
|
|
, receiving(buffer, counterparty.fbe_offset() + counterparty.fbe_size())
|
|
, amount(buffer, receiving.fbe_offset() + receiving.fbe_size())
|
|
, time(buffer, amount.fbe_offset() + amount.fbe_size())
|
|
{}
|
|
|
|
size_t FieldModel<::bank_dom::Transaction>::fbe_body() const noexcept
|
|
{
|
|
size_t fbe_result = 4 + 4
|
|
+ counterparty.fbe_size()
|
|
+ receiving.fbe_size()
|
|
+ amount.fbe_size()
|
|
+ time.fbe_size()
|
|
;
|
|
return fbe_result;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Transaction>::fbe_extra() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
|
|
size_t fbe_result = fbe_body()
|
|
+ counterparty.fbe_extra()
|
|
+ receiving.fbe_extra()
|
|
+ amount.fbe_extra()
|
|
+ time.fbe_extra()
|
|
;
|
|
|
|
_buffer.unshift(fbe_struct_offset);
|
|
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::Transaction>::verify(bool fbe_verify_type) const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return true;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
if (fbe_struct_size < (4 + 4))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_type = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4));
|
|
if (fbe_verify_type && (fbe_struct_type != fbe_type()))
|
|
return false;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
bool fbe_result = verify_fields(fbe_struct_size);
|
|
_buffer.unshift(fbe_struct_offset);
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::Transaction>::verify_fields(size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + counterparty.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!counterparty.verify())
|
|
return false;
|
|
fbe_current_size += counterparty.fbe_size();
|
|
|
|
if ((fbe_current_size + receiving.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!receiving.verify())
|
|
return false;
|
|
fbe_current_size += receiving.fbe_size();
|
|
|
|
if ((fbe_current_size + amount.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!amount.verify())
|
|
return false;
|
|
fbe_current_size += amount.fbe_size();
|
|
|
|
if ((fbe_current_size + time.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!time.verify())
|
|
return false;
|
|
fbe_current_size += time.fbe_size();
|
|
|
|
return true;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Transaction>::get_begin() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + 4 + 4) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
assert((fbe_struct_size >= (4 + 4)) && "Model is broken!");
|
|
if (fbe_struct_size < (4 + 4))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Transaction>::get_end(size_t fbe_begin) const noexcept
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Transaction>::get(::bank_dom::Transaction& fbe_value) const noexcept
|
|
{
|
|
size_t fbe_begin = get_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset()));
|
|
get_fields(fbe_value, fbe_struct_size);
|
|
get_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Transaction>::get_fields(::bank_dom::Transaction& fbe_value, size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + counterparty.fbe_size()) <= fbe_struct_size)
|
|
counterparty.get(fbe_value.counterparty, "");
|
|
else
|
|
fbe_value.counterparty = "";
|
|
fbe_current_size += counterparty.fbe_size();
|
|
|
|
if ((fbe_current_size + receiving.fbe_size()) <= fbe_struct_size)
|
|
receiving.get(fbe_value.receiving, false);
|
|
else
|
|
fbe_value.receiving = false;
|
|
fbe_current_size += receiving.fbe_size();
|
|
|
|
if ((fbe_current_size + amount.fbe_size()) <= fbe_struct_size)
|
|
amount.get(fbe_value.amount, (uint32_t)0ull);
|
|
else
|
|
fbe_value.amount = (uint32_t)0ull;
|
|
fbe_current_size += amount.fbe_size();
|
|
|
|
if ((fbe_current_size + time.fbe_size()) <= fbe_struct_size)
|
|
time.get(fbe_value.time);
|
|
else
|
|
fbe_value.time = (uint64_t)0ull;
|
|
fbe_current_size += time.fbe_size();
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Transaction>::set_begin()
|
|
{
|
|
assert(((_buffer.offset() + fbe_offset() + fbe_size()) <= _buffer.size()) && "Model is broken!");
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = (uint32_t)fbe_body();
|
|
uint32_t fbe_struct_offset = (uint32_t)(_buffer.allocate(fbe_struct_size) - _buffer.offset());
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) > _buffer.size()))
|
|
return 0;
|
|
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset())) = fbe_struct_offset;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset)) = fbe_struct_size;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4)) = (uint32_t)fbe_type();
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Transaction>::set_end(size_t fbe_begin)
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Transaction>::set(const ::bank_dom::Transaction& fbe_value) noexcept
|
|
{
|
|
size_t fbe_begin = set_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
set_fields(fbe_value);
|
|
set_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Transaction>::set_fields(const ::bank_dom::Transaction& fbe_value) noexcept
|
|
{
|
|
counterparty.set(fbe_value.counterparty);
|
|
receiving.set(fbe_value.receiving);
|
|
amount.set(fbe_value.amount);
|
|
time.set(fbe_value.time);
|
|
}
|
|
|
|
namespace bank_dom {
|
|
|
|
bool TransactionModel::verify()
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return false;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
if (fbe_full_size < model.fbe_size())
|
|
return false;
|
|
|
|
return model.verify();
|
|
}
|
|
|
|
size_t TransactionModel::create_begin()
|
|
{
|
|
size_t fbe_begin = this->buffer().allocate(4 + model.fbe_size());
|
|
return fbe_begin;
|
|
}
|
|
|
|
size_t TransactionModel::create_end(size_t fbe_begin)
|
|
{
|
|
size_t fbe_end = this->buffer().size();
|
|
uint32_t fbe_full_size = (uint32_t)(fbe_end - fbe_begin);
|
|
*((uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4)) = fbe_full_size;
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t TransactionModel::serialize(const ::bank_dom::Transaction& value)
|
|
{
|
|
size_t fbe_begin = create_begin();
|
|
model.set(value);
|
|
size_t fbe_full_size = create_end(fbe_begin);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t TransactionModel::deserialize(::bank_dom::Transaction& value) const noexcept
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return 0;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
assert((fbe_full_size >= model.fbe_size()) && "Model is broken!");
|
|
if (fbe_full_size < model.fbe_size())
|
|
return 0;
|
|
|
|
model.get(value);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
} // namespace bank_dom
|
|
|
|
FieldModel<::bank_dom::Logs>::FieldModel(FBEBuffer& buffer, size_t offset) noexcept : _buffer(buffer), _offset(offset)
|
|
, data(buffer, 4 + 4)
|
|
{}
|
|
|
|
size_t FieldModel<::bank_dom::Logs>::fbe_body() const noexcept
|
|
{
|
|
size_t fbe_result = 4 + 4
|
|
+ data.fbe_size()
|
|
;
|
|
return fbe_result;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Logs>::fbe_extra() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
|
|
size_t fbe_result = fbe_body()
|
|
+ data.fbe_extra()
|
|
;
|
|
|
|
_buffer.unshift(fbe_struct_offset);
|
|
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::Logs>::verify(bool fbe_verify_type) const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return true;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
if (fbe_struct_size < (4 + 4))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_type = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4));
|
|
if (fbe_verify_type && (fbe_struct_type != fbe_type()))
|
|
return false;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
bool fbe_result = verify_fields(fbe_struct_size);
|
|
_buffer.unshift(fbe_struct_offset);
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::Logs>::verify_fields(size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + data.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!data.verify())
|
|
return false;
|
|
fbe_current_size += data.fbe_size();
|
|
|
|
return true;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Logs>::get_begin() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + 4 + 4) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
assert((fbe_struct_size >= (4 + 4)) && "Model is broken!");
|
|
if (fbe_struct_size < (4 + 4))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Logs>::get_end(size_t fbe_begin) const noexcept
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Logs>::get(::bank_dom::Logs& fbe_value) const noexcept
|
|
{
|
|
size_t fbe_begin = get_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset()));
|
|
get_fields(fbe_value, fbe_struct_size);
|
|
get_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Logs>::get_fields(::bank_dom::Logs& fbe_value, size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + data.fbe_size()) <= fbe_struct_size)
|
|
data.get(fbe_value.data);
|
|
else
|
|
fbe_value.data.clear();
|
|
fbe_current_size += data.fbe_size();
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Logs>::set_begin()
|
|
{
|
|
assert(((_buffer.offset() + fbe_offset() + fbe_size()) <= _buffer.size()) && "Model is broken!");
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = (uint32_t)fbe_body();
|
|
uint32_t fbe_struct_offset = (uint32_t)(_buffer.allocate(fbe_struct_size) - _buffer.offset());
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) > _buffer.size()))
|
|
return 0;
|
|
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset())) = fbe_struct_offset;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset)) = fbe_struct_size;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4)) = (uint32_t)fbe_type();
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Logs>::set_end(size_t fbe_begin)
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Logs>::set(const ::bank_dom::Logs& fbe_value) noexcept
|
|
{
|
|
size_t fbe_begin = set_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
set_fields(fbe_value);
|
|
set_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Logs>::set_fields(const ::bank_dom::Logs& fbe_value) noexcept
|
|
{
|
|
data.set(fbe_value.data);
|
|
}
|
|
|
|
namespace bank_dom {
|
|
|
|
bool LogsModel::verify()
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return false;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
if (fbe_full_size < model.fbe_size())
|
|
return false;
|
|
|
|
return model.verify();
|
|
}
|
|
|
|
size_t LogsModel::create_begin()
|
|
{
|
|
size_t fbe_begin = this->buffer().allocate(4 + model.fbe_size());
|
|
return fbe_begin;
|
|
}
|
|
|
|
size_t LogsModel::create_end(size_t fbe_begin)
|
|
{
|
|
size_t fbe_end = this->buffer().size();
|
|
uint32_t fbe_full_size = (uint32_t)(fbe_end - fbe_begin);
|
|
*((uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4)) = fbe_full_size;
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t LogsModel::serialize(const ::bank_dom::Logs& value)
|
|
{
|
|
size_t fbe_begin = create_begin();
|
|
model.set(value);
|
|
size_t fbe_full_size = create_end(fbe_begin);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t LogsModel::deserialize(::bank_dom::Logs& value) const noexcept
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return 0;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
assert((fbe_full_size >= model.fbe_size()) && "Model is broken!");
|
|
if (fbe_full_size < model.fbe_size())
|
|
return 0;
|
|
|
|
model.get(value);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
} // namespace bank_dom
|
|
|
|
FieldModel<::bank_dom::User>::FieldModel(FBEBuffer& buffer, size_t offset) noexcept : _buffer(buffer), _offset(offset)
|
|
, balance(buffer, 4 + 4)
|
|
, password(buffer, balance.fbe_offset() + balance.fbe_size())
|
|
, logs(buffer, password.fbe_offset() + password.fbe_size())
|
|
{}
|
|
|
|
size_t FieldModel<::bank_dom::User>::fbe_body() const noexcept
|
|
{
|
|
size_t fbe_result = 4 + 4
|
|
+ balance.fbe_size()
|
|
+ password.fbe_size()
|
|
+ logs.fbe_size()
|
|
;
|
|
return fbe_result;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::User>::fbe_extra() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
|
|
size_t fbe_result = fbe_body()
|
|
+ balance.fbe_extra()
|
|
+ password.fbe_extra()
|
|
+ logs.fbe_extra()
|
|
;
|
|
|
|
_buffer.unshift(fbe_struct_offset);
|
|
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::User>::verify(bool fbe_verify_type) const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return true;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
if (fbe_struct_size < (4 + 4))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_type = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4));
|
|
if (fbe_verify_type && (fbe_struct_type != fbe_type()))
|
|
return false;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
bool fbe_result = verify_fields(fbe_struct_size);
|
|
_buffer.unshift(fbe_struct_offset);
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::User>::verify_fields(size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + balance.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!balance.verify())
|
|
return false;
|
|
fbe_current_size += balance.fbe_size();
|
|
|
|
if ((fbe_current_size + password.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!password.verify())
|
|
return false;
|
|
fbe_current_size += password.fbe_size();
|
|
|
|
if ((fbe_current_size + logs.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!logs.verify())
|
|
return false;
|
|
fbe_current_size += logs.fbe_size();
|
|
|
|
return true;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::User>::get_begin() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + 4 + 4) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
assert((fbe_struct_size >= (4 + 4)) && "Model is broken!");
|
|
if (fbe_struct_size < (4 + 4))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::User>::get_end(size_t fbe_begin) const noexcept
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::User>::get(::bank_dom::User& fbe_value) const noexcept
|
|
{
|
|
size_t fbe_begin = get_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset()));
|
|
get_fields(fbe_value, fbe_struct_size);
|
|
get_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::User>::get_fields(::bank_dom::User& fbe_value, size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + balance.fbe_size()) <= fbe_struct_size)
|
|
balance.get(fbe_value.balance, (uint32_t)0ull);
|
|
else
|
|
fbe_value.balance = (uint32_t)0ull;
|
|
fbe_current_size += balance.fbe_size();
|
|
|
|
if ((fbe_current_size + password.fbe_size()) <= fbe_struct_size)
|
|
password.get(fbe_value.password, (uint64_t)0ull);
|
|
else
|
|
fbe_value.password = (uint64_t)0ull;
|
|
fbe_current_size += password.fbe_size();
|
|
|
|
if ((fbe_current_size + logs.fbe_size()) <= fbe_struct_size)
|
|
logs.get(fbe_value.logs, std::nullopt);
|
|
else
|
|
fbe_value.logs = std::nullopt;
|
|
fbe_current_size += logs.fbe_size();
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::User>::set_begin()
|
|
{
|
|
assert(((_buffer.offset() + fbe_offset() + fbe_size()) <= _buffer.size()) && "Model is broken!");
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = (uint32_t)fbe_body();
|
|
uint32_t fbe_struct_offset = (uint32_t)(_buffer.allocate(fbe_struct_size) - _buffer.offset());
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) > _buffer.size()))
|
|
return 0;
|
|
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset())) = fbe_struct_offset;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset)) = fbe_struct_size;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4)) = (uint32_t)fbe_type();
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::User>::set_end(size_t fbe_begin)
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::User>::set(const ::bank_dom::User& fbe_value) noexcept
|
|
{
|
|
size_t fbe_begin = set_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
set_fields(fbe_value);
|
|
set_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::User>::set_fields(const ::bank_dom::User& fbe_value) noexcept
|
|
{
|
|
balance.set(fbe_value.balance);
|
|
password.set(fbe_value.password);
|
|
logs.set(fbe_value.logs);
|
|
}
|
|
|
|
namespace bank_dom {
|
|
|
|
bool UserModel::verify()
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return false;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
if (fbe_full_size < model.fbe_size())
|
|
return false;
|
|
|
|
return model.verify();
|
|
}
|
|
|
|
size_t UserModel::create_begin()
|
|
{
|
|
size_t fbe_begin = this->buffer().allocate(4 + model.fbe_size());
|
|
return fbe_begin;
|
|
}
|
|
|
|
size_t UserModel::create_end(size_t fbe_begin)
|
|
{
|
|
size_t fbe_end = this->buffer().size();
|
|
uint32_t fbe_full_size = (uint32_t)(fbe_end - fbe_begin);
|
|
*((uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4)) = fbe_full_size;
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t UserModel::serialize(const ::bank_dom::User& value)
|
|
{
|
|
size_t fbe_begin = create_begin();
|
|
model.set(value);
|
|
size_t fbe_full_size = create_end(fbe_begin);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t UserModel::deserialize(::bank_dom::User& value) const noexcept
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return 0;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
assert((fbe_full_size >= model.fbe_size()) && "Model is broken!");
|
|
if (fbe_full_size < model.fbe_size())
|
|
return 0;
|
|
|
|
model.get(value);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
} // namespace bank_dom
|
|
|
|
FieldModel<::bank_dom::Global>::FieldModel(FBEBuffer& buffer, size_t offset) noexcept : _buffer(buffer), _offset(offset)
|
|
, keys(buffer, 4 + 4)
|
|
, users(buffer, keys.fbe_offset() + keys.fbe_size())
|
|
{}
|
|
|
|
size_t FieldModel<::bank_dom::Global>::fbe_body() const noexcept
|
|
{
|
|
size_t fbe_result = 4 + 4
|
|
+ keys.fbe_size()
|
|
+ users.fbe_size()
|
|
;
|
|
return fbe_result;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Global>::fbe_extra() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
|
|
size_t fbe_result = fbe_body()
|
|
+ keys.fbe_extra()
|
|
+ users.fbe_extra()
|
|
;
|
|
|
|
_buffer.unshift(fbe_struct_offset);
|
|
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::Global>::verify(bool fbe_verify_type) const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return true;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
if (fbe_struct_size < (4 + 4))
|
|
return false;
|
|
|
|
uint32_t fbe_struct_type = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4));
|
|
if (fbe_verify_type && (fbe_struct_type != fbe_type()))
|
|
return false;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
bool fbe_result = verify_fields(fbe_struct_size);
|
|
_buffer.unshift(fbe_struct_offset);
|
|
return fbe_result;
|
|
}
|
|
|
|
bool FieldModel<::bank_dom::Global>::verify_fields(size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + keys.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!keys.verify())
|
|
return false;
|
|
fbe_current_size += keys.fbe_size();
|
|
|
|
if ((fbe_current_size + users.fbe_size()) > fbe_struct_size)
|
|
return true;
|
|
if (!users.verify())
|
|
return false;
|
|
fbe_current_size += users.fbe_size();
|
|
|
|
return true;
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Global>::get_begin() const noexcept
|
|
{
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_offset = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset()));
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + 4 + 4) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + 4 + 4) > _buffer.size()))
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset));
|
|
assert((fbe_struct_size >= (4 + 4)) && "Model is broken!");
|
|
if (fbe_struct_size < (4 + 4))
|
|
return 0;
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Global>::get_end(size_t fbe_begin) const noexcept
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Global>::get(::bank_dom::Global& fbe_value) const noexcept
|
|
{
|
|
size_t fbe_begin = get_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
uint32_t fbe_struct_size = *((const uint32_t*)(_buffer.data() + _buffer.offset()));
|
|
get_fields(fbe_value, fbe_struct_size);
|
|
get_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Global>::get_fields(::bank_dom::Global& fbe_value, size_t fbe_struct_size) const noexcept
|
|
{
|
|
size_t fbe_current_size = 4 + 4;
|
|
|
|
if ((fbe_current_size + keys.fbe_size()) <= fbe_struct_size)
|
|
keys.get(fbe_value.keys);
|
|
else
|
|
fbe_value.keys.clear();
|
|
fbe_current_size += keys.fbe_size();
|
|
|
|
if ((fbe_current_size + users.fbe_size()) <= fbe_struct_size)
|
|
users.get(fbe_value.users);
|
|
else
|
|
fbe_value.users.clear();
|
|
fbe_current_size += users.fbe_size();
|
|
}
|
|
|
|
size_t FieldModel<::bank_dom::Global>::set_begin()
|
|
{
|
|
assert(((_buffer.offset() + fbe_offset() + fbe_size()) <= _buffer.size()) && "Model is broken!");
|
|
if ((_buffer.offset() + fbe_offset() + fbe_size()) > _buffer.size())
|
|
return 0;
|
|
|
|
uint32_t fbe_struct_size = (uint32_t)fbe_body();
|
|
uint32_t fbe_struct_offset = (uint32_t)(_buffer.allocate(fbe_struct_size) - _buffer.offset());
|
|
assert(((fbe_struct_offset > 0) && ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) <= _buffer.size())) && "Model is broken!");
|
|
if ((fbe_struct_offset == 0) || ((_buffer.offset() + fbe_struct_offset + fbe_struct_size) > _buffer.size()))
|
|
return 0;
|
|
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_offset())) = fbe_struct_offset;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset)) = fbe_struct_size;
|
|
*((uint32_t*)(_buffer.data() + _buffer.offset() + fbe_struct_offset + 4)) = (uint32_t)fbe_type();
|
|
|
|
_buffer.shift(fbe_struct_offset);
|
|
return fbe_struct_offset;
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Global>::set_end(size_t fbe_begin)
|
|
{
|
|
_buffer.unshift(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Global>::set(const ::bank_dom::Global& fbe_value) noexcept
|
|
{
|
|
size_t fbe_begin = set_begin();
|
|
if (fbe_begin == 0)
|
|
return;
|
|
|
|
set_fields(fbe_value);
|
|
set_end(fbe_begin);
|
|
}
|
|
|
|
void FieldModel<::bank_dom::Global>::set_fields(const ::bank_dom::Global& fbe_value) noexcept
|
|
{
|
|
keys.set(fbe_value.keys);
|
|
users.set(fbe_value.users);
|
|
}
|
|
|
|
namespace bank_dom {
|
|
|
|
bool GlobalModel::verify()
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return false;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
if (fbe_full_size < model.fbe_size())
|
|
return false;
|
|
|
|
return model.verify();
|
|
}
|
|
|
|
size_t GlobalModel::create_begin()
|
|
{
|
|
size_t fbe_begin = this->buffer().allocate(4 + model.fbe_size());
|
|
return fbe_begin;
|
|
}
|
|
|
|
size_t GlobalModel::create_end(size_t fbe_begin)
|
|
{
|
|
size_t fbe_end = this->buffer().size();
|
|
uint32_t fbe_full_size = (uint32_t)(fbe_end - fbe_begin);
|
|
*((uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4)) = fbe_full_size;
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t GlobalModel::serialize(const ::bank_dom::Global& value)
|
|
{
|
|
size_t fbe_begin = create_begin();
|
|
model.set(value);
|
|
size_t fbe_full_size = create_end(fbe_begin);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
size_t GlobalModel::deserialize(::bank_dom::Global& value) const noexcept
|
|
{
|
|
if ((this->buffer().offset() + model.fbe_offset() - 4) > this->buffer().size())
|
|
return 0;
|
|
|
|
uint32_t fbe_full_size = *((const uint32_t*)(this->buffer().data() + this->buffer().offset() + model.fbe_offset() - 4));
|
|
assert((fbe_full_size >= model.fbe_size()) && "Model is broken!");
|
|
if (fbe_full_size < model.fbe_size())
|
|
return 0;
|
|
|
|
model.get(value);
|
|
return fbe_full_size;
|
|
}
|
|
|
|
} // namespace bank_dom
|
|
|
|
} // namespace FBE
|