Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
66 kB · 2142 lines
C++
at master
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143//// buffer.hpp// ~~~~~~~~~~//// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)//// Distributed under the Boost Software License, Version 1.0. (See accompanying// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)//
#ifndef BOOST_ASIO_BUFFER_HPP#define BOOST_ASIO_BUFFER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)# pragma once#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include <boost/asio/detail/config.hpp>#include <cstddef>#include <cstring>#include <string>#include <vector>#include <boost/detail/workaround.hpp>#include <boost/asio/detail/array_fwd.hpp>
#if defined(BOOST_MSVC)# if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)# if !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)# define BOOST_ASIO_ENABLE_BUFFER_DEBUGGING# endif // !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)# endif // defined(_HAS_ITERATOR_DEBUGGING)#endif // defined(BOOST_MSVC)
#if defined(__GNUC__)# if defined(_GLIBCXX_DEBUG)# if !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)# define BOOST_ASIO_ENABLE_BUFFER_DEBUGGING# endif // !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)# endif // defined(_GLIBCXX_DEBUG)#endif // defined(__GNUC__)
#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)# include <boost/function.hpp>#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \ || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))# include <boost/type_traits/is_const.hpp>#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
#include <boost/asio/detail/push_options.hpp>
namespace boost {namespace asio {
class mutable_buffer;class const_buffer;
namespace detail {void* buffer_cast_helper(const mutable_buffer&);const void* buffer_cast_helper(const const_buffer&);std::size_t buffer_size_helper(const mutable_buffer&);std::size_t buffer_size_helper(const const_buffer&);} // namespace detail
/// Holds a buffer that can be modified./** * The mutable_buffer class provides a safe representation of a buffer that can * be modified. It does not own the underlying data, and so is cheap to copy or * assign. * * @par Accessing Buffer Contents * * The contents of a buffer may be accessed using the @ref buffer_size * and @ref buffer_cast functions: * * @code boost::asio::mutable_buffer b1 = ...; * std::size_t s1 = boost::asio::buffer_size(b1); * unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1); * @endcode * * The boost::asio::buffer_cast function permits violations of type safety, so * uses of it in application code should be carefully considered. */class mutable_buffer{public: /// Construct an empty buffer. mutable_buffer() : data_(0), size_(0) { }
/// Construct a buffer to represent a given memory range. mutable_buffer(void* data, std::size_t size) : data_(data), size_(size) { }
#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) mutable_buffer(void* data, std::size_t size, boost::function<void()> debug_check) : data_(data), size_(size), debug_check_(debug_check) { }
const boost::function<void()>& get_debug_check() const { return debug_check_; }#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
private: friend void* boost::asio::detail::buffer_cast_helper( const mutable_buffer& b); friend std::size_t boost::asio::detail::buffer_size_helper( const mutable_buffer& b);
void* data_; std::size_t size_;
#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) boost::function<void()> debug_check_;#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING};
namespace detail {
inline void* buffer_cast_helper(const mutable_buffer& b){#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) if (b.size_ && b.debug_check_) b.debug_check_();#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING return b.data_;}
inline std::size_t buffer_size_helper(const mutable_buffer& b){ return b.size_;}
} // namespace detail
/// Adapts a single modifiable buffer so that it meets the requirements of the/// MutableBufferSequence concept.class mutable_buffers_1 : public mutable_buffer{public: /// The type for each element in the list of buffers. typedef mutable_buffer value_type;
/// A random-access iterator type that may be used to read elements. typedef const mutable_buffer* const_iterator;
/// Construct to represent a given memory range. mutable_buffers_1(void* data, std::size_t size) : mutable_buffer(data, size) { }
/// Construct to represent a single modifiable buffer. explicit mutable_buffers_1(const mutable_buffer& b) : mutable_buffer(b) { }
/// Get a random-access iterator to the first element. const_iterator begin() const { return this; }
/// Get a random-access iterator for one past the last element. const_iterator end() const { return begin() + 1; }};
/// Holds a buffer that cannot be modified./** * The const_buffer class provides a safe representation of a buffer that cannot * be modified. It does not own the underlying data, and so is cheap to copy or * assign. * * @par Accessing Buffer Contents * * The contents of a buffer may be accessed using the @ref buffer_size * and @ref buffer_cast functions: * * @code boost::asio::const_buffer b1 = ...; * std::size_t s1 = boost::asio::buffer_size(b1); * const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1); * @endcode * * The boost::asio::buffer_cast function permits violations of type safety, so * uses of it in application code should be carefully considered. */class const_buffer{public: /// Construct an empty buffer. const_buffer() : data_(0), size_(0) { }
/// Construct a buffer to represent a given memory range. const_buffer(const void* data, std::size_t size) : data_(data), size_(size) { }
/// Construct a non-modifiable buffer from a modifiable one. const_buffer(const mutable_buffer& b) : data_(boost::asio::detail::buffer_cast_helper(b)), size_(boost::asio::detail::buffer_size_helper(b))#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , debug_check_(b.get_debug_check())#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING { }
#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) const_buffer(const void* data, std::size_t size, boost::function<void()> debug_check) : data_(data), size_(size), debug_check_(debug_check) { }
const boost::function<void()>& get_debug_check() const { return debug_check_; }#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
private: friend const void* boost::asio::detail::buffer_cast_helper( const const_buffer& b); friend std::size_t boost::asio::detail::buffer_size_helper( const const_buffer& b);
const void* data_; std::size_t size_;
#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) boost::function<void()> debug_check_;#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING};
namespace detail {
inline const void* buffer_cast_helper(const const_buffer& b){#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) if (b.size_ && b.debug_check_) b.debug_check_();#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING return b.data_;}
inline std::size_t buffer_size_helper(const const_buffer& b){ return b.size_;}
} // namespace detail
/// Adapts a single non-modifiable buffer so that it meets the requirements of/// the ConstBufferSequence concept.class const_buffers_1 : public const_buffer{public: /// The type for each element in the list of buffers. typedef const_buffer value_type;
/// A random-access iterator type that may be used to read elements. typedef const const_buffer* const_iterator;
/// Construct to represent a given memory range. const_buffers_1(const void* data, std::size_t size) : const_buffer(data, size) { }
/// Construct to represent a single non-modifiable buffer. explicit const_buffers_1(const const_buffer& b) : const_buffer(b) { }
/// Get a random-access iterator to the first element. const_iterator begin() const { return this; }
/// Get a random-access iterator for one past the last element. const_iterator end() const { return begin() + 1; }};
/// An implementation of both the ConstBufferSequence and MutableBufferSequence/// concepts to represent a null buffer sequence.class null_buffers{public: /// The type for each element in the list of buffers. typedef mutable_buffer value_type;
/// A random-access iterator type that may be used to read elements. typedef const mutable_buffer* const_iterator;
/// Get a random-access iterator to the first element. const_iterator begin() const { return &buf_; }
/// Get a random-access iterator for one past the last element. const_iterator end() const { return &buf_; }
private: mutable_buffer buf_;};
/** @defgroup buffer_size boost::asio::buffer_size * * @brief The boost::asio::buffer_size function determines the total number of * bytes in a buffer or buffer sequence. *//*@{*/
/// Get the number of bytes in a modifiable buffer.inline std::size_t buffer_size(const mutable_buffer& b){ return detail::buffer_size_helper(b);}
/// Get the number of bytes in a modifiable buffer.inline std::size_t buffer_size(const mutable_buffers_1& b){ return detail::buffer_size_helper(b);}
/// Get the number of bytes in a non-modifiable buffer.inline std::size_t buffer_size(const const_buffer& b){ return detail::buffer_size_helper(b);}
/// Get the number of bytes in a non-modifiable buffer.inline std::size_t buffer_size(const const_buffers_1& b){ return detail::buffer_size_helper(b);}
/// Get the total number of bytes in a buffer sequence./** * The @c BufferSequence template parameter may meet either of the @c * ConstBufferSequence or @c MutableBufferSequence type requirements. */template <typename BufferSequence>inline std::size_t buffer_size(const BufferSequence& b){ std::size_t total_buffer_size = 0;
typename BufferSequence::const_iterator iter = b.begin(); typename BufferSequence::const_iterator end = b.end(); for (; iter != end; ++iter) total_buffer_size += detail::buffer_size_helper(*iter);
return total_buffer_size;}
/*@}*/
/** @defgroup buffer_cast boost::asio::buffer_cast * * @brief The boost::asio::buffer_cast function is used to obtain a pointer to * the underlying memory region associated with a buffer. * * @par Examples: * * To access the memory of a non-modifiable buffer, use: * @code boost::asio::const_buffer b1 = ...; * const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1); * @endcode * * To access the memory of a modifiable buffer, use: * @code boost::asio::mutable_buffer b2 = ...; * unsigned char* p2 = boost::asio::buffer_cast<unsigned char*>(b2); * @endcode * * The boost::asio::buffer_cast function permits violations of type safety, so * uses of it in application code should be carefully considered. *//*@{*/
/// Cast a non-modifiable buffer to a specified pointer to POD type.template <typename PointerToPodType>inline PointerToPodType buffer_cast(const mutable_buffer& b){ return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));}
/// Cast a non-modifiable buffer to a specified pointer to POD type.template <typename PointerToPodType>inline PointerToPodType buffer_cast(const const_buffer& b){ return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));}
/*@}*/
/// Create a new modifiable buffer that is offset from the start of another./** * @relates mutable_buffer */inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start){ if (start > buffer_size(b)) return mutable_buffer(); char* new_data = buffer_cast<char*>(b) + start; std::size_t new_size = buffer_size(b) - start; return mutable_buffer(new_data, new_size#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , b.get_debug_check()#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING );}
/// Create a new modifiable buffer that is offset from the start of another./** * @relates mutable_buffer */inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b){ if (start > buffer_size(b)) return mutable_buffer(); char* new_data = buffer_cast<char*>(b) + start; std::size_t new_size = buffer_size(b) - start; return mutable_buffer(new_data, new_size#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , b.get_debug_check()#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING );}
/// Create a new non-modifiable buffer that is offset from the start of another./** * @relates const_buffer */inline const_buffer operator+(const const_buffer& b, std::size_t start){ if (start > buffer_size(b)) return const_buffer(); const char* new_data = buffer_cast<const char*>(b) + start; std::size_t new_size = buffer_size(b) - start; return const_buffer(new_data, new_size#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , b.get_debug_check()#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING );}
/// Create a new non-modifiable buffer that is offset from the start of another./** * @relates const_buffer */inline const_buffer operator+(std::size_t start, const const_buffer& b){ if (start > buffer_size(b)) return const_buffer(); const char* new_data = buffer_cast<const char*>(b) + start; std::size_t new_size = buffer_size(b) - start; return const_buffer(new_data, new_size#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , b.get_debug_check()#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING );}
#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)namespace detail {
template <typename Iterator>class buffer_debug_check{public: buffer_debug_check(Iterator iter) : iter_(iter) { }
~buffer_debug_check() {#if BOOST_WORKAROUND(BOOST_MSVC, == 1400) // MSVC 8's string iterator checking may crash in a std::string::iterator // object's destructor when the iterator points to an already-destroyed // std::string object, unless the iterator is cleared first. iter_ = Iterator();#endif // BOOST_WORKAROUND(BOOST_MSVC, == 1400) }
void operator()() { *iter_; }
private: Iterator iter_;};
} // namespace detail#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
/** @defgroup buffer boost::asio::buffer * * @brief The boost::asio::buffer function is used to create a buffer object to * represent raw memory, an array of POD elements, a vector of POD elements, * or a std::string. * * A buffer object represents a contiguous region of memory as a 2-tuple * consisting of a pointer and size in bytes. A tuple of the form <tt>{void*, * size_t}</tt> specifies a mutable (modifiable) region of memory. Similarly, a * tuple of the form <tt>{const void*, size_t}</tt> specifies a const * (non-modifiable) region of memory. These two forms correspond to the classes * mutable_buffer and const_buffer, respectively. To mirror C++'s conversion * rules, a mutable_buffer is implicitly convertible to a const_buffer, and the * opposite conversion is not permitted. * * The simplest use case involves reading or writing a single buffer of a * specified size: * * @code sock.send(boost::asio::buffer(data, size)); @endcode * * In the above example, the return value of boost::asio::buffer meets the * requirements of the ConstBufferSequence concept so that it may be directly * passed to the socket's write function. A buffer created for modifiable * memory also meets the requirements of the MutableBufferSequence concept. * * An individual buffer may be created from a builtin array, std::vector, * std::array or boost::array of POD elements. This helps prevent buffer * overruns by automatically determining the size of the buffer: * * @code char d1[128]; * size_t bytes_transferred = sock.receive(boost::asio::buffer(d1)); * * std::vector<char> d2(128); * bytes_transferred = sock.receive(boost::asio::buffer(d2)); * * std::array<char, 128> d3; * bytes_transferred = sock.receive(boost::asio::buffer(d3)); * * boost::array<char, 128> d4; * bytes_transferred = sock.receive(boost::asio::buffer(d4)); @endcode * * In all three cases above, the buffers created are exactly 128 bytes long. * Note that a vector is @e never automatically resized when creating or using * a buffer. The buffer size is determined using the vector's <tt>size()</tt> * member function, and not its capacity. * * @par Accessing Buffer Contents * * The contents of a buffer may be accessed using the @ref buffer_size and * @ref buffer_cast functions: * * @code boost::asio::mutable_buffer b1 = ...; * std::size_t s1 = boost::asio::buffer_size(b1); * unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1); * * boost::asio::const_buffer b2 = ...; * std::size_t s2 = boost::asio::buffer_size(b2); * const void* p2 = boost::asio::buffer_cast<const void*>(b2); @endcode * * The boost::asio::buffer_cast function permits violations of type safety, so * uses of it in application code should be carefully considered. * * For convenience, the @ref buffer_size function also works on buffer * sequences (that is, types meeting the ConstBufferSequence or * MutableBufferSequence type requirements). In this case, the function returns * the total size of all buffers in the sequence. * * @par Buffer Copying * * The @ref buffer_copy function may be used to copy raw bytes between * individual buffers and buffer sequences. * * In particular, when used with the @ref buffer_size, the @ref buffer_copy * function can be used to linearise a sequence of buffers. For example: * * @code vector<const_buffer> buffers = ...; * * vector<unsigned char> data(boost::asio::buffer_size(buffers)); * boost::asio::buffer_copy(boost::asio::buffer(data), buffers); @endcode * * @par Buffer Invalidation * * A buffer object does not have any ownership of the memory it refers to. It * is the responsibility of the application to ensure the memory region remains * valid until it is no longer required for an I/O operation. When the memory * is no longer available, the buffer is said to have been invalidated. * * For the boost::asio::buffer overloads that accept an argument of type * std::vector, the buffer objects returned are invalidated by any vector * operation that also invalidates all references, pointers and iterators * referring to the elements in the sequence (C++ Std, 23.2.4) * * For the boost::asio::buffer overloads that accept an argument of type * std::basic_string, the buffer objects returned are invalidated according to * the rules defined for invalidation of references, pointers and iterators * referring to elements of the sequence (C++ Std, 21.3). * * @par Buffer Arithmetic * * Buffer objects may be manipulated using simple arithmetic in a safe way * which helps prevent buffer overruns. Consider an array initialised as * follows: * * @code boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' }; @endcode * * A buffer object @c b1 created using: * * @code b1 = boost::asio::buffer(a); @endcode * * represents the entire array, <tt>{ 'a', 'b', 'c', 'd', 'e' }</tt>. An * optional second argument to the boost::asio::buffer function may be used to * limit the size, in bytes, of the buffer: * * @code b2 = boost::asio::buffer(a, 3); @endcode * * such that @c b2 represents the data <tt>{ 'a', 'b', 'c' }</tt>. Even if the * size argument exceeds the actual size of the array, the size of the buffer * object created will be limited to the array size. * * An offset may be applied to an existing buffer to create a new one: * * @code b3 = b1 + 2; @endcode * * where @c b3 will set to represent <tt>{ 'c', 'd', 'e' }</tt>. If the offset * exceeds the size of the existing buffer, the newly created buffer will be * empty. * * Both an offset and size may be specified to create a buffer that corresponds * to a specific range of bytes within an existing buffer: * * @code b4 = boost::asio::buffer(b1 + 1, 3); @endcode * * so that @c b4 will refer to the bytes <tt>{ 'b', 'c', 'd' }</tt>. * * @par Buffers and Scatter-Gather I/O * * To read or write using multiple buffers (i.e. scatter-gather I/O), multiple * buffer objects may be assigned into a container that supports the * MutableBufferSequence (for read) or ConstBufferSequence (for write) concepts: * * @code * char d1[128]; * std::vector<char> d2(128); * boost::array<char, 128> d3; * * boost::array<mutable_buffer, 3> bufs1 = { * boost::asio::buffer(d1), * boost::asio::buffer(d2), * boost::asio::buffer(d3) }; * bytes_transferred = sock.receive(bufs1); * * std::vector<const_buffer> bufs2; * bufs2.push_back(boost::asio::buffer(d1)); * bufs2.push_back(boost::asio::buffer(d2)); * bufs2.push_back(boost::asio::buffer(d3)); * bytes_transferred = sock.send(bufs2); @endcode *//*@{*/
/// Create a new modifiable buffer from an existing buffer./** * @returns <tt>mutable_buffers_1(b)</tt>. */inline mutable_buffers_1 buffer(const mutable_buffer& b){ return mutable_buffers_1(b);}
/// Create a new modifiable buffer from an existing buffer./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * buffer_cast<void*>(b), * min(buffer_size(b), max_size_in_bytes)); @endcode */inline mutable_buffers_1 buffer(const mutable_buffer& b, std::size_t max_size_in_bytes){ return mutable_buffers_1( mutable_buffer(buffer_cast<void*>(b), buffer_size(b) < max_size_in_bytes ? buffer_size(b) : max_size_in_bytes#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , b.get_debug_check()#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/// Create a new non-modifiable buffer from an existing buffer./** * @returns <tt>const_buffers_1(b)</tt>. */inline const_buffers_1 buffer(const const_buffer& b){ return const_buffers_1(b);}
/// Create a new non-modifiable buffer from an existing buffer./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * buffer_cast<const void*>(b), * min(buffer_size(b), max_size_in_bytes)); @endcode */inline const_buffers_1 buffer(const const_buffer& b, std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(buffer_cast<const void*>(b), buffer_size(b) < max_size_in_bytes ? buffer_size(b) : max_size_in_bytes#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , b.get_debug_check()#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/// Create a new modifiable buffer that represents the given memory range./** * @returns <tt>mutable_buffers_1(data, size_in_bytes)</tt>. */inline mutable_buffers_1 buffer(void* data, std::size_t size_in_bytes){ return mutable_buffers_1(mutable_buffer(data, size_in_bytes));}
/// Create a new non-modifiable buffer that represents the given memory range./** * @returns <tt>const_buffers_1(data, size_in_bytes)</tt>. */inline const_buffers_1 buffer(const void* data, std::size_t size_in_bytes){ return const_buffers_1(const_buffer(data, size_in_bytes));}
/// Create a new modifiable buffer that represents the given POD array./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * static_cast<void*>(data), * N * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline mutable_buffers_1 buffer(PodType (&data)[N]){ return mutable_buffers_1(mutable_buffer(data, N * sizeof(PodType)));} /// Create a new modifiable buffer that represents the given POD array./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * static_cast<void*>(data), * min(N * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline mutable_buffers_1 buffer(PodType (&data)[N], std::size_t max_size_in_bytes){ return mutable_buffers_1( mutable_buffer(data, N * sizeof(PodType) < max_size_in_bytes ? N * sizeof(PodType) : max_size_in_bytes));} /// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * static_cast<const void*>(data), * N * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(const PodType (&data)[N]){ return const_buffers_1(const_buffer(data, N * sizeof(PodType)));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * static_cast<const void*>(data), * min(N * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(const PodType (&data)[N], std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(data, N * sizeof(PodType) < max_size_in_bytes ? N * sizeof(PodType) : max_size_in_bytes));}
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \ || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
// Borland C++ and Sun Studio think the overloads://// unspecified buffer(boost::array<PodType, N>& array ...);//// and//// unspecified buffer(boost::array<const PodType, N>& array ...);//// are ambiguous. This will be worked around by using a buffer_types traits// class that contains typedefs for the appropriate buffer and container// classes, based on whether PodType is const or non-const.
namespace detail {
template <bool IsConst>struct buffer_types_base;
template <>struct buffer_types_base<false>{ typedef mutable_buffer buffer_type; typedef mutable_buffers_1 container_type;};
template <>struct buffer_types_base<true>{ typedef const_buffer buffer_type; typedef const_buffers_1 container_type;};
template <typename PodType>struct buffer_types : public buffer_types_base<boost::is_const<PodType>::value>{};
} // namespace detail
template <typename PodType, std::size_t N>inline typename detail::buffer_types<PodType>::container_typebuffer(boost::array<PodType, N>& data){ typedef typename boost::asio::detail::buffer_types<PodType>::buffer_type buffer_type; typedef typename boost::asio::detail::buffer_types<PodType>::container_type container_type; return container_type( buffer_type(data.c_array(), data.size() * sizeof(PodType)));}
template <typename PodType, std::size_t N>inline typename detail::buffer_types<PodType>::container_typebuffer(boost::array<PodType, N>& data, std::size_t max_size_in_bytes){ typedef typename boost::asio::detail::buffer_types<PodType>::buffer_type buffer_type; typedef typename boost::asio::detail::buffer_types<PodType>::container_type container_type; return container_type( buffer_type(data.c_array(), data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes));}
#else // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
/// Create a new modifiable buffer that represents the given POD array./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * data.data(), * data.size() * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline mutable_buffers_1 buffer(boost::array<PodType, N>& data){ return mutable_buffers_1( mutable_buffer(data.c_array(), data.size() * sizeof(PodType)));}
/// Create a new modifiable buffer that represents the given POD array./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * data.data(), * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline mutable_buffers_1 buffer(boost::array<PodType, N>& data, std::size_t max_size_in_bytes){ return mutable_buffers_1( mutable_buffer(data.c_array(), data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * data.size() * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(boost::array<const PodType, N>& data){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType)));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(boost::array<const PodType, N>& data, std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes));}
#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * data.size() * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(const boost::array<PodType, N>& data){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType)));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(const boost::array<PodType, N>& data, std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes));}
#if defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
/// Create a new modifiable buffer that represents the given POD array./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * data.data(), * data.size() * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline mutable_buffers_1 buffer(std::array<PodType, N>& data){ return mutable_buffers_1( mutable_buffer(data.data(), data.size() * sizeof(PodType)));}
/// Create a new modifiable buffer that represents the given POD array./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * data.data(), * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline mutable_buffers_1 buffer(std::array<PodType, N>& data, std::size_t max_size_in_bytes){ return mutable_buffers_1( mutable_buffer(data.data(), data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * data.size() * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(std::array<const PodType, N>& data){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType)));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(std::array<const PodType, N>& data, std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * data.size() * sizeof(PodType)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(const std::array<PodType, N>& data){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType)));}
/// Create a new non-modifiable buffer that represents the given POD array./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode */template <typename PodType, std::size_t N>inline const_buffers_1 buffer(const std::array<PodType, N>& data, std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes));}
#endif // defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
/// Create a new modifiable buffer that represents the given POD vector./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * data.size() ? &data[0] : 0, * data.size() * sizeof(PodType)); @endcode * * @note The buffer is invalidated by any vector operation that would also * invalidate iterators. */template <typename PodType, typename Allocator>inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data){ return mutable_buffers_1( mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType)#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , detail::buffer_debug_check< typename std::vector<PodType, Allocator>::iterator >(data.begin())#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/// Create a new modifiable buffer that represents the given POD vector./** * @returns A mutable_buffers_1 value equivalent to: * @code mutable_buffers_1( * data.size() ? &data[0] : 0, * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode * * @note The buffer is invalidated by any vector operation that would also * invalidate iterators. */template <typename PodType, typename Allocator>inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes){ return mutable_buffers_1( mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , detail::buffer_debug_check< typename std::vector<PodType, Allocator>::iterator >(data.begin())#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/// Create a new non-modifiable buffer that represents the given POD vector./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.size() ? &data[0] : 0, * data.size() * sizeof(PodType)); @endcode * * @note The buffer is invalidated by any vector operation that would also * invalidate iterators. */template <typename PodType, typename Allocator>inline const_buffers_1 buffer( const std::vector<PodType, Allocator>& data){ return const_buffers_1( const_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType)#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , detail::buffer_debug_check< typename std::vector<PodType, Allocator>::const_iterator >(data.begin())#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/// Create a new non-modifiable buffer that represents the given POD vector./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.size() ? &data[0] : 0, * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode * * @note The buffer is invalidated by any vector operation that would also * invalidate iterators. */template <typename PodType, typename Allocator>inline const_buffers_1 buffer( const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType) < max_size_in_bytes ? data.size() * sizeof(PodType) : max_size_in_bytes#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , detail::buffer_debug_check< typename std::vector<PodType, Allocator>::const_iterator >(data.begin())#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/// Create a new non-modifiable buffer that represents the given string./** * @returns <tt>const_buffers_1(data.data(), data.size() * sizeof(Elem))</tt>. * * @note The buffer is invalidated by any non-const operation called on the * given string object. */template <typename Elem, typename Traits, typename Allocator>inline const_buffers_1 buffer( const std::basic_string<Elem, Traits, Allocator>& data){ return const_buffers_1(const_buffer(data.data(), data.size() * sizeof(Elem)#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , detail::buffer_debug_check< typename std::basic_string<Elem, Traits, Allocator>::const_iterator >(data.begin())#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/// Create a new non-modifiable buffer that represents the given string./** * @returns A const_buffers_1 value equivalent to: * @code const_buffers_1( * data.data(), * min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode * * @note The buffer is invalidated by any non-const operation called on the * given string object. */template <typename Elem, typename Traits, typename Allocator>inline const_buffers_1 buffer( const std::basic_string<Elem, Traits, Allocator>& data, std::size_t max_size_in_bytes){ return const_buffers_1( const_buffer(data.data(), data.size() * sizeof(Elem) < max_size_in_bytes ? data.size() * sizeof(Elem) : max_size_in_bytes#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , detail::buffer_debug_check< typename std::basic_string<Elem, Traits, Allocator>::const_iterator >(data.begin())#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING ));}
/*@}*/
/** @defgroup buffer_copy boost::asio::buffer_copy * * @brief The boost::asio::buffer_copy function is used to copy bytes from a * source buffer (or buffer sequence) to a target buffer (or buffer sequence). * * The @c buffer_copy function is available in two forms: * * @li A 2-argument form: @c buffer_copy(target, source) * * @li A 3-argument form: @c buffer_copy(target, source, max_bytes_to_copy)
* Both forms return the number of bytes actually copied. The number of bytes * copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c If specified, @c max_bytes_to_copy. * * This prevents buffer overflow, regardless of the buffer sizes used in the * copy operation. *//*@{*/
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffer& target, const const_buffer& source){ using namespace std; // For memcpy. std::size_t target_size = buffer_size(target); std::size_t source_size = buffer_size(source); std::size_t n = target_size < source_size ? target_size : source_size; memcpy(buffer_cast<void*>(target), buffer_cast<const void*>(source), n); return n;}
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffer& target, const const_buffers_1& source){ return buffer_copy(target, static_cast<const const_buffer&>(source));}
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffer& target, const mutable_buffer& source){ return buffer_copy(target, const_buffer(source));}
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffer& target, const mutable_buffers_1& source){ return buffer_copy(target, const_buffer(source));}
/// Copies bytes from a source buffer sequence to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer sequence representing the memory * regions from which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */template <typename ConstBufferSequence>std::size_t buffer_copy(const mutable_buffer& target, const ConstBufferSequence& source){ std::size_t total_bytes_copied = 0;
typename ConstBufferSequence::const_iterator source_iter = source.begin(); typename ConstBufferSequence::const_iterator source_end = source.end();
for (mutable_buffer target_buffer(target); buffer_size(target_buffer) && source_iter != source_end; ++source_iter) { const_buffer source_buffer(*source_iter); std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer); total_bytes_copied += bytes_copied; target_buffer = target_buffer + bytes_copied; }
return total_bytes_copied;}
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffers_1& target, const const_buffer& source){ return buffer_copy(static_cast<const mutable_buffer&>(target), source);}
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffers_1& target, const const_buffers_1& source){ return buffer_copy(static_cast<const mutable_buffer&>(target), static_cast<const const_buffer&>(source));}
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffers_1& target, const mutable_buffer& source){ return buffer_copy(static_cast<const mutable_buffer&>(target), const_buffer(source));}
/// Copies bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */inline std::size_t buffer_copy(const mutable_buffers_1& target, const mutable_buffers_1& source){ return buffer_copy(static_cast<const mutable_buffer&>(target), const_buffer(source));}
/// Copies bytes from a source buffer sequence to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer sequence representing the memory * regions from which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */template <typename ConstBufferSequence>inline std::size_t buffer_copy(const mutable_buffers_1& target, const ConstBufferSequence& source){ return buffer_copy(static_cast<const mutable_buffer&>(target), source);}
/// Copies bytes from a source buffer to a target buffer sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */template <typename MutableBufferSequence>std::size_t buffer_copy(const MutableBufferSequence& target, const const_buffer& source){ std::size_t total_bytes_copied = 0;
typename MutableBufferSequence::const_iterator target_iter = target.begin(); typename MutableBufferSequence::const_iterator target_end = target.end();
for (const_buffer source_buffer(source); buffer_size(source_buffer) && target_iter != target_end; ++target_iter) { mutable_buffer target_buffer(*target_iter); std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer); total_bytes_copied += bytes_copied; source_buffer = source_buffer + bytes_copied; }
return total_bytes_copied;}
/// Copies bytes from a source buffer to a target buffer sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */template <typename MutableBufferSequence>inline std::size_t buffer_copy(const MutableBufferSequence& target, const const_buffers_1& source){ return buffer_copy(target, static_cast<const const_buffer&>(source));}
/// Copies bytes from a source buffer to a target buffer sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */template <typename MutableBufferSequence>inline std::size_t buffer_copy(const MutableBufferSequence& target, const mutable_buffer& source){ return buffer_copy(target, const_buffer(source));}
/// Copies bytes from a source buffer to a target buffer sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */template <typename MutableBufferSequence>inline std::size_t buffer_copy(const MutableBufferSequence& target, const mutable_buffers_1& source){ return buffer_copy(target, const_buffer(source));}
/// Copies bytes from a source buffer sequence to a target buffer sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A non-modifiable buffer sequence representing the memory * regions from which the bytes will be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) */template <typename MutableBufferSequence, typename ConstBufferSequence>std::size_t buffer_copy(const MutableBufferSequence& target, const ConstBufferSequence& source){ std::size_t total_bytes_copied = 0;
typename MutableBufferSequence::const_iterator target_iter = target.begin(); typename MutableBufferSequence::const_iterator target_end = target.end(); std::size_t target_buffer_offset = 0;
typename ConstBufferSequence::const_iterator source_iter = source.begin(); typename ConstBufferSequence::const_iterator source_end = source.end(); std::size_t source_buffer_offset = 0;
while (target_iter != target_end && source_iter != source_end) { mutable_buffer target_buffer = mutable_buffer(*target_iter) + target_buffer_offset;
const_buffer source_buffer = const_buffer(*source_iter) + source_buffer_offset;
std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer); total_bytes_copied += bytes_copied;
if (bytes_copied == buffer_size(target_buffer)) { ++target_iter; target_buffer_offset = 0; } else target_buffer_offset += bytes_copied;
if (bytes_copied == buffer_size(source_buffer)) { ++source_iter; source_buffer_offset = 0; } else source_buffer_offset += bytes_copied; }
return total_bytes_copied;}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffer& target, const const_buffer& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffer& target, const const_buffers_1& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffer& target, const mutable_buffer& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffer& target, const mutable_buffers_1& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer sequence to a target/// buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer sequence representing the memory * regions from which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */template <typename ConstBufferSequence>inline std::size_t buffer_copy(const mutable_buffer& target, const ConstBufferSequence& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffers_1& target, const const_buffer& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffers_1& target, const const_buffers_1& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffers_1& target, const mutable_buffer& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */inline std::size_t buffer_copy(const mutable_buffers_1& target, const mutable_buffers_1& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer sequence to a target/// buffer./** * @param target A modifiable buffer representing the memory region to which * the bytes will be copied. * * @param source A non-modifiable buffer sequence representing the memory * regions from which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */template <typename ConstBufferSequence>inline std::size_t buffer_copy(const mutable_buffers_1& target, const ConstBufferSequence& source, std::size_t max_bytes_to_copy){ return buffer_copy(buffer(target, max_bytes_to_copy), source);}
/// Copies a limited number of bytes from a source buffer to a target buffer/// sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */template <typename MutableBufferSequence>inline std::size_t buffer_copy(const MutableBufferSequence& target, const const_buffer& source, std::size_t max_bytes_to_copy){ return buffer_copy(target, buffer(source, max_bytes_to_copy));}
/// Copies a limited number of bytes from a source buffer to a target buffer/// sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A non-modifiable buffer representing the memory region from * which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */template <typename MutableBufferSequence>inline std::size_t buffer_copy(const MutableBufferSequence& target, const const_buffers_1& source, std::size_t max_bytes_to_copy){ return buffer_copy(target, buffer(source, max_bytes_to_copy));}
/// Copies a limited number of bytes from a source buffer to a target buffer/// sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */template <typename MutableBufferSequence>inline std::size_t buffer_copy(const MutableBufferSequence& target, const mutable_buffer& source, std::size_t max_bytes_to_copy){ return buffer_copy(target, buffer(source, max_bytes_to_copy));}
/// Copies a limited number of bytes from a source buffer to a target buffer/// sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A modifiable buffer representing the memory region from which * the bytes will be copied. The contents of the source buffer will not be * modified. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */template <typename MutableBufferSequence>inline std::size_t buffer_copy(const MutableBufferSequence& target, const mutable_buffers_1& source, std::size_t max_bytes_to_copy){ return buffer_copy(target, buffer(source, max_bytes_to_copy));}
/// Copies a limited number of bytes from a source buffer sequence to a target/// buffer sequence./** * @param target A modifiable buffer sequence representing the memory regions to * which the bytes will be copied. * * @param source A non-modifiable buffer sequence representing the memory * regions from which the bytes will be copied. * * @param max_bytes_to_copy The maximum number of bytes to be copied. * * @returns The number of bytes copied. * * @note The number of bytes copied is the lesser of: * * @li @c buffer_size(target) * * @li @c buffer_size(source) * * @li @c max_bytes_to_copy */template <typename MutableBufferSequence, typename ConstBufferSequence>std::size_t buffer_copy(const MutableBufferSequence& target, const ConstBufferSequence& source, std::size_t max_bytes_to_copy){ std::size_t total_bytes_copied = 0;
typename MutableBufferSequence::const_iterator target_iter = target.begin(); typename MutableBufferSequence::const_iterator target_end = target.end(); std::size_t target_buffer_offset = 0;
typename ConstBufferSequence::const_iterator source_iter = source.begin(); typename ConstBufferSequence::const_iterator source_end = source.end(); std::size_t source_buffer_offset = 0;
while (total_bytes_copied != max_bytes_to_copy && target_iter != target_end && source_iter != source_end) { mutable_buffer target_buffer = mutable_buffer(*target_iter) + target_buffer_offset;
const_buffer source_buffer = const_buffer(*source_iter) + source_buffer_offset;
std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer, max_bytes_to_copy - total_bytes_copied); total_bytes_copied += bytes_copied;
if (bytes_copied == buffer_size(target_buffer)) { ++target_iter; target_buffer_offset = 0; } else target_buffer_offset += bytes_copied;
if (bytes_copied == buffer_size(source_buffer)) { ++source_iter; source_buffer_offset = 0; } else source_buffer_offset += bytes_copied; }
return total_bytes_copied;}
/*@}*/
} // namespace asio} // namespace boost
#include <boost/asio/detail/pop_options.hpp>
#endif // BOOST_ASIO_BUFFER_HPP