Gov. Dannel P. Malloy signed a bill into law Thursday that attempts to give nonviolent criminals more opportunities to reintegrate into the community, and he promised to offer additional changes in the next legislative session.
The Democrat held a bill-signing ceremony at the state Capitol for his so-called Second Chance Society legislation. He was surrounded by a crowd of supporters of the legislation, including the Republican leader of the state Senate, Len Fasano. Among other things, the new law reclassifies drug possession as a misdemeanor and provides housing and employment to inmates leaving prison.
Afterward, Malloy said he's already compiling a "series of next steps for the next legislative session," which begins in February. Malloy said he's working with academics and people involved in the criminal justice and correctional systems on some new proposals, but he didn't provide any details.
"I think that this is an important first step, but I also believe there are additional steps," he said.
Malloy said he recently visited a prison in Berlin, Germany, where more than 25 percent of the staff focuses on helping inmates turn around their lives. He said they make sure inmates receive needed psychological treatment and job training. Malloy said inmates trained as cooks are successfully placed in jobs after they leave prison.
"As people are leaving jail, they are walking into a job," he said.
In contrast, Malloy said few people living in Connecticut halfway houses after a prison term are gainfully employed.
"We've got to rebalance our approach," he added.
Patrick Gallahue, communications director for the American Civil Liberties Union of Connecticut, said his organization hopes additional changes will be made.
He said the first round of Malloy's Second Chance Society highlighted how someone "can recover from an addiction, but not a conviction." He said Connecticut can learn from other states, where "they're trying out different ways to reduce people's contact with the criminal justice system if they can go into treatment instead."


Great article Bob and you are spot on! The FDIC is aggressively shaking down the community banks and then giving them away for free to the TBTF banks that caused the whole mess to begin with! They are literally taking away banks that are closely held and people's life's work. Big like GM and Citicorp get bailed out and it doesn't matter that a bank worth 4 or 5 million a couple of years ago gets given away for nothing. And let us not forget the monetary policy of nearly 0% interest which is completely unbalanced and is decimating banks, businesses, and individuals, especially the retirees! And if zero percent interest doesn't wipe out your retirement or your business the fed will steal from you by printing money and making your dollars worth 50% less! It is legalized theft!!


text:
/**
 * @file
 *   This file includes definitions for the message buffer pool and message buffers.
 */

#ifndef MESSAGE_HPP_
#define MESSAGE_HPP_

#include "openthread-core-config.h"

#include <stdint.h>

#include <openthread/message.h>
#include <openthread/nat64.h>
#include <openthread/platform/messagepool.h>

#include "common/as_core_type.hpp"
#include "common/clearable.hpp"
#include "common/code_utils.hpp"
#include "common/const_cast.hpp"
#include "common/data.hpp"
#include "common/encoding.hpp"
#include "common/iterator_utils.hpp"
#include "common/linked_list.hpp"
#include "common/locator.hpp"
#include "common/non_copyable.hpp"
#include "common/pool.hpp"
#include "common/timer.hpp"
#include "common/type_traits.hpp"
#include "mac/mac_types.hpp"
#include "thread/child_mask.hpp"
#include "thread/link_quality.hpp"

/**
 * This struct represents an opaque (and empty) type for an OpenThread message buffer.
 *
 */
struct otMessage
{
};

namespace ot {

namespace Crypto {

class AesCcm;
class Sha256;
class HmacSha256;

} // namespace Crypto

/**
 * @addtogroup core-message
 *
 * @brief
 *   This module includes definitions for the message buffer pool and message buffers.
 *
 * @{
 *
 */

/**
 * This macro frees a given message buffer if not `nullptr`.
 *
 * This macro and the ones that follow contain small but common code patterns used in many of the core modules. They
 * are intentionally defined as macros instead of inline methods/functions to ensure that they are fully inlined.
 * Note that an `inline` method/function is not necessarily always inlined by the toolchain and not inlining such
 * small implementations can add a rather large code-size overhead.
 *
 * @param[in] aMessage    A pointer to a `Message` to free (can be `nullptr`).
 *
 */
#define FreeMessage(aMessage)      \
    do                             \
    {                              \
        if ((aMessage) != nullptr) \
        {                          \
            (aMessage)->Free();    \
        }                          \
    } while (false)

/**
 * This macro frees a given message buffer if a given `Error` indicates an error.
 *
 * The parameter @p aMessage can be `nullptr` in which case this macro does nothing.
 *
 * @param[in] aMessage    A pointer to a `Message` to free (can be `nullptr`).
 * @param[in] aError      The `Error` to check.
 *
 */
#define FreeMessageOnError(aMessage, aError)                     \
    do                                                           \
    {                                                            \
        if (((aError) != kErrorNone) && ((aMessage) != nullptr)) \
        {                                                        \
            (aMessage)->Free();                                  \
        }                                                        \
    } while (false)

/**
 * This macro frees a given message buffer if a given `Error` indicates an error and sets the `aMessage` to `nullptr`.
 *
 * @param[in] aMessage    A pointer to a `Message` to free (can be `nullptr`).
 * @param[in] aError      The `Error` to check.
 *
 */
#define FreeAndNullMessageOnError(aMessage, aError)              \
    do                                                           \
    {                                                            \
        if (((aError) != kErrorNone) && ((aMessage) != nullptr)) \
        {                                                        \
            (aMessage)->Free();                                  \
            (aMessage) = nullptr;                                \
        }                                                        \
    } while (false)

constexpr uint16_t kNumBuffers = OPENTHREAD_CONFIG_NUM_MESSAGE_BUFFERS;
constexpr uint16_t kBufferSize = OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE;

class Message;
class MessagePool;
class MessageQueue;
class PriorityQueue;
class ThreadLinkInfo;

/**
 * This class represents a Message buffer.
 *
 */
class Buffer : public otMessageBuffer, public LinkedListEntry<Buffer>
{
    friend class Message;

public:
    /**
     * This method returns a pointer to the next message buffer.
     *
     * @returns A pointer to the next message buffer.
     *
     */
    Buffer *GetNextBuffer(void) { return GetNext(); }

    /**
     * This method returns a pointer to the next message buffer.
     *
     * @returns A pointer to the next message buffer.
     *
     */
    const Buffer *GetNextBuffer(void) const { return GetNext(); }

    /**
     * This method sets the pointer to the next message buffer.
     *
     * @param[in] aNext  A pointer to the next buffer.
     *
     */
    void SetNextBuffer(Buffer *aNext) { SetNext(aNext); }

protected:
    struct Metadata
    {
        Message *    mNext;        // Next message in a doubly linked list.
        Message *    mPrev;        // Previous message in a doubly linked list.
        MessagePool *mMessagePool; // Message pool for this message.
        void *       mQueue;       // The queue where message is queued (if any). Queue type from `mInPriorityQ`.
        uint32_t     mDatagramTag; // The datagram tag used for 6LoWPAN frags or IPv6fragmentation.
        TimeMilli    mTimestamp;   // The message timestamp.
        uint16_t     mReserved;    // Number of reserved bytes (for header).
        uint16_t     mLength;      // Current message length (number of bytes).
        uint16_t     mOffset;      // A byte offset within the message.
        uint16_t     mMeshDest;    // Used for unicast non-link-local messages.
        uint16_t     mPanId;       // PAN ID (used for MLE Discover Request and Response).
        uint8_t      mChannel;     // The message channel (used for MLE Announce).
        RssAverager  mRssAverager; // The averager maintaining the received signal strength (RSS) average.
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
        LqiAverager mLqiAverager; // The averager maintaining the Link quality indicator (LQI) average.
#endif
        ChildMask mChildMask; // ChildMask to indicate which sleepy children need to receive this.

        uint8_t mType : 3;             // The message type.
        uint8_t mSubType : 4;          // The message sub type.
        bool    mDirectTx : 1;         // Whether a direct transmission is required.
        bool    mLinkSecurity : 1;     // Whether link security is enabled.
        uint8_t mPriority : 2;         // The message priority level (higher value is higher priority).
        bool    mInPriorityQ : 1;      // Whether the message is queued in normal or priority queue.
        bool    mTxSuccess : 1;        // Whether the direct tx of the message was successful.
        bool    mDoNotEvict : 1;       // Whether this message may be evicted.
        bool    mMulticastLoop : 1;    // Whether this multicast message may be looped back.
        bool    mResolvingAddress : 1; // Whether the message is pending an address query resolution.
#if OPENTHREAD_CONFIG_MULTI_RADIO
        uint8_t mRadioType : 2;      // The radio link type the message was received on, or should be sent on.
        bool    mIsRadioTypeSet : 1; // Whether the radio type is set.
        static_assert(Mac::kNumRadioTypes <= (1 << 2), "mRadioType bitfield cannot store all radio type values");
#endif
#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
        bool    mTimeSync : 1;      // Whether the message is also used for time sync purpose.
        int64_t mNetworkTimeOffset; // The time offset to the Thread network time, in microseconds.
        uint8_t mTimeSyncSeq;       // The time sync sequence.
#endif
    };

    static_assert(kBufferSize > sizeof(Metadata) + sizeof(otMessageBuffer), "Metadata does not fit in a single buffer");

    static constexpr uint16_t kBufferDataSize     = kBufferSize - sizeof(otMessageBuffer);
    static constexpr uint16_t kHeadBufferDataSize = kBufferDataSize - sizeof(Metadata);

    Metadata &      GetMetadata(void) { return mBuffer.mHead.mMetadata; }
    const Metadata &GetMetadata(void) const { return mBuffer.mHead.mMetadata; }

    uint8_t *      GetFirstData(void) { return mBuffer.mHead.mData; }
    const uint8_t *GetFirstData(void) const { return mBuffer.mHead.mData; }

    uint8_t *      GetData(void) { return mBuffer.mData; }
    const uint8_t *GetData(void) const { return mBuffer.mData; }

private:
    union
    {
        struct
        {
            Metadata mMetadata;
            uint8_t  mData[kHeadBufferDataSize];
        } mHead;
        uint8_t mData[kBufferDataSize];
    } mBuffer;
};

static_assert(sizeof(Buffer) >= kBufferSize,
              "Buffer size is not valid. Increase OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE.");

/**
 * This class represents a message.
 *
 */
class Message : public otMessage, public Buffer, public GetProvider<Message>
{
    friend class Checksum;
    friend class Crypto::HmacSha256;
    friend class Crypto::Sha256;
    friend class Crypto::AesCcm;
    friend class MessagePool;
    friend class MessageQueue;
    friend class PriorityQueue;

public:
    /**
     * This enumeration represents the message type.
     *
     */
    enum Type : uint8_t
    {
        kTypeIp6          = 0, ///< A full uncompressed IPv6 packet
        kType6lowpan      = 1, ///< A 6lowpan frame
        kTypeSupervision  = 2, ///< A child supervision frame.
        kTypeMacEmptyData = 3, ///< An empty MAC data frame.
        kTypeIp4          = 4, ///< A full uncompressed IPv4 packet, for NAT64.
        kTypeOther        = 5, ///< Other (data) message.
    };

    /**
     * This enumeration represents the message sub-type.
     *
     */
    enum SubType : uint8_t
    {
        kSubTypeNone                   = 0,  ///< None
        kSubTypeMleAnnounce            = 1,  ///< MLE Announce
        kSubTypeMleDiscoverRequest     = 2,  ///< MLE Discover Request
        kSubTypeMleDiscoverResponse    = 3,  ///< MLE Discover Response
        kSubTypeJoinerEntrust          = 4,  ///< Joiner Entrust
        kSubTypeMplRetransmission      = 5,  ///< MPL next retransmission message
        kSubTypeMleGeneral             = 6,  ///< General MLE
        kSubTypeJoinerFinalizeResponse = 7,  ///< Joiner Finalize Response
        kSubTypeMleChildUpdateRequest  = 8,  ///< MLE Child Update Request
        kSubTypeMleDataResponse        = 9,  ///< MLE Data Response
        kSubTypeMleChildIdRequest      = 10, ///< MLE Child ID Request
        kSubTypeMleDataRequest         = 11, ///< MLE Data Request
    };

    enum Priority : uint8_t
    {
        kPriorityLow    = OT_MESSAGE_PRIORITY_LOW,      ///< Low priority level.
        kPriorityNormal = OT_MESSAGE_PRIORITY_NORMAL,   ///< Normal priority level.
        kPriorityHigh   = OT_MESSAGE_PRIORITY_HIGH,     ///< High priority level.
        kPriorityNet    = OT_MESSAGE_PRIORITY_HIGH + 1, ///< Network Control priority level.
    };

    static constexpr uint8_t kNumPriorities = 4; ///< Number of priority levels.

    /**
     * This enumeration represents the link security mode (used by `Settings` constructor).
     *
     */
    enum LinkSecurityMode : bool
    {
        kNoLinkSecurity   = false, ///< Link security disabled (no link security).
        kWithLinkSecurity = true,  ///< Link security enabled.
    };

    /**
     * This enumeration represents the message ownership model when a `Message` instance is passed to a method/function.
     *
     */
    enum Ownership : uint8_t
    {
        /**
         * This value indicates that the method/function receiving a `Message` instance should take custody of the
         * message (e.g., the method should `Free()` the message if no longer needed).
         *
         */
        kTakeCustody,

        /**
         * This value indicates that the method/function receiving a `Message` instance does not own the message (e.g.,
         * it should not `Free()` or `Enqueue()` it in a queue). The receiving method/function should create a
         * copy/clone of the message to keep (if/when needed).
         *
         */
        kCopyToUse,
    };

    /**
     * This class represents settings used for creating a new message.
     *
     */
    class Settings : public otMessageSettings
    {
    public:
        /**
         * This constructor initializes the `Settings` object.
         *
         * @param[in]  aSecurityMode  A link security mode.
         * @param[in]  aPriority      A message priority.
         *
         */
        Settings(LinkSecurityMode aSecurityMode, Priority aPriority);

        /**
         * This constructor initializes the `Settings` with a given message priority and link security enabled.
         *
         * @param[in]  aPriority      A message priority.
         *
         */
        explicit Settings(Priority aPriority)
            : Settings(kWithLinkSecurity, aPriority)
        {
        }

        /**
         * This method gets the message priority.
         *
         * @returns The message priority.
         *
         */
        Priority GetPriority(void) const { return static_cast<Priority>(mPriority); }

        /**
         * This method indicates whether the link security should be enabled.
         *
         * @returns TRUE if link security should be enabled, FALSE otherwise.
         *
         */
        bool IsLinkSecurityEnabled(void) const { return mLinkSecurityEnabled; }

        /**
         * This static method converts a pointer to an `otMessageSettings` to a `Settings`.
         *
         * @param[in] aSettings  A pointer to `otMessageSettings` to covert from.
         *                       If it is `nullptr`, then the default settings `GetDefault()` will be used.
         *
         * @returns A reference to the converted `Settings` or the default if @p aSettings is `nullptr`.
         *
         */
        static const Settings &From(const otMessageSettings *aSettings);

        /**
         * This static method returns the default settings with link security enabled and `kPriorityNormal` priority.
         *
         * @returns A reference to the default settings (link security enable and `kPriorityNormal` priority).
         *
         */
        static const Settings &GetDefault(void) { return static_cast<const Settings &>(kDefault); }

    private:
        static const otMessageSettings kDefault;
    };

    /**
     * This method returns a reference to the OpenThread Instance which owns the `Message`.
     *
     * @returns A reference to the `Instance`.
     *
     */
    Instance &GetInstance(void) const;

    /**
     * This method frees this message buffer.
     *
     */
    void Free(void);

    /**
     * This method returns a pointer to the next message.
     *
     * @returns A pointer to the next message in the list or `nullptr` if at the end of the list.
     *
     */
    Message *GetNext(void) const;

    /**
     * This method returns the number of bytes in the message.
     *
     * @returns The number of bytes in the message.
     *
     */
    uint16_t GetLength(void) const { return GetMetadata().mLength; }

    /**
     * This method sets the number of bytes in the message.
     *
     * @param[in]  aLength  Requested number of bytes in the message.
     *
     * @retval kErrorNone    Successfully set the length of the message.
     * @retval kErrorNoBufs  Failed to grow the size of the message because insufficient buffers were available.
     *
     */
    Error SetLength(uint16_t aLength);

    /**
     * This method returns the number of buffers in the message.
     *
     */
    uint8_t GetBufferCount(void) const;

    /**
     * This method returns the byte offset within the message.
     *
     * @returns A byte offset within the message.
     *
     */
    uint16_t GetOffset(void) const { return GetMetadata().mOffset; }

    /**
     * This method moves the byte offset within the message.
     *
     * @param[in]  aDelta  The number of bytes to move the current offset, which may be positive or negative.
     *
     */
    void MoveOffset(int aDelta);

    /**
     * This method sets the byte offset within the message.
     *
     * @param[in]  aOffset  The byte offset within the message.
     *
     */
    void SetOffset(uint16_t aOffset);

    /**
     * This method returns the type of the message.
     *
     * @returns The type of the message.
     *
     */
    Type GetType(void) const { return static_cast<Type>(GetMetadata().mType); }

    /**
     * This method sets the message type.
     *
     * @param[in]  aType  The message type.
     *
     */
    void SetType(Type aType) { GetMetadata().mType = aType; }

    /**
     * This method returns the sub type of the message.
     *
     * @returns The sub type of the message.
     *
     */
    SubType GetSubType(void) const { return static_cast<SubType>(GetMetadata().mSubType); }

    /**
     * This method sets the message sub type.
     *
     * @param[in]  aSubType  The message sub type.
     *
     */
    void SetSubType(SubType aSubType) { GetMetadata().mSubType = aSubType; }

    /**
     * This method returns whether or not the message is of MLE subtype.
     *
     * @retval TRUE   If message is of MLE subtype.
     * @retval FALSE  If message is not of MLE subtype.
     *
     */
    bool IsSubTypeMle(void) const;

    /**
     * This method checks whether this multicast message may be looped back.
     *
     * @retval TRUE   If message may be looped back.
     * @retval FALSE  If message must not be looped back.
     *
     */
    bool GetMulticastLoop(void) const { return GetMetadata().mMulticastLoop; }

    /**
     * This method sets whether multicast may be looped back.
     *
     * @param[in]  aMulticastLoop  Whether allow looping back multicast.
     *
     */
    void SetMulticastLoop(bool aMulticastLoop) { GetMetadata().mMulticastLoop = aMulticastLoop; }

    /**
     * This method returns the message priority level.
     *
     * @returns The priority level associated with this message.
     *
     */
    Priority GetPriority(void) const { return static_cast<Priority>(GetMetadata().mPriority); }

    /**
     * This method sets the messages priority.
     * If the message is already queued in a priority queue, changing the priority ensures to
     * update the message in the associated queue.
     *
     * @param[in]  aPriority  The message priority level.
     *
     * @retval kErrorNone          Successfully set the priority for the message.
     * @retval kErrorInvalidArgs   Priority level is not invalid.
     *
     */
    Error SetPriority(Priority aPriority);

    /**
     * This static method convert a `Priority` to a string.
     *
     * @param[in] aPriority  The priority level.
     *
     * @returns A string representation of @p aPriority.
     *
     */
    static const char *PriorityToString(Priority aPriority);

    /**
     * This method prepends bytes to the front of the message.
     *
     * On success, this method grows the message by @p aLength bytes.
     *
     * @param[in]  aBuf     A pointer to a data buffer (can be `nullptr` to grow message without writing bytes).
     * @param[in]  aLength  The number of bytes to prepend.
     *
     * @retval kErrorNone    Successfully prepended the bytes.
     * @retval kErrorNoBufs  Not enough reserved bytes in the message.
     *
     */
    Error PrependBytes(const void *aBuf, uint16_t aLength);

    /**
     * This method prepends an object to the front of the message.
     *
     * On success, this method grows the message by the size of the object.
     *
     * @tparam    ObjectType   The object type to prepend to the message.
     *
     * @param[in] aObject      A reference to the object to prepend to the message.
     *
     * @retval kErrorNone    Successfully prepended the object.
     * @retval kErrorNoBufs  Not enough reserved bytes in the message.
     *
     */
    template <typename ObjectType> Error Prepend(const ObjectType &aObject)
    {
        static_assert(!TypeTraits::IsPointer<ObjectType>::kValue, "ObjectType must not be a pointer");

        return PrependBytes(&aObject, sizeof(ObjectType));
    }

    /**
     * This method removes header bytes from the message.
     *
     * @param[in]  aLength  Number of header bytes to remove.
     *
     */
    void RemoveHeader(uint16_t aLength);

    /**
     * This method appends bytes to the end of the message.
     *
     * On success, this method grows the message by @p aLength bytes.
     *
     * @param[in]  aBuf     A pointer to a data buffer (MUST not be `nullptr`).
     * @param[in]  aLength  The number of bytes to append.
     *
     * @retval kErrorNone    Successfully appended the bytes.
     * @retval kErrorNoBufs  Insufficient available buffers to grow the message.
     *
     */
    Error AppendBytes(const void *aBuf, uint16_t aLength);

    /**
     * This method appends bytes read from another or potentially the same message to the end of the current message.
     *
     * On success, this method grows the message by @p aLength bytes.
     *
     * @param[in] aMessage   The message to read the bytes from (it can be the same as the current message).
     * @param[in] aOffset    The offset in @p aMessage to start reading the bytes from.
     * @param[in] aLength    The number of bytes to read from @p aMessage and append.
     *
     * @retval kErrorNone    Successfully appended the bytes.
     * @retval kErrorNoBufs  Insufficient available buffers to grow the message.
     * @retval kErrorParse   Not enough bytes in @p aMessage to read @p aLength bytes from @p aOffset.
     *
     */
    Error AppendBytesFromMessage(const Message &aMessage, uint16_t aOffset, uint16_t aLength);

    /**
     * This method appends an object to the end of the message.
     *
     * On success, this method grows the message by the size of the appended object
     *
     * @tparam    ObjectType   The object type to append to the message.
     *
     * @param[in] aObject      A reference to the object to append to the message.
     *
     * @retval kErrorNone    Successfully appended the object.
     * @retval kErrorNoBufs  Insufficient available buffers to grow the message.
     *
     */
    template <typename ObjectType> Error Append(const ObjectType &aObject)
    {
        static_assert(!TypeTraits::IsPointer<ObjectType>::kValue, "ObjectType must not be a pointer");

        return AppendBytes(&aObject, sizeof(ObjectType));
    }

    /**
     * This method appends bytes from a given `Data` instance to the end of the message.
     *
     * On success, this method grows the message by the size of the appended data.
     *
     * @tparam    kDataLengthType   Determines the data length type (`uint8_t` or `uint16_t`).
     *
     * @param[in] aData      A reference to `Data` to append to the message.
     *
     * @retval kErrorNone    Successfully appended the bytes from @p aData.
     * @retval kErrorNoBufs  Insufficient available buffers to grow the message.
     *
     */
    template <DataLengthType kDataLengthType> Error AppendData(const Data<kDataLengthType> &aData)
    {
        return AppendBytes(aData.GetBytes(), aData.GetLength());
    }

    /**
     * This method reads bytes from the message.
     *
     * @param[in]  aOffset  Byte offset within the message to begin reading.
     * @param[out] aBuf     A pointer to a data buffer to copy the read bytes into.
     * @param[in]  aLength  Number of bytes to read.
     *
     * @returns The number of bytes read.
     *
     */
    uint16_t ReadBytes(uint16_t aOffset, void *aBuf, uint16_t aLength) const;

    /**
     * This method reads a given number of bytes from the message.
     *
     * If there are fewer bytes available in the message than the requested read length, the available bytes will be
     * read and copied into @p aBuf. In this case `kErrorParse` will be returned.
     *
     * @param[in]  aOffset  Byte offset within the message to begin reading.
     * @param[out] aBuf     A pointer to a data buffer to copy the read bytes into.
     * @param[in]  aLength  Number of bytes to read.
     *
     * @retval kErrorNone     @p aLength bytes were successfully read from message.
     * @retval kErrorParse    Not enough bytes remaining in message to read the entire object.
     *
     */
    Error Read(uint16_t aOffset, void *aBuf, uint16_t aLength) const;

    /**
     * This method reads an object from the message.
     *
     * If there are fewer bytes available in the message than the requested object size, the available bytes will be
     * read and copied into @p aObject (@p aObject will be read partially). In this case `kErrorParse` will
     * be returned.
     *
     * @tparam     ObjectType   The object type to read from the message.
     *
     * @param[in]  aOffset      Byte offset within the message to begin reading.
     * @param[out] aObject      A reference to the object to read into.
     *
     * @retval kErrorNone     Object @p aObject was successfully read from message.
     * @retval kErrorParse    Not enough bytes remaining in message to read the entire object.
     *
     */
    template <typename ObjectType> Error Read(uint16_t aOffset, ObjectType &aObject) const
    {
        static_assert(!TypeTraits::IsPointer<ObjectType>::kValue, "ObjectType must not be a pointer");

        return Read(aOffset, &aObject, sizeof(ObjectType));
    }

    /**
     * This method compares the bytes in the message at a given offset with a given byte array.
     *
     * If there are fewer bytes available in the message than the requested @p aLength, the comparison is treated as
     * failure (returns FALSE).
     *
     * @param[in]  aOffset    Byte offset within the message to read from for the comparison.
     * @param[in]  aBuf       A pointer to a data buffer to compare with the bytes from message.
     * @param[in]  aLength    Number of bytes in @p aBuf.
     * @param[in]  aMatcher   A `ByteMatcher` function pointer to match the bytes. If `nullptr` then bytes are directly
     *                        compared.
     *
     * @returns TRUE if there are enough bytes available in @p aMessage and they match the bytes from @p aBuf,
     *          FALSE otherwise.
     *
     */
    bool CompareBytes(uint16_t aOffset, const void *aBuf, uint16_t aLength, ByteMatcher aMatcher = nullptr) const;

    /**
     * This method compares the bytes in the message at a given offset with bytes read from another message.
     *
     * If either message has fewer bytes available than the requested @p aLength, the comparison is treated as failure
     * (returns FALSE).
     *
     * @param[in]  aOffset        Byte offset within the message to read from for the comparison.
     * @param[in]  aOtherMessage  The other message to compare with.
     * @param[in]  aOtherOffset   Byte offset within @p aOtherMessage to read from for the comparison.
     * @param[in]  aLength        Number of bytes to compare.
     * @param[in]  aMatcher       A `ByteMatcher` function pointer to match the bytes. If `nullptr` then bytes are
     *                            directly compared.
     *
     * @returns TRUE if there are enough bytes available in both messages and they all match. FALSE otherwise.
     *
     */
    bool CompareBytes(uint16_t       aOffset,
                      const Message &aOtherMessage,
                      uint16_t       aOtherOffset,
                      uint16_t       aLength,
                      ByteMatcher    aMatcher = nullptr) const;

    /**
     * This method compares the bytes in the message at a given offset with an object.
     *
     * The bytes in the message are compared with the bytes in @p aObject. If there are fewer bytes available in the
     * message than the requested object size, it is treated as failed comparison (returns FALSE).
     *
     * @tparam     ObjectType   The object type to compare with the bytes in message.
     *
     * @param[in] aOffset      Byte offset within the message to read from for the comparison.
     * @param[in] aObject      A reference to the object to compare with the message bytes.
     *
     * @returns TRUE if there are enough bytes available in @p aMessage and they match the bytes in @p aObject,
     *          FALSE otherwise.
     *
     */
    template <typename ObjectType> bool Compare(uint16_t aOffset, const ObjectType &aObject) const
    {
        static_assert(!TypeTraits::IsPointer<ObjectType>::kValue, "ObjectType must not be a pointer");

        return CompareBytes(aOffset, &aObject, sizeof(ObjectType));
    }

    /**
     * This method writes bytes to the message.
     *
     * This method will not resize the message. The given data to write (with @p aLength bytes) MUST fit within the
     * existing message buffer (from the given offset @p aOffset up to the message's length).
     *
     * @param[in]  aOffset  Byte offset within the message to begin writing.
     * @param[in]  aBuf     A pointer to a data buffer.
     * @param[in]  aLength  Number of bytes to write.
     *
     */
    void WriteBytes(uint16_t aOffset, const void *aBuf, uint16_t aLength);

    /**
     * This methods writes an object to the message.
     *
     * This method will not resize the message. The entire given object (all its bytes) MUST fit within the existing
     * message buffer (from the given offset @p aOffset up to the message's length).
     *
     * @tparam     ObjectType   The object type to write to the message.
     *
     * @param[in]  aOffset      Byte offset within the message to begin writing.
     * @param[in]  aObject      A reference to the object to write.
     *
     */
    template <typename ObjectType> void Write(uint16_t aOffset, const ObjectType &aObject)
    {
        static_assert(!TypeTraits::IsPointer<ObjectType>::kValue, "ObjectType must not be a pointer");

        WriteBytes(aOffset, &aObject, sizeof(ObjectType));
    }

    /**
     * This method writes bytes from a given `Data` instance to the message.
     *
     * This method will not resize the message. The given data to write MUST fit within the existing message buffer
     * (from the given offset @p aOffset up to the message's length).
     *
     * @tparam     kDataLengthType   Determines the data length type (`uint8_t` or `uint16_t`).
     *
     * @param[in]  aOffset    Byte offset within the message to begin writing.
     * @param[in]  aData      The `Data` to write to the message.
     *
     */
    template <DataLengthType kDataLengthType> void WriteData(uint16_t aOffset, const Data<kDataLengthType> &aData)
    {
        WriteBytes(aOffset, aData.GetBytes(), aData.GetLength());
    }

    /**
     * This method copies bytes from one message to another.
     *
     * If source and destination messages are the same, `CopyTo()` can be used to perform a backward copy, but
     * it MUST not be used to forward copy within the same message (i.e., when source and destination messages are the
     * same and source offset is smaller than the destination offset).
     *
     * @param[in] aSourceOffset       Byte offset within the source message to begin reading.
     * @param[in] aDestinationOffset  Byte offset within the destination message to begin writing.
     * @param[in] aLength             Number of bytes to copy.
     * @param[in] aMessage            Message to copy to.
     *
     * @returns The number of bytes copied.
     *
     */
    uint16_t CopyTo(uint16_t aSourceOffset, uint16_t aDestinationOffset, uint16_t aLength, Message &aMessage) const;

    /**
     * This method creates a copy of the message.
     *
     * It allocates the new message from the same message pool as the original one and copies @p aLength octets
     * of the payload. The `Type`, `SubType`, `LinkSecurity`, `Offset`, `InterfaceId`, and `Priority` fields on the
     * cloned message are also copied from the original one.
     *
     * @param[in] aLength  Number of payload bytes to copy.
     *
     * @returns A pointer to the message or nullptr if insufficient message buffers are available.
     *
     */
    Message *Clone(uint16_t aLength) const;

    /**
     * This method creates a copy of the message.
     *
     * It allocates the new message from the same message pool as the original one and copies the entire payload. The
     * `Type`, `SubType`, `LinkSecurity`, `Offset`, `InterfaceId`, and `Priority` fields on the cloned message are also
     * copied from the original one.
     *
     * @returns A pointer to the message or `nullptr` if insufficient message buffers are available.
     *
     */
    Message *Clone(void) const { return Clone(GetLength()); }

    /**
     * This method returns the datagram tag used for 6LoWPAN fragmentation or the identification used for IPv6
     * fragmentation.
     *
     * @returns The 6LoWPAN datagram tag or the IPv6 fragment identification.
     *
     */
    uint32_t GetDatagramTag(void) const { return GetMetadata().mDatagramTag; }

    /**
     * This method sets the datagram tag used for 6LoWPAN fragmentation.
     *
     * @param[in]  aTag  The 6LoWPAN datagram tag.
     *
     */
    void SetDatagramTag(uint32_t aTag) { GetMetadata().mDatagramTag = aTag; }

    /**
     * This method returns whether or not the message forwarding is scheduled for the child.
     *
     * @param[in]  aChildIndex  The index into the child table.
     *
     * @retval TRUE   If the message is scheduled to be forwarded to the child.
     * @retval FALSE  If the message is not scheduled to be forwarded to the child.
     *
     */
    bool GetChildMask(uint16_t aChildIndex) const;

    /**
     * This method unschedules forwarding of the message to the child.
     *
     * @param[in]  aChildIndex  The index into the child table.
     *
     */
    void ClearChildMask(uint16_t aChildIndex);

    /**
     * This method schedules forwarding of the message to the child.
     *
     * @param[in]  aChildIndex  The index into the child table.
     *
     */
    void SetChildMask(uint16_t aChildIndex);

    /**
     * This method returns whether or not the message forwarding is scheduled for at least one child.
     *
     * @retval TRUE   If message forwarding is scheduled for at least one child.
     * @retval FALSE  If message forwarding is not scheduled for any child.
     *
     */
    bool IsChildPending(void) const;

    /**
     * This method returns the RLOC16 of the mesh destination.
     *
     * @note Only use this for non-link-local unicast messages.
     *
     * @returns The IEEE 802.15.4 Destination PAN ID.
     *
     */
    uint16_t GetMeshDest(void) const { return GetMetadata().mMeshDest; }

    /**
     * This method sets the RLOC16 of the mesh destination.
     *
     * @note Only use this when sending non-link-local unicast messages.
     *
     * @param[in]  aMeshDest  The IEEE 802.15.4 Destination PAN ID.
     *
     */
    void SetMeshDest(uint16_t aMeshDest) { GetMetadata().mMeshDest = aMeshDest; }

    /**
     * This method returns the IEEE 802.15.4 Destination PAN ID.
     *
     * @note Only use this when sending MLE Discover Request or Response messages.
     *
     * @returns The IEEE 802.15.4 Destination PAN ID.
     *
     */
    uint16_t GetPanId(void) const { return GetMetadata().mPanId; }

    /**
     * This method sets the IEEE 802.15.4 Destination PAN ID.
     *
     * @note Only use this when sending MLE Discover Request or Response messages.
     *
     * @param[in]  aPanId  The IEEE 802.15.4 Destination PAN ID.
     *
     */
    void SetPanId(uint16_t aPanId) { GetMetadata().mPanId = aPanId; }

    /**
     * This method returns the IEEE 802.15.4 Channel to use for transmission.
     *
     * @note Only use this when sending MLE Announce messages.
     *
     * @returns The IEEE 802.15.4 Channel to use for transmission.
     *
     */
    uint8_t GetChannel(void) const { return GetMetadata().mChannel; }

    /**
     * This method sets the IEEE 802.15.4 Channel to use for transmission.
     *
     * @note Only use this when sending MLE Announce messages.
     *
     * @param[in]  aChannel  The IEEE 802.15.4 Channel to use for transmission.
     *
     */
    void SetChannel(uint8_t aChannel) { GetMetadata().mChannel = aChannel; }

    /**
     * This method returns the message timestamp.
     *
     * @returns The message timestamp.
     *
     */
    TimeMilli GetTimestamp(void) const { return GetMetadata().mTimestamp; }

    /**
     * This method sets the message timestamp to a given time.
     *
     * @param[in] aTimestamp   The timestamp value.
     *
     */
    void SetTimestamp(TimeMilli aTimestamp) { GetMetadata().mTimestamp = aTimestamp; }

    /**
     * This method sets the message timestamp to the current time.
     *
     */
    void SetTimestampToNow(void) { SetTimestamp(TimerMilli::GetNow()); }

    /**
     * This method returns whether or not message forwarding is scheduled for direct transmission.
     *
     * @retval TRUE   If message forwarding is scheduled for direct transmission.
     * @retval FALSE  If message forwarding is not scheduled for direct transmission.
     *
     */
    bool IsDirectTransmission(void) const { return GetMetadata().mDirectTx; }

    /**
     * This method unschedules forwarding using direct transmission.
     *
     */
    void ClearDirectTransmission(void) { GetMetadata().mDirectTx = false; }

    /**
     * This method schedules forwarding using direct transmission.
     *
     */
    void SetDirectTransmission(void) { GetMetadata().mDirectTx = true; }

    /**
     * This method indicates whether the direct transmission of message was successful.
     *
     * @retval TRUE   If direct transmission of message was successful (all fragments were delivered and acked).
     * @retval FALSE  If direct transmission of message failed (at least one fragment failed).
     *
     */
    bool GetTxSuccess(void) const { return GetMetadata().mTxSuccess; }

    /**
     * This method sets whether the direct transmission of message was successful.
     *
     * @param[in] aTxSuccess   TRUE if the direct transmission is successful, FALSE otherwise (i.e., at least one
     *                         fragment transmission failed).
     *
     */
    void SetTxSuccess(bool aTxSuccess) { GetMetadata().mTxSuccess = aTxSuccess; }

    /**
     * This method indicates whether the message may be evicted.
     *
     * @retval TRUE   If the message must not be evicted.
     * @retval FALSE  If the message may be evicted.
     *
     */
    bool GetDoNotEvict(void) const { return GetMetadata().mDoNotEvict; }

    /**
     * This method sets whether the message may be evicted.
     *
     * @param[in]  aDoNotEvict  TRUE if the message may not be evicted, FALSE otherwise.
     *
     */
    void SetDoNotEvict(bool aDoNotEvict) { GetMetadata().mDoNotEvict = aDoNotEvict; }

    /**
     * This method indicates whether the message is waiting for an address query resolution.
     *
     * @retval TRUE   If the message is waiting for address query resolution.
     * @retval FALSE  If the message is not waiting for address query resolution.
     *
     */
    bool IsResolvingAddress(void) const { return GetMetadata().mResolvingAddress; }

    /**
     * This method sets whether the message is waiting for an address query resolution.
     *
     * @param[in] aResolvingAddress    TRUE if message is waiting for address resolution, FALSE otherwise.
     *
     */
    void SetResolvingAddress(bool aResolvingAddress) { GetMetadata().mResolvingAddress = aResolvingAddress; }

    /**
     * This method indicates whether or not link security is enabled for the message.
     *
     * @retval TRUE   If link security is enabled.
     * @retval FALSE  If link security is not enabled.
     *
     */
    bool IsLinkSecurityEnabled(void) const { return GetMetadata().mLinkSecurity; }

    /**
     * This method sets whether or not link security is enabled for the message.
     *
     * @param[in]  aEnabled  TRUE if link security is enabled, FALSE otherwise.
     *
     */
    void SetLinkSecurityEnabled(bool aEnabled) { GetMetadata().mLinkSecurity = aEnabled; }

    /**
     * This method updates the average RSS (Received Signal Strength) associated with the message by adding the given
     * RSS value to the average. Note that a message can be composed of multiple 802.15.4 data frame fragments each
     * received with a different signal strength.
     *
     * @param[in] aRss A new RSS value (in dBm) to be added to average.
     *
     */
    void AddRss(int8_t aRss) { IgnoreError(GetMetadata().mRssAverager.Add(aRss)); }

    /**
     * This method returns the average RSS (Received Signal Strength) associated with the message.
     *
     * @returns The current average RSS value (in dBm) or `Radio::kInvalidRssi` if no average is available.
     *
     */
    int8_t GetAverageRss(void) const { return GetMetadata().mRssAverager.GetAverage(); }

    /**
     * This method returns a const reference to RssAverager of the message.
     *
     * @returns A const reference to the RssAverager of the message.
     *
     */
    const RssAverager &GetRssAverager(void) const { return GetMetadata().mRssAverager; }

#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
    /**
     * This method updates the average LQI (Link Quality Indicator) associated with the message.
     *
     * The given LQI value would be added to the average. Note that a message can be composed of multiple 802.15.4
     * frame fragments each received with a different signal strength.
     *
     * @param[in] aLqi A new LQI value (has no unit) to be added to average.
     *
     */
    void AddLqi(uint8_t aLqi) { GetMetadata().mLqiAverager.Add(aLqi); }

    /**
     * This method returns the average LQI (Link Quality Indicator) associated with the message.
     *
     * @returns The current average LQI value (in dBm) or OT_RADIO_LQI_NONE if no average is available.
     *
     */
    uint8_t GetAverageLqi(void) const { return GetMetadata().mLqiAverager.GetAverage(); }

    /**
     * This method returns the count of frames counted so far.
     *
     * @returns The count of frames that have been counted.
     *
     */
    uint8_t GetPsduCount(void) const { return GetMetadata().mLqiAverager.GetCount(); }
#endif

    /**
     * This method sets the message's link info properties (PAN ID, link security, RSS) from a given `ThreadLinkInfo`.
     *
     * @param[in] aLinkInfo   The `ThreadLinkInfo` instance from which to set message's related properties.
     *
     */
    void SetLinkInfo(const ThreadLinkInfo &aLinkInfo);

    /**
     * This method returns a pointer to the message queue (if any) where this message is queued.
     *
     * @returns A pointer to the message queue or `nullptr` if not in any message queue.
     *
     */
    MessageQueue *GetMessageQueue(void) const
    {
        return !GetMetadata().mInPriorityQ ? static_cast<MessageQueue *>(GetMetadata().mQueue) : nullptr;
    }

    /**
     * This method returns a pointer to the priority message queue (if any) where this message is queued.
     *
     * @returns A pointer to the priority queue or `nullptr` if not in any priority queue.
     *
     */
    PriorityQueue *GetPriorityQueue(void) const
    {
        return GetMetadata().mInPriorityQ ? static_cast<PriorityQueue *>(GetMetadata().mQueue) : nullptr;
    }

    /**
     * This method indicates whether or not the message is also used for time sync purpose.
     *
     * When OPENTHREAD_CONFIG_TIME_SYNC_ENABLE is 0, this method always return false.
     *
     * @retval TRUE   If the message is also used for time sync purpose.
     * @retval FALSE  If the message is not used for time sync purpose.
     *
     */
    bool IsTimeSync(void) const;

#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
    /**
     * This method sets whether or not the message is also used for time sync purpose.
     *
     * @param[in]  aEnabled  TRUE if the message is also used for time sync purpose, FALSE otherwise.
     *
     */
    void SetTimeSync(bool aEnabled) { GetMetadata().mTimeSync = aEnabled; }

    /**
     * This method sets the offset to network time.
     *
     * @param[in]  aNetworkTimeOffset  The offset to network time.
     *
     */
    void SetNetworkTimeOffset(int64_t aNetworkTimeOffset) { GetMetadata().mNetworkTimeOffset = aNetworkTimeOffset; }

    /**
     * This method gets the offset to network time.
     *
     * @returns  The offset to network time.
     *
     */
    int64_t GetNetworkTimeOffset(void) const { return GetMetadata().mNetworkTimeOffset; }

    /**
     * This method sets the time sync sequence.
     *
     * @param[in]  aTimeSyncSeq  The time sync sequence.
     *
     */
    void SetTimeSyncSeq(uint8_t aTimeSyncSeq) { GetMetadata().mTimeSyncSeq = aTimeSyncSeq; }

    /**
     * This method gets the time sync sequence.
     *
     * @returns  The time sync sequence.
     *
     */
    uint8_t GetTimeSyncSeq(void) const { return GetMetadata().mTimeSyncSeq; }
#endif // OPENTHREAD_CONFIG_TIME_SYNC_ENABLE

#if OPENTHREAD_CONFIG_MULTI_RADIO
    /**
     * This method indicates whether the radio type is set.
     *
     * @retval TRUE   If the radio type is set.
     * @retval FALSE  If the radio type is not set.
     *
     */
    bool IsRadioTypeSet(void) const { return GetMetadata().mIsRadioTypeSet; }

    /**
     * This method gets the radio link type the message was received on, or should be sent on.
     *
     * This method should be used only when `IsRadioTypeSet()` returns `true`.
     *
     * @returns The radio link type of the message.
     *
     */
    Mac::RadioType GetRadioType(void) const { return static_cast<Mac::RadioType>(GetMetadata().mRadioType); }

    /**
     * This method sets the radio link type the message was received on, or should be sent on.
     *
     * @param[in] aRadioType   A radio link type of the message.
     *
     */
    void SetRadioType(Mac::RadioType aRadioType)
    {
        GetMetadata().mIsRadioTypeSet = true;
        GetMetadata().mRadioType      = aRadioType;
    }

    /**
     * This method clears any previously set radio type on the message.
     *
     * After calling this method, `IsRadioTypeSet()` returns false until radio type is set (`SetRadioType()`).
     *
     */
    void ClearRadioType(void) { GetMetadata().mIsRadioTypeSet = false; }

#endif // #if OPENTHREAD_CONFIG_MULTI_RADIO

protected:
    class ConstIterator : public ItemPtrIterator<const Message, ConstIterator>
    {
        friend class ItemPtrIterator<const Message, ConstIterator>;

    public:
        ConstIterator(void) = default;

        explicit ConstIterator(const Message *aMessage)
            : ItemPtrIterator(aMessage)
        {
        }

    private:
        void Advance(void) { mItem = mItem->GetNext(); }
    };

    class Iterator : public ItemPtrIterator<Message, Iterator>
    {
        friend class ItemPtrIterator<Message, Iterator>;

    public:
        Iterator(void)
            : mNext(nullptr)
        {
        }

        explicit Iterator(Message *aMessage)
            : ItemPtrIterator(aMessage)
            , mNext(NextMessage(aMessage))
        {
        }

    private:
        void            Advance(void);
        static Message *NextMessage(Message *aMessage) { return (aMessage != nullptr) ? aMessage->GetNext() : nullptr; }

        Message *mNext;
    };

    uint16_t GetReserved(void) const { return GetMetadata().mReserved; }
    void     SetReserved(uint16_t aReservedHeader) { GetMetadata().mReserved = aReservedHeader; }

private:
    class Chunk : public Data<kWithUint16Length>
    {
    public:
        const Buffer *GetBuffer(void) const { return mBuffer; }
        void          SetBuffer(const Buffer *aBuffer) { mBuffer = aBuffer; }

    private:
        const Buffer *mBuffer; // Buffer containing the chunk
    };

    class MutableChunk : public Chunk
    {
    public:
        uint8_t *GetBytes(void) { return AsNonConst(Chunk::GetBytes()); }
    };

    void GetFirstChunk(uint16_t aOffset, uint16_t &aLength, Chunk &aChunk) const;
    void GetNextChunk(uint16_t &aLength, Chunk &aChunk) const;

    void GetFirstChunk(uint16_t aOffset, uint16_t &aLength, MutableChunk &aChunk)
    {
        AsConst(this)->GetFirstChunk(aOffset, aLength, static_cast<Chunk &>(aChunk));
    }

    void GetNextChunk(uint16_t &aLength, MutableChunk &aChunk)
    {
        AsConst(this)->GetNextChunk(aLength, static_cast<Chunk &>(aChunk));
    }

    MessagePool *GetMessagePool(void) const { return GetMetadata().mMessagePool; }
    void         SetMessagePool(MessagePool *aMessagePool) { GetMetadata().mMessagePool = aMessagePool; }

    bool IsInAQueue(void) const { return (GetMetadata().mQueue != nullptr); }
    void SetMessageQueue(MessageQueue *aMessageQueue);
    void SetPriorityQueue(PriorityQueue *aPriorityQueue);

    Message *&      Next(void) { return GetMetadata().mNext; }
    Message *const &Next(void) const { return GetMetadata().mNext; }
    Message *&      Prev(void) { return GetMetadata().mPrev; }

    static Message *      NextOf(Message *aMessage) { return (aMessage != nullptr) ? aMessage->Next() : nullptr; }
    static const Message *NextOf(const Message *aMessage) { return (aMessage != nullptr) ? aMessage->Next() : nullptr; }

    Error ResizeMessage(uint16_t aLength);
};

/**
 * This class implements a message queue.
 *
 */
class MessageQueue : public otMessageQueue
{
    friend class Message;
    friend class PriorityQueue;

public:
    typedef otMessageQueueInfo Info; ///< This struct represents info (number of messages/buffers) about a queue.

    /**
     * This enumeration represents a position (head or tail) in the queue. This is used to specify where a new message
     * should be added in the queue.
     *
     */
    enum QueuePosition : uint8_t
    {
        kQueuePositionHead, ///< Indicates the head (front) of the list.
        kQueuePositionTail, ///< Indicates the tail (end) of the list.
    };

    /**
     * This constructor initializes the message queue.
     *
     */
    MessageQueue(void) { SetTail(nullptr); }

    /**
     * This method returns a pointer to the first message.
     *
     * @returns A pointer to the first message.
     *
     */
    Message *GetHead(void) { return Message::NextOf(GetTail()); }

    /**
     * This method returns a pointer to the first message.
     *
     * @returns A pointer to the first message.
     *
     */
    const Message *GetHead(void) const { return Message::NextOf(GetTail()); }

    /**
     * This method adds a message to the end of the list.
     *
     * @param[in]  aMessage  The message to add.
     *
     */
    void Enqueue(Message &aMessage) { Enqueue(aMessage, kQueuePositionTail); }

    /**
     * This method adds a message at a given position (head/tail) of the list.
     *
     * @param[in]  aMessage  The message to add.
     * @param[in]  aPosition The position (head or tail) where to add the message.
     *
     */
    void Enqueue(Message &aMessage, QueuePosition aPosition);

    /**
     * This method removes a message from the list.
     *
     * @param[in]  aMessage  The message to remove.
     *
     */
    void Dequeue(Message &aMessage);

    /**
     * This method removes a message from the queue and frees it.
     *
     * @param[in]  aMessage  The message to remove and free.
     *
     */
    void DequeueAndFree(Message &aMessage);

    /**
     * This method removes and frees all messages from the queue.
     *
     */
    void DequeueAndFreeAll(void);

    /**
     * This method gets the information about number of messages and buffers in the queue.
     *
     * This method updates `aInfo` and adds number of message/buffers in the message queue to the corresponding member
     * variable in `aInfo`. The caller needs to make sure `aInfo` is initialized before calling this method (e.g.,
     * clearing `aInfo`). Same `aInfo` can be passed in multiple calls of `GetInfo(aInfo)` on different queues to add
     * up the number of messages/buffers on different queues.
     *
     * @param[out] aInfo  A reference to `Info` structure to update.ni
     *
     */
    void GetInfo(Info &aInfo) const;

    // The following methods are intended to support range-based `for`
    // loop iteration over the queue entries and should not be used
    // directly. The range-based `for` works correctly even if the
    // current entry is removed from the queue during iteration.

    Message::Iterator begin(void);
    Message::Iterator end(void) { return Message::Iterator(); }

    Message::ConstIterator begin(void) const;
    Message::ConstIterator end(void) const { return Message::ConstIterator(); }

private:
    Message *      GetTail(void) { return static_cast<Message *>(mData); }
    const Message *GetTail(void) const { return static_cast<const Message *>(mData); }
    void           SetTail(Message *aMessage) { mData = aMessage; }
};

/**
 * This class implements a priority queue.
 *
 */
class PriorityQueue : private Clearable<PriorityQueue>
{
    friend class Message;
    friend class MessageQueue;
    friend class MessagePool;
    friend class Clearable<PriorityQueue>;

public:
    typedef otMessageQueueInfo Info; ///< This struct represents info (number of messages/buffers) about a queue.

    /**
     * This constructor initializes the priority queue.
     *
     */
    PriorityQueue(void) { Clear(); }

    /**
     * This method returns a pointer to the first message.
     *
     * @returns A pointer to the first message.
     *
     */
    Message *GetHead(void) { return AsNonConst(AsConst(this)->GetHead()); }

    /**
     * This method returns a pointer to the first message.
     *
     * @returns A pointer to the first message.
     *
     */
    const Message *GetHead(void) const;

    /**
     * This method returns a pointer to the first message for a given priority level.
     *
     * @param[in] aPriority   Priority level.
     *
     * @returns A pointer to the first message with given priority level or `nullptr` if there is no messages with
     *          this priority level.
     *
     */
    Message *GetHeadForPriority(Message::Priority aPriority)
    {
        return AsNonConst(AsConst(this)->GetHeadForPriority(aPriority));
    }

    /**
     * This method returns a pointer to the first message for a given priority level.
     *
     * @param[in] aPriority   Priority level.
     *
     * @returns A pointer to the first message with given priority level or `nullptr` if there is no messages with
     *          this priority level.
     *
     */
    const Message *GetHeadForPriority(Message::Priority aPriority) const;

    /**
     * This method adds a message to the queue.
     *
     * @param[in]  aMessage  The message to add.
     *
     */
    void Enqueue(Message &aMessage);

    /**
     * This method removes a message from the list.
     *
     * @param[in]  aMessage  The message to remove.
     *
     */
    void Dequeue(Message &aMessage);

    /**
     * This method removes a message from the queue and frees it.
     *
     * @param[in]  aMessage  The message to remove and free.
     *
     */
    void DequeueAndFree(Message &aMessage);

    /**
     * This method removes and frees all messages from the queue.
     *
     */
    void DequeueAndFreeAll(void);

    /**
     * This method returns the tail of the list (last message in the list).
     *
     * @returns A pointer to the tail of the list.
     *
     */
    Message *GetTail(void) { return AsNonConst(AsConst(this)->GetTail()); }

    /**
     * This method returns the tail of the list (last message in the list).
     *
     * @returns A pointer to the tail of the list.
     *
     */
    const Message *GetTail(void) const;

    /**
     * This method gets the information about number of messages and buffers in the priority queue.
     *
     * This method updates `aInfo` array and adds number of message/buffers in the message queue to the corresponding
     * member variable in `aInfo`. The caller needs to make sure `aInfo` is initialized before calling this method
     * (e.g., clearing `aInfo`). Same `aInfo` can be passed in multiple calls of `GetInfo(aInfo)` on different queues
     * to add up the number of messages/buffers on different queues.
     *
     * @param[out] aInfo  A reference to an `Info` structure to update.
     *
     */
    void GetInfo(Info &aInfo) const;

    // The following methods are intended to support range-based `for`
    // loop iteration over the queue entries and should not be used
    // directly. The range-based `for` works correctly even if the
    // current entry is removed from the queue during iteration.

    Message::Iterator begin(void);
    Message::Iterator end(void) { return Message::Iterator(); }

    Message::ConstIterator begin(void) const;
    Message::ConstIterator end(void) const { return Message::ConstIterator(); }

private:
    uint8_t PrevPriority(uint8_t aPriority) const
    {
        return (aPriority == Message::kNumPriorities - 1) ? 0 : (aPriority + 1);
    }

    const Message *FindFirstNonNullTail(Message::Priority aStartPriorityLevel) const;

    Message *FindFirstNonNullTail(Message::Priority aStartPriorityLevel)
    {
        return AsNonConst(AsConst(this)->FindFirstNonNullTail(aStartPriorityLevel));
    }

    Message *mTails[Message::kNumPriorities]; // Tail pointers associated with different priority levels.
};

/**
 * This class represents a message pool
 *
 */
class MessagePool : public InstanceLocator, private NonCopyable
{
    friend class Message;
    friend class MessageQueue;
    friend class PriorityQueue;

public:
    /**
     * This constructor initializes the object.
     *
     */
    explicit MessagePool(Instance &aInstance);

    /**
     * This method allocates a new message with specified settings.
     *
     * @param[in]  aType           The message type.
     * @param[in]  aReserveHeader  The number of header bytes to reserve.
     * @param[in]  aSettings       The message settings.
     *
     * @returns A pointer to the message or `nullptr` if no message buffers are available.
     *
     */
    Message *Allocate(Message::Type            aType,
                      uint16_t                 aReserveHeader = 0,
                      const Message::Settings &aSettings      = Message::Settings::GetDefault());

    /**
     * This method is used to free a message and return all message buffers to the buffer pool.
     *
     * @param[in]  aMessage  The message to free.
     *
     */
    void Free(Message *aMessage);

    /**
     * This method returns the number of free buffers.
     *
     * @returns The number of free buffers, or 0xffff (UINT16_MAX) if number is unknown.
     *
     */
    uint16_t GetFreeBufferCount(void) const;

    /**
     * This method returns the total number of buffers.
     *
     * @returns The total number of buffers, or 0xffff (UINT16_MAX) if number is unknown.
     *
     */
    uint16_t GetTotalBufferCount(void) const;

private:
    Buffer *NewBuffer(Message::Priority aPriority);
    void    FreeBuffers(Buffer *aBuffer);
    Error   ReclaimBuffers(Message::Priority aPriority);

#if !OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT && !OPENTHREAD_CONFIG_MESSAGE_USE_HEAP_ENABLE
    uint16_t                  mNumFreeBuffers;
    Pool<Buffer, kNumBuffers> mBufferPool;
#endif
};

inline Instance &Message::GetInstance(void) const
{
    return GetMessagePool()->GetInstance();
}

/**
 * @}
 *
 */

DefineCoreType(otMessageBuffer, Buffer);
DefineCoreType(otMessageSettings, Message::Settings);
DefineCoreType(otMessage, Message);
DefineCoreType(otMessageQueue, MessageQueue);

} // namespace ot

#endif // MESSAGE_HPP_

redpajama_set_name: RedPajamaGithub


text:
Realme Patents Smartphone With Oval-Shaped Rear Camera Module, Hole-Punch Display: Report
Realme has patented a smartphone design that has a unique oval-shaped rear camera module and a hole-punch display, as per a report. The illustration shared in the report shows the rear camera module has five cutouts, including a rectangular one. It is possible that this rectangular cutout features a periscope camera. When seen from the front, there is a hole-punch cutout on the top left corner, and the handset has noticeable bezels as well as a thick chin. The schematics also show a 3.5mm headphone port at the bottom.
IThome reports that a blogger shared the schematics of an alleged Realme smartphone with a unique rear camera module. As per the illustration provided with the report, the oval-shaped camera module features five cutouts – four circular and one rectangular. The circular cutouts are arranged in a diamond-shape fashion with the rectangular one sitting just below this setup.
There is no information on the camera/ lens but it is claimed that one of the circular cutouts will have a flash. The rectangular cutout could be a periscope camera just like we have seen in various smartphones. When seen from the front, there is a single hole-punch cutout on the top left corner, a chin and bezels on three sides.
The schematics of the alleged Realme smartphone also show a 3.5mm headphone and charging ports. As far as physical buttons are concerned, the power button can be seen on the right side, volume rocker is placed on the left.
Gadgets 360 is unable to confirm the claims, therefore, it is advised that users take this development with a pinch of salt.
Redmi Note 8 or Realme 5s: Which is the best phone under Rs. 10,000 in India right now? We discussed this on Orbital, our weekly technology podcast, which you can subscribe to via Apple Podcasts or RSS, download the episode, or just hit the play button below.
House Speaker McCarthy spoke with Musk about making Twitter 'fair on all sides'
Twitter Teams Up With Ad Verification Firms to Show Advertisers Tweet-Level Analytics, Verified Views

redpajama_set_name: RedPajamaCommonCrawl


£500 towards legal fees*..... Situated in the cultural centre of Purfleet within a mile of the mainline C2C station and the redevelopment area of the shortly to be renamed Purfleet on Thames. This two double bedroom house has excellent room sizes and a first floor bathroom, on the ground floor can be found an entrance hall, though lounge/diner with French doors leading to the garden, kitchen and conservatory. The gardens are easily maintained and give access to the garage/man cave.
Bay window to front, French doors to rear garden. laminate floor.
Purchasers are required to use our preferred conveyancers. We will pay £500 inc vat to the conveyancer upon completion of the sale of this property to the purchaser introduced through ourselves.


Thank you, This is a great resource to have for web developers.
Amazing, thank you so much for putting this gist up, respect.
You are always there for us and we knew that .. Awesome work .. Thanks for spending your time to help and develop us .. Way to go man ..
Thank a lot Brad for these helpful resources!
AWESOME! Thanks for all You are doing!
Thank you Brad for these very useful resources. I have been following you on YouTube for a good amount of time, and you never fail your audience.st will proved to be invaluable. You never can have tools in your tool-belt for web/API/application development.
Thanks Brad..Been Putting Off setting up a GitHub Account, But just so I could say Thank You!!
A gold mine thanks Brad!
You're amazing man! Thank you!
Thank you very much for share that links, it is very important for the web developer.
Well complied! Thanks for sharing.
Brad is a beacon of hope for so many. I wish Ur days be long and full of bliss my friend. Thank U.
Thank you a lot ..
Really amazing bro :) Thank your they are all awsome!!
Very useful post.thank you sir!
Thanks, Brad! These are great resources!
Multiple Image Resizer is my favorite, I recommend you to add.
Another markdown editor (this time one focused on GH style markdown): https://jbt.github.io/markdown-editor/.
For mockups, I find that draw.io and uxpin.com to be handy.
Most excellent, as always!!! Keep broadcasting!!
Thanks for these helpful resources.
Thank you so much Brad! Awesome!
Thank you very much Brad. You are the best!
Thank you! I don't feel alone out here.
Thanks :), tableconvert.com is my favorite, I recommend you to add.


text:
» Home » Marketplaces » eBay » A Love for the Unique Proves Profitable
A Love for the Unique Proves Profitable
Merchant endures challenges and finds online success.
By Olga Munoz · April 2, 2012 · No comments
TAGGED IN: Bonanza, ebay, profile, selling
Sheila Sarver always dreamed of having a booth in an antiques mall after retiring from a 25-year career in education. But the move to selling came sooner than she expected in 1998 when she got custody of her 3-year-old grandson.
To make room for her new addition, Sarver needed to clean out a bedroom where she stored many of her collections, including illustrated comic books, she recalls. She quickly turned to eBay, knowing she could start selling her collections quickly without much startup cost. Thirteen years later, Sarver loves the path her life has taken, says the seller known as msmizzou on eBay and Bonanza.
"I would have never thought I'd be selling online years ago, but now I can't imagine not doing it," she says. "It's fun and rewarding."
A passion for the 'unusual'
Sarver's stores, Shemaw's Stuff, got their name courtesy of her grandson, who called Sarver "Shemaw" when he was a toddler.
"I had a big vintage toy collection and when [my grandson] would try to play with them, I would tell him they were my items for resale," she explains. "Since he calls me Shemaw, he began calling those toys 'Shemaw's Stuff.'"
"My best friend often laughs at me about items I purchase, and I always remind her that even an old, blind hog sometimes finds an acorn"
Initially, Sarver stuck to the vintage toys and ceramics she owned. However, she eventually "graduated" to other items, like books and figurines. She admits that she's also drawn to unique products that other sellers seem to shy away from because they aren't familiar with them. For instance, she once bought a wooden rabbit figure she found at an estate sale. It was on sale and featured a "Made in Demark" label.
Sarver didn't know much about the bunny, but she took a gamble and bought the critter. After researching it, she learned the figure was a Danish modern piece from a well-known designer.
"I sold it on eBay for $175," she recalls. "My best friend, who also sells on eBay and Bonanza, often laughs at me about items I purchase, and I always remind her that even an old, blind hog sometimes finds an acorn."
Sarver adds that she also favors paper products because they're easy to ship, photograph or scan, and can be very profitable, as a torn photo of an early Texas A&M University football team proved. It sold for more than $200 on eBay.
On average, the seller has between 500 and 700 items for sale on Bonanza every week. She posts anywhere from 300 to 400 items on eBay, she notes.
To catch buyers' eyes, Sarver provides interesting titles in her listings and quality photos that show every angle of an item, she notes. Good customer service and properly packed shipments also help encourage buyers to come back.
"I have learned that some of my customers collect, so I contact them when I list some things they might be interested in purchasing," she adds.
She loves communicating with buyers. It's this, combined with the ability to bring in extra income, share her finds with others and learn about the items she uncovers that make selling online so fun.
"I like to place items with people who will appreciate them," Sarver notes.
For instance, there was the time she sold an art deco fountain pen she had inherited on eBay.
"A professor in Arizona contacted me immediately, and told me about his fountain pen collection and how the pen would be the jewel of his collection," she recalls. "He said he and his little son went out on the weekends hunting for treasures, and he had been looking for this pen for years."
The two emailed back and forth several times, and Sarver learned about fountain pens, information she now uses to look for certain pens.
Her advice to those thinking of starting their own online business? "Research, research, research," she says. "That means look into the online sales site completely and see what costs are involved. Also, research your items to see if they will sell on the site and what you can expect to receive for them."
Hurricanes bring set-backs
"Research the site completely and see what costs are involved. Also, research your items to see if they will sell on the site"
In her more than 13 years of selling, Sarver has had challenges. Some have come from trying to make buyers happy, others from Mother Nature. In fact, two of them came in the form of natural disasters: Hurricane Rita and Hurricane Ike. When Rita hit, Sarver didn't have a laptop, so when she had to evacuate her home, she took her computer tower and headed to a friend's house in Vicksburg, MS, she notes.
Luckily, Sarver didn't have many items listed at the time—she might have had fewer than 20 items, she notes—but she contacted each of her bidders and told them not to pay for their items until she contacted them.
"I did not know if the items or my home would be intact when I got home," she explains. "Thank goodness everyone was very understanding since I was without electricity for nearly a month."
The hurricane hit Sarver's property hard. It tore down 18 large trees on her lot. Not too far away, her brother's house had trees fall on top of it, damaging the house and prompting him to move in with Sarver during repairs.
"A storage building on my land took a tree on half of it, and so a number of items I had purchased for resale were damaged," she notes. "The good part of the incident was that my family would find a hotel room each weekend and go there until we got electricity back. We always tried to go someplace near areas that had good antique malls, so I could go shopping."
Sarver's brother lived with her for eight months while his house was repaired. To thank her, he gave Sarver her first laptop so she would have a portable way of checking on her online sales, should another natural disaster hit.
Two years later, Hurricane Ike blew in. Sarver and her family were evacuated to Arkansas. This time, she used her laptop to keep up with sales and monitor flooding in her area. At that time, she also had a booth in a brick-and-mortar antique mall.
She soon got a call from the store, letting her know that the "tornado had ripped back the roof and turned over shelving, breaking glass and ceramics, and wetting my paper items," she recalls.
A storage building on her property was also damaged when a tree fell on it. Salvageable items had to be moved to the garage, she says. Luckily, the electricity was up sooner this time than after Hurricane Rita, she notes. eBay had also posted a note on its site, informing buyers that storms might impact communication with buyers and sellers in Southeast Texas and Southwest Louisiana. Both hurricanes hurt Sarver's sales since she was unable to list items, and she had to tend to repairs on her property after the storms, pulling her away from her sales. But she considers herself lucky.
"I did not lose any items I had sold and all my buyers were understanding about the delay," Sarver says.
Visit Shemaw's Stuff on Bonanza and eBay.
Olga Munoz is editor of TheOnlineSeller.com. In addition to writing news and feature articles about e-commerce, selling trends, online marketing and other topics of interest to online sellers, Olga manages the site's social media efforts. A journalism graduate of Chico State, Olga says her favorite part of being a journalist is learning interesting facts that help put stories into perspective, attending industry events and meeting interesting people "that leave you smiling, even in tough situations." Opinions expressed here may not be shared by The Online Seller and/or its principals.
July 18, 2019 · No comments
← An Antisocial Look at Social Media
Tias.com Voted Best Place to Buy Collectibles →


text:
Home > Naked > Jo ann harris naked
Jo ann harris naked
Uncensored leaked nudes
Mischa Barton has developed an extensive filmograp She has a topless scene near the 60 minute mrk and her breast and nipple can be seen from the side. Kelly kelly sexy nude. However, in my opinion, her perfect legs make up for the lack of that. Joanne Arnold Joanne Arnold is an American actress and model.
She has also previously worked as BBC A band leader and pioneer in jazz percussion, Jones anchored the Count Basie Orchestra rhythm section from to Skin Quicklinks to other nakes celebs that you might find interesting: A couple of minutes later one of her breasts pops out when someone grabs her arm.
She is the Irish metres outdoor women's record holder with a time of She has a love scene with Clint Eastwood at the 69 minute mark. Shortly after the 70 minute makr she takes off her top with her back towards the camera. Jo ann harris naked. Sadly, the first time we see any of it, aside from a nice walkaway in shorts, is when she is being raped. As of March more than 3 million copies of his novels have been sold in Norway, and his work has been translated Not a ringing endorsement toward rape scenes, but the subject is handled so poorly I just hard for me to take it seriously.
For this role she All our nude female celebrities: How many celebrities named Joanne can you think of? Her young, firm, and bulbous boobies were out for all to see, but they didn't get a rise for her co-star, who was trying to avoid the draft by pretending to be There are naked pics and topless videos of Jo Ann Harris here All our nude female celebrities: He is currently touring the college circuit as a featured comedian and performs in clubs across the country.
She took part in beauty pageants, becoming Miss Limerick Photogenic, then Miss Ireland inat the age The famous Joannes below have many different professions, as this list includes notable actors named Joanne, athletes named Joanne, and even political figures named Joanne.
It's a bit dark but you can see her very pointy and puffy nipple. She has charted nine number one singles on the Billboard country music charts. Jo Ann Harris nude pictures and movies.
She has been honored by the Country Music Association, Known primarily for playing roles older than she was, her career spanned over three decades, and she won an Academy Award as well as a Tony She won the John W.
Big boobs big ass naked
Public selfies nude
Naked kombat free videos
Set of sexy girls
Nude sex shower
Lesbian videos and movies
Skin Quicklinks to other nakes celebs that you might find interesting: All our nude female celebrities: Shortly after the 70 minute makr she takes off her top with her back towards the camera.
A band leader and pioneer in jazz percussion, Jones anchored the Count Basie Orchestra rhythm section from to She is the Irish metres outdoor women's record holder with a time of Member Login Sign in not a member? Jo Ann Harris nude pictures and movies. If your name is Joanne, then you're in some great company.
He is best known for his leading roles in the films The Classic, Marathon, and Tazza: She has a topless scene near the 60 minute mrk and her breast and nipple can be seen from the side.
For this role, she has received Thank you for visiting our page about Jo Ann Harris we hope you liked it. Milf gangbang sex stories. Back to the main page for a full list of celebs. Admired for the purity of her As of March more than 3 million copies of his novels have been sold in Norway, and his work has been translated Joanne Whalley Joanne Whalley is an English actress.
To read more about these notable people named Joanne, click the corresponding row of who you want to learn more about, and additional information will appear. Only her breasts are shown and it's a bit dark. Born in Los Angeles, she is known for her role in the film The Beguiled as the sultry year-old Carol who seduces Clint Eastwood's character.
Which famous people named Joanne are worth mentioning? Her young, firm, and bulbous boobies were out for all to see, but they didn't get a rise for her co-star, who was trying to avoid the draft by pretending to be There are naked pics and topless videos of Jo Ann Harris here All our nude female celebrities: However, in my opinion, her perfect legs make up for the lack of that.
Starting her entertainment career with a move from psychiatric nursing to the alternative comedy stand-up scene Later, she joins several other women for a soak in a hot tub. She has been honored by the Country Music Association, Around the 50 minute mark she strips to take a shower.
Gay Deceivers, The She was Playboy magazine's Playmate of the Month for the May issue. Jo ann harris naked. Jo Guest Joanne Guest is an English former glamour model and media figure.
Pieman was written on June 18,
See more tits
Male escorts for women uk
Urban decay naked ultimate basics eyeshadow palette
Black milf video tumblr
Black lesbian girls having sex
Doctor fuck milf
Black and spanish lesbians
Pussy lesbian black
Calum worthy naked
Mona singh nude pics
Carly simon tits
Bbw College Amateur Big ass. Videos De Brasileiras 7. Let grandma feast on your cock Models 4 U Mature BBW in lingerie masturbates with dildo Channels: All of the videos displayed on our site are hosted by websites that are not under our control. Five Star Porn Sites Free Video Hd Mature bbw shows her big tits on free online cams Channels: Mature BBW takes dick in mouth and cunt Channels: Amateur Indian Mature Couple Fuck 4: British bbw fingerfucked until squirting
mentesanavidarica.com © 2013-2017 Jo ann harris naked.


Which Gran Canaria airport do flights land in?
Flights most commonly land at Gran Canaria Las Palmas Airport, 12 miles (19km) south of Las Palmas.
Are there direct flights between the UK and Gran Canaria?
There are direct flights between Gran Canaria and several UK cities.
How long is the flight from the UK to Gran Canaria?
A direct flight from London to Gran Canaria takes just over four hours.
What is the time difference between the UK and Gran Canaria?
There is no time difference between London and Gran Canaria.
The airport is situated 13 miles (21km) south of Las Palmas.
The airport is located five miles (8km) south of Santa Cruz La Palma.


2. Do you have a 9/11 "covered illness" such as cancer, breathing problems, or digestive issues?
and many more. (See below for most recent updated list from the Victim Compensation Fund (VCF)).
View the full list of covered cancers and breathing/digestive conditions.
*Note: Generally, the "9/11 Crash Site Area" includes the World Trade Center site, Pentagon site, and Shanksville, Pennsylvania site, downtown Manhattan below Canal Street west to the Hudson River and east below Clinton Street to the East River. In addition, the crash site include the Fresh Kills landfill on Staten Island, the trucks and barges that removed 9/11 debris, places where emergency vehicles were cleaned, and the New York City Morgue.
In general, anyone with a covered illness who was present in Downtown Manhattan below Canal Street, the Fresh Kills landfill, on or near the barges/trucks that moved debris, the NYC Morgue, or garages where emergency vehicles were cleaned; or responded to the Pentagon or Shanksville, PA crash sites between the dates of September 11, 2001 and May 30, 2002 may be eligible for free lifetime healthcare and a financial award. Medical benefits and financial awards for 9/11 cancer claims depend on whether all eligibility criteria is satisfied and the strict registration deadline is met. Our 9/11 victims compensation fund lawyers can assist you with the process.
In addition, the "crash site area" or exposure zone under the World Trade Center Health Program is larger than the exposure zone for the VCF. The WTCHP exposure zone includes a section of downtown Brooklyn (the Brooklyn Heights area) and includes all of lower Manhattan south of Houston Street.
Which First Responders are Eligible?


You are invited to join our marriage class on Wednesdays at 7pm.
Every marriage has it's different seasons, it's ups and downs. It's important to connect with leadership that you can trust, and with friends that will encourage and lift you up. Metro's Marriage Ministries, led by Tracy and Debra Adams, is just the place.
Real people with real experiences. Come join us for love, laughter, and good friends.


Soccer is an active game. It requires physical effort, mental concentration and the execution of varied techniques often under a physical challenge. While it serves a purpose, passive training, i.e. passing a ball back and forth, dribbling through cones doesn't come close to duplicating the demands of the actual game. A certain level of physical confrontation, challenge is necessary. This element is called "Rough and Tumble Play" and it serves a very important purpose in human growth and development. Below is some guidance on what it is and is not.
Expert Advice - Greg Uba - Former Kindergarten and Pre-K teacher.
"Rough and tumble play allows kids to take some risks, as far as physical activity. Adults are sometimes uncomfortable with rough and tumble play because, to them, it symbolizes aggression, whereas to children, it symbolizes competence. Adults have forgotten how to play and instead construe the rough play as aggression and conflict.
Rough and tumble play is different from aggression. Kids aren't always smiling during rough and tumble play – sometimes they're working hard to demonstrate their ability to be competent – but generally, it's in the spirit of play. Aggression has a spirit of dominating and intimidation.
Boys find it especially appealing because rough and tumble play addresses their need for power and motor skills competence. They're imitating what society gives them as male role models. Often, they're imitating how adults play with them at home. For boys, it gives them an opportunity to touch each other. Society doesn't give men and boys the opportunity to touch each other. Rough and tumble play enables men to have contact with each other in a way that society agrees with.
A child care provider should manage rough and tumble play so it doesn't turn into aggression. You should constantly supervise the play and have children help come up with the rules. Make it part of the structured day. Rough and tumble play doesn't have to always involve touching other children or being combative. It can be a noisy center with cans to kick, or plastic bottles to throw against. It can be an obstacle course or even a punching pillow. It could be lifting medicine balls or running with 5 pounds of flour.
A child care provider should make sure the play doesn't turn negative by checking in with them regularly. Ask the kids, "Are you playing or are you fighting? Do you both agree with this play?" Give both of the kids the opportunity to option out of the activity. Children are exposed to too much media violence which could negatively influence their rough play. Our society is moving toward where everything needs to be more and more extreme. It's something society has to reflect upon as far as the images that are presented to children. Kids can wind up getting frustrated, however, if you don't let them have an outlet for their energy. Rough and tumble play can help provide that release."
Of course we all need some peace and quiet sometimes, and no one wants children to get hurt, but do rough-and-tumble play, or 'play-fighting', have a place too?
Boys especially often love rough play. A play-fight is not the same as bullying or real fighting. A play-fight can last from 20-60 minutes or more and everyone will still be friends at the end. A real fight lasts about 3 minutes and can be physically and emotionally painful.
Studies have shown that rough-and-tumble play actually helps children to develop. Through play-fighting children can learn to control their emotions, bodies, expression and anger. They learn their own limits and those of others so that they don't lose control and hurt themselves or others.
Therefore it can be important to allow children time and space where they can just let rip and make as much noise as they like. So long as no one gets hurt, it doesn't need to be stopped - and it could just help you get some peace and quiet later on!
Risk-taking is a powerful way of learning. When we take a risk, we face success or failure. Success raises our self-esteem. Failure may hurt, but it teaches us to do things differently next time. Children need to learn to make sensible choices as they get older and sometimes this takes a few mistakes.
Of course adults need to limit the risks children take to prevent serious injuries. Ideally, though, we shouldn't remove risks completely. We can't prevent every injury, and minor ones can be a useful learning experience, after all.
In an article published in the April issue of Current Directions in Psychological Science, Sergio and Vivian Pellis of the University of Lethbridge reviewed multiple studies involving animals, and found a link between rough and tumble play and social competence.
Coordinated movements appear to suffer in the absence of rough and tumble play as well. Rats, as most other mammals, rely heavily on coordinated movement for both cooperative and competitive situations. Rats that are reared in isolation have impaired ability to coordinate their movements appropriately with opponents. This coordination, say the authors, can be learned through the constantly shifting body motions that take place during playfighting.
Deprivation from peer interaction appears to have neurological consequences as well. Juvenile play fighting has been found to stimulate the release of certain chemical growth factors in the cerebral cortex, an area the authors describe as the "social brain." Among the structures in the social brain is the orbitofrontal cortex, an area known to be involved in social discrimination and decision. As logic would tell us, the less growth is promoted in this area, the greater the likelihood of impaired movement coordination, perception of social cues, and the like.
"The knowledge thus gained," writes Pellis "can provide the clues to the correlated consequences of those processes that can be studied in humans."
The above was written from a news release by Association for Psychological Science.
University of Pittsburg advice on Rough Play.
Evolutionary Psychology "Rough and Tumble" Play: Lessons in Life.
Raising Children Network | Rough-and-tumble play.
Risky Play Among Four- And Five Year Olds in Preschool.
Rough and Tumble Play, with love. Don Ratcliffe.
Rough and tumble, Local women tackling a tough sport, The Boston Globe.
Morning Edition, October 25, 2006 · School administrators have gone to ludicrous extremes to protect children. For instance, school districts in Wyoming, Washington state and California have banned the game of tag during recess.
All Things Considered, May 11, 2001 · Commentator Stephen Lynch can't believe that some schools around the country are banning dodgeball. He thinks this trend toward making childhood "safe" coddles kids.


My first year of college was transformational, weird, and wonderful.
I had moved 12 hours away from my family to attend a college where I knew 2 people, in a state I had been to twice. It was terrifying yet thrilling.
But one of the most frightening things was walking into a dining hall as a freshman.
I would walk into a dining hall for lunch or dinner those first few months of college and become absolutely terrified. After surveying all the options, circling the dining hall a few times, then deciding exactly what I wanted, I would more often than not get my food to-go and eat it back in my dorm while watching America's Next Top Model. Dining halls were scary. They were filled with lines, and so many choices, and more intimidatingly, people I didn't know... who didn't know me, but seemed to know each other very, very well.
My first couple of months of college were filled with lonely meals. Not because I didn't have friends yet or because I was anti-social, but because I didn't know where my family was.
You see, I had spent the first 18 years of my life coming home from school and having dinner with my family. That's just how things worked in my house. Meals were connect times with people who loved me and wanted to hear about my life. And college was seeming to be a place where I'd have to go without them.
But there's a shift that happens that no one tells you about towards the middle of your freshmen year. You realize that you can still have your family. It's just going to look a little different now.
You have to allow your friends to become your family.
This wasn't an overnight thing for my friend group. It was a gradual thing that came after we had all subconsciously made some choices. And even now, as a young adult, I'm finding we still have to make these choices in order to keep having family. But as a young adult, these decisions must be way more intentional.
1. We decided to eat together. It sounds simple, but there is something about having a meal together that bonds people. Shauna Niequist says it best: "When we stop everything else to gather around the table and eat a meal..., we honor our bodies and the God who created them... And in that moment we acknowledge that even though life is fast and frantic, we're not machines and we do require nourishment, physically and otherwise." You must make an effort to eat meals with your friends. Cook for them. Let them cook for you. Sit at a table with them and enjoy every bit of the meal and company that is placed in front of you.
2. We decided to be honest with each other. Enough with the word "fine." When someone asks you how your day is, believe that they actually want to know. They don't want to hear that your day was "fine." "Fine" is the most generic and superficial answer we can give. But when we choose to believe someone cares about our day, walls are brought down and family is formed. It allows bonds to be made that proclaim "I know the season you're in. I get it. I'm with you in it."
3. We decided to run errands together. My friend, Jeff, is a prime example of this. We became friends our first week of college, but he quickly became family. I'm pretty sure I ran more errands with him than any of my other friends... possibly even my real family; trips to WalMart, HEB, the mall, Jimmy John's, wherever. He became my brother because we were together and doing the boring, mundane stuff of life together. You get to know people really well after you take a trip to Target with them. And then I started thinking how different college would've been if I had run those errands alone. Don't run errands alone, friends. Drag someone along. Chances are, they need toilet paper too.
4. We decided to become texters. If you aren't a texter now, start becoming one. Some people are anti-group-text but I am ALL about them. It's an amazing thing to have a piece of communication where plans can be organized and everyone can be in on it. Yes, your group-texts will sometimes go off into rabbit-trails about the latest Iron Man movie or why creamy peanut butter is way better than crunchy. Just let it happen. While we're talking about this, let me add - you should respond to texts! Send people "How's your day going?" texts. Be intentional. And yes, you have time for this. It takes about 15 seconds to send a text.
5. We decided to show up. It didn't matter who was initiating the hang out... it didn't matter if I knew 2 or 20 people there... it didn't matter if I had no interest in the movie we were watching or the restaurant we were going to... if I was available, I showed up. As a "family", we became committed to celebration - the big and little things. We chose to mourn with each other when things were hard. We came to performances, dinners with parents, birthday parties, prayer times. We decided to be there... when it was most difficult, when life was crazy, when we were tired. We chose to be there.
6. We decided not to run away when things got hard. And things DID get hard. Disagreements were had. Breakups happened. Awkward conversations were braved. But we chose to press in when things got uncomfortable. We didn't stop showing up because things were awkward. We didn't stop showing up because we were offended. We had the hard, necessary, clarifying conversations. We tried our hardest to accept correction with humility and not pride. We stayed vulnerable. We forgave. We extended grace to each other in our messiness and mistakes. We learned how to do life together, not alone.
The key was pressing in.. being present.. acknowledging the now moments and living fully awake in them. It was being free from comparison by celebrating the accomplishments of another "family" member. It was realizing that each person, despite their own weaknesses, had something entirely unique that the "family" needed. It was loving the imperfections, walking through the mess, and allowing your friends to become one of closest families you've know.


Diniz G, Aktaş S, Ortaç R, Erbay A, Vergin C, Ergin M. Alternative prognostic factors in pediatric embryonal rhabdomyosarcoma: Nm23 expression, proliferative activity and angiogenesis. Turk J Pediatr 2004; 46: 239-244.
Possible clinical relevance of Nm23 expression, angiogenesis and proliferative activity were evaluated as prognostic parameters in childhood embryonal rhabdomyosarcoma (RMS).
Specimens of 25 RMS cases were studied for Nm23 antigen immunohistochemically. Vascular surface density (VSD) and number of vessels per stroma (NVES) calculated by stereologic methods on labeling sections with CD34 antibody. For evaluation of proliferative activity of tumors, mitotic figures and Ki67 positive cells were investigated. All findings were searched statistically.
Five patients were stage 1 (20%), two were stage 2 (8%), 15 were stage 3 (60%) and three were stage 4 (12%). The mean event free survival (EFS) was 20.8 and the mean overall survival (OS) was 25.9 months. Sixteen patients (64%) were alive and without disease. The percentage of Nm23 positivity was 52%. Log rank analysis showed Nm23 as a predictor for survival (p=0.0313). In Pearson correlation analysis, there was statistical significance between OS and presence of Nm23 expression (p=0.044). VSD was also positively related with EFS (p=0.040).
Despite the present parameters in use, there is a need for new prognostic markers, especially to predict the outcome of patients. These findings suggested that Nm23 expression and VSD might be useful for follow-up in RMS.


United States Masters Swimming (USMS) is a national organization that provides organized workouts, competitions, clinics and workshops for adults aged 18 and over. Programs are open to all adult swimmers (fitness, triathlete, competitive, non-competitive) who are dedicated to improving their fitness through swimming. All USMS programs are designed to help swimmers improve fitness and/or train for specific goals, and offer active support for a healthy lifestyle through friendship, and camaraderie.