Skip to content

Correct typo #143

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
huangminghuang merged 1 commit into from
Feb 28, 2025
Merged

Correct typo #143

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
58 changes: 29 additions & 29 deletions src/mfast/sequence_type.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,37 +7,37 @@
#include <boost/move/core.hpp>
#include "sequence_ref.h"
namespace mfast {
template <typename CRef> class squence_type_base {
template <typename CRef> class sequence_type_base {
#ifdef BOOST_NO_RVALUE_REFERENCES
BOOST_MOVABLE_BUT_NOT_COPYABLE(squence_type_base)
BOOST_MOVABLE_BUT_NOT_COPYABLE(sequence_type_base)
#endif
public:
typedef typename CRef::instruction_cptr instruction_cptr;
typedef CRef cref_type;
typedef typename mref_of<cref_type>::type mref_type;

squence_type_base(mfast::allocator *alloc = nullptr,
sequence_type_base(mfast::allocator *alloc = nullptr,
instruction_cptr instruction = 0,
value_storage *fields_storage = nullptr);

// a special constructor to facilitate puting a message_type instance in an
// associative
// container
// using emplace()
squence_type_base(std::pair<mfast::allocator *, instruction_cptr> p);
~squence_type_base();
sequence_type_base(std::pair<mfast::allocator *, instruction_cptr> p);
~sequence_type_base();

squence_type_base(const cref_type &other, mfast::allocator *alloc);
sequence_type_base(const cref_type &other, mfast::allocator *alloc);

squence_type_base(BOOST_RV_REF(squence_type_base) other)
sequence_type_base(BOOST_RV_REF(sequence_type_base) other)
: alloc_(other.alloc_), instruction_(other.instruction_) {
// g++ 4.7.1 doesn't allow this member function to defined out of class
// declaration
my_storage_ = other.my_storage_;
other.instruction_ = 0;
}

squence_type_base &operator=(BOOST_RV_REF(squence_type_base) other) {
sequence_type_base &operator=(BOOST_RV_REF(sequence_type_base) other) {
// g++ 4.7.1 doesn't allow this member function to defined out of class
// declaration
if (this->instruction())
Expand Down Expand Up @@ -77,92 +77,92 @@ template <typename CRef> class squence_type_base {
value_storage my_storage_;
};

typedef squence_type_base<sequence_cref> sequence_type;
typedef sequence_type_base<sequence_cref> sequence_type;

///////////////////////////////////////////////////////

template <typename CRef>
inline squence_type_base<CRef>::squence_type_base(
inline sequence_type_base<CRef>::sequence_type_base(
mfast::allocator *alloc,
typename squence_type_base<CRef>::instruction_cptr instruction,
typename sequence_type_base<CRef>::instruction_cptr instruction,
value_storage *fields_storage)
: alloc_(alloc), instruction_(instruction) {
if (instruction_)
instruction_->construct_value(my_storage_, fields_storage, alloc_, false);
}

template <typename CRef>
inline squence_type_base<CRef>::squence_type_base(
inline sequence_type_base<CRef>::sequence_type_base(
std::pair<mfast::allocator *,
typename squence_type_base<CRef>::instruction_cptr> p)
typename sequence_type_base<CRef>::instruction_cptr> p)
: alloc_(p.first), instruction_(p.second) {
instruction_->construct_value(my_storage_, 0, alloc_, false);
}

template <typename CRef> inline squence_type_base<CRef>::~squence_type_base() {
template <typename CRef> inline sequence_type_base<CRef>::~sequence_type_base() {
if (alloc_ && this->instruction())
this->instruction()->destruct_value(my_storage_, alloc_);
}

template <typename CRef>
inline typename squence_type_base<CRef>::instruction_cptr
squence_type_base<CRef>::instruction() const {
inline typename sequence_type_base<CRef>::instruction_cptr
sequence_type_base<CRef>::instruction() const {
return instruction_;
}

template <typename CRef>
inline squence_type_base<CRef>::squence_type_base(const CRef &other,
inline sequence_type_base<CRef>::sequence_type_base(const CRef &other,
mfast::allocator *alloc)
: alloc_(alloc), instruction_(other.instruction()) {
this->instruction()->copy_construct_value(
*field_cref_core_access::storage_of(other), my_storage_, alloc, nullptr);
}

template <typename CRef>
inline typename squence_type_base<CRef>::mref_type
squence_type_base<CRef>::ref() {
inline typename sequence_type_base<CRef>::mref_type
sequence_type_base<CRef>::ref() {
return mref_type(alloc_, &my_storage_, instruction_);
}

template <typename CRef>
inline typename squence_type_base<CRef>::mref_type
squence_type_base<CRef>::mref() {
inline typename sequence_type_base<CRef>::mref_type
sequence_type_base<CRef>::mref() {
return mref_type(alloc_, &my_storage_, instruction_);
}

template <typename CRef>
inline typename squence_type_base<CRef>::cref_type
squence_type_base<CRef>::ref() const {
inline typename sequence_type_base<CRef>::cref_type
sequence_type_base<CRef>::ref() const {
return cref_type(&my_storage_, instruction_);
}

template <typename CRef>
inline typename squence_type_base<CRef>::cref_type
squence_type_base<CRef>::cref() const {
inline typename sequence_type_base<CRef>::cref_type
sequence_type_base<CRef>::cref() const {
return cref_type(&my_storage_, instruction_);
}

template <typename CRef>
inline const char *squence_type_base<CRef>::name() const {
inline const char *sequence_type_base<CRef>::name() const {
return instruction_->name();
}

template <typename CRef>
inline mfast::allocator *squence_type_base<CRef>::allocator() const {
inline mfast::allocator *sequence_type_base<CRef>::allocator() const {
return this->alloc_;
}

// template <typename CRef>
// inline void
// squence_type_base<CRef>::reset()
// sequence_type_base<CRef>::reset()
// {
// my_storage_.of_array.content_ = 0;
// my_storage_.of_array.capacity_in_bytes_ = 0;
// }
//
// template <typename CRef>
// inline void
// squence_type_base<CRef>::ensure_valid()
// sequence_type_base<CRef>::ensure_valid()
// {
// instruction_->ensure_valid_storage(my_storage_, alloc_);
// }
Expand Down