text:
using namespace xbox::services::tournaments;

NAMESPACE_MICROSOFT_XBOX_SERVICES_MULTIPLAYER_CPP_BEGIN

multiplayer_session::multiplayer_session() :
    m_membersAccepted(0),
    m_joiningSession(false),
    m_newSession(false),
    m_initializationStage(multiplayer_initialization_stage::unknown),
    m_initializationEpisode(0),
    m_hasMatchmakingServer(false),
    m_changeNumber(0)
{
    m_servers = web::json::value::object();
    m_sessionConstants = std::make_shared<multiplayer_session_constants>();
    m_sessionRequest = std::make_shared<multiplayer_session_request>();
    m_multiplayerSessionProperties = std::make_shared<multiplayer_session_properties>();
    m_sessionRoleTypes = std::make_shared<multiplayer_session_role_types>();
}

multiplayer_session::multiplayer_session(
    _In_ string_t xboxUserId
    ) :
    m_xboxUserId(std::move(xboxUserId)),
    m_membersAccepted(0),
    m_joiningSession(false),
    m_newSession(true),
    m_initializationStage(multiplayer_initialization_stage::unknown),
    m_initializationEpisode(0),
    m_hasMatchmakingServer(false),
    m_changeNumber(0)
{
    XSAPI_ASSERT(!m_xboxUserId.empty());
    _Initialize(m_xboxUserId);
}

multiplayer_session::multiplayer_session(
    _In_ string_t xboxUserId,
    _In_ multiplayer_session_reference sessionReference
    ) :
    m_xboxUserId(std::move(xboxUserId)),
    m_sessionReference(std::move(sessionReference)),
    m_newSession(true),
    m_membersAccepted(0),
    m_joiningSession(false),
    m_initializationStage(multiplayer_initialization_stage::unknown),
    m_initializationEpisode(0),
    m_hasMatchmakingServer(false),
    m_changeNumber(0)
{
    XSAPI_ASSERT(!m_xboxUserId.empty());

    _Initialize(m_xboxUserId);
    m_sessionRequest->set_session_reference(m_sessionReference);
}

multiplayer_session::multiplayer_session(
    _In_ string_t xboxUserId,
    _In_ multiplayer_session_reference sessionReference,
    _In_ std::vector<string_t> initiatorXboxUserIds
    ) :
    m_xboxUserId(std::move(xboxUserId)),
    m_sessionReference(std::move(sessionReference)),
    m_newSession(true),
    m_membersAccepted(0),
    m_joiningSession(false),
    m_initializationStage(multiplayer_initialization_stage::unknown),
    m_initializationEpisode(0),
    m_hasMatchmakingServer(false),
    m_changeNumber(0)
{
    XSAPI_ASSERT(!m_xboxUserId.empty());

    _Initialize(m_xboxUserId);

    m_sessionConstants = std::make_shared<multiplayer_session_constants>(initiatorXboxUserIds);
    m_sessionRequest->set_session_constants(m_sessionConstants);
    m_sessionRequest->set_session_reference(m_sessionReference);
}

multiplayer_session::multiplayer_session(
    _In_ string_t xboxUserId,
    _In_ multiplayer_session_reference sessionReference,
    _In_ uint32_t maxMembersInSession,
    _In_ multiplayer_session_visibility multiplayerSessionVisibility,
    _In_ std::vector<string_t> initiatorXboxUserIds,
    _In_ web::json::value sessionCustomConstantsJson
    ) :
    m_xboxUserId(std::move(xboxUserId)),
    m_sessionReference(std::move(sessionReference)),
    m_newSession(true),
    m_membersAccepted(0),
    m_joiningSession(false),
    m_initializationStage(multiplayer_initialization_stage::unknown),
    m_initializationEpisode(0),
    m_hasMatchmakingServer(false),
    m_changeNumber(0)
{
    XSAPI_ASSERT(!m_xboxUserId.empty());

    XSAPI_ASSERT(
        multiplayerSessionVisibility >= multiplayer_session_visibility::any &&
        multiplayerSessionVisibility <= multiplayer_session_visibility::open
        );

    _Initialize(m_xboxUserId);

    web::json::value sessionCustomConstants;
    if (!sessionCustomConstantsJson.is_null())
    {
        sessionCustomConstants = std::move(sessionCustomConstantsJson);
    }
    m_sessionConstants = std::make_shared<multiplayer_session_constants>(
        maxMembersInSession,
        multiplayerSessionVisibility,
        initiatorXboxUserIds,
        sessionCustomConstants
        );

    m_sessionRequest->set_session_constants(m_sessionConstants);
    m_sessionRequest->set_session_reference(m_sessionReference);
}

std::shared_ptr<multiplayer_session> multiplayer_session::_Create_deep_copy()
{
    auto copy = std::make_shared<multiplayer_session>();
    copy->deep_copy_from(*this);
    return copy;
}

void multiplayer_session::deep_copy_from(
    _In_ const multiplayer_session& other
    )
{
    m_xboxUserId = other.m_xboxUserId;
    m_sessionReference = other.m_sessionReference;
    m_sessionConstants = other.m_sessionConstants;
    m_arbitrationStatus = other.m_arbitrationStatus;
    m_sessionRoleTypes = other.m_sessionRoleTypes;
    m_servers = other.m_servers;
    m_membersAccepted = other.m_membersAccepted;
    m_correlationId = other.m_correlationId;
    m_searchHandleId = other.m_searchHandleId;
    m_eTag = other.m_eTag;
    m_joiningSession = other.m_joiningSession;
    m_newSession = other.m_newSession;
    m_startTime = other.m_startTime;
    m_dateOfSession = other.m_dateOfSession;
    m_matchmakingServer = other.m_matchmakingServer;
    m_hasMatchmakingServer = other.m_hasMatchmakingServer;
    m_sessionSubscriptionGuid = other.m_sessionSubscriptionGuid;
    m_branch = other.m_branch;
    m_changeNumber = other.m_changeNumber;
    m_writeSessionStatus = other.m_writeSessionStatus;
    m_nextTimer = other.m_nextTimer;
    m_initializationStage = other.m_initializationStage;
    m_initializationStageStartTime = other.m_initializationStageStartTime;
    m_initializationEpisode = other.m_initializationEpisode;
    m_hostCandidate = other.m_hostCandidate;
    m_tournamentsServer = other.m_tournamentsServer;
    m_arbitrationServer = other.m_arbitrationServer;

    m_memberCurrentUser = other.m_memberCurrentUser == nullptr ? nullptr : other.m_memberCurrentUser->_Create_deep_copy();
    m_sessionRequest = other.m_sessionRequest == nullptr ? nullptr : other.m_sessionRequest->create_deep_copy();
    m_members = std::vector<std::shared_ptr<multiplayer_session_member>>();

    bool lookForMe = true;
    for (const auto& member : other.m_members)
    {
        std::shared_ptr<multiplayer_session_member> memberCopy = std::make_shared<multiplayer_session_member>();
        memberCopy = member->_Create_deep_copy();
        memberCopy->_Set_session_request(m_sessionRequest);
        if (lookForMe)
        {
            bool isMe =
                utils::str_icmp(memberCopy->xbox_user_id(), m_xboxUserId) == 0;
            if (isMe)
            {
                lookForMe = false;
                std::shared_ptr<multiplayer_session_member_request> memberRequest = m_sessionRequest->add_member_request(
                    false,
                    isMe,
                    m_xboxUserId,
                    web::json::value(),
                    false,
                    false
                    );

                memberCopy->_Set_member_request(memberRequest);
                memberCopy->_Set_is_current_user(true);
                memberCopy->_Set_current_user_status(member->status());
                m_memberCurrentUser = memberCopy;
            }
        }
        m_members.push_back(memberCopy);
    }

    m_multiplayerSessionProperties->_Deep_copy(*(other.m_multiplayerSessionProperties));
    m_multiplayerSessionProperties->_Initialize(
        m_sessionRequest,
        m_members
        );
}

void multiplayer_session::_Initialize(
    _In_ string_t xboxUserId
    )
{
    m_xboxUserId = std::move(xboxUserId);
    m_servers = web::json::value::object();
    m_sessionConstants = std::make_shared<multiplayer_session_constants>();
    m_multiplayerSessionProperties = std::make_shared<multiplayer_session_properties>();
    m_sessionRoleTypes = std::make_shared<multiplayer_session_role_types>();
    m_sessionRequest = std::make_shared<multiplayer_session_request>(m_sessionConstants);

    m_multiplayerSessionProperties->_Initialize(
        m_sessionRequest,
        m_members
        );

    ensure_session_subscription_id_initialized();
}

void
multiplayer_session::_Initialize_after_deserialize(
    _In_ string_t eTag,
    _In_ string_t responseDate,
    _In_ multiplayer_session_reference sessionReference,
    _In_ string_t xboxUserId
    )
{
    m_eTag = std::move(eTag);
    m_dateOfSession = utility::datetime::from_string(responseDate, utility::datetime::date_format::RFC_1123);
    m_sessionReference = std::move(sessionReference);
    m_xboxUserId = std::move(xboxUserId);
    m_sessionRequest->set_session_reference(m_sessionReference);

    ensure_session_subscription_id_initialized();
    if (!m_members.empty())
    {
        bool lookForMe = true;
        for (auto& member : m_members)
        {
            member->_Set_session_request(m_sessionRequest);
            if (lookForMe)
            {
                bool isMe =
                    utils::str_icmp(member->xbox_user_id(), m_xboxUserId) == 0;
                if (isMe)
                {
                    lookForMe = false;
                    std::shared_ptr<multiplayer_session_member_request> memberRequest = m_sessionRequest->add_member_request(
                        false,
                        isMe,
                        m_xboxUserId,
                        web::json::value(),
                        false,
                        false
                        );

                    member->_Set_member_request(memberRequest);
                    member->_Set_is_current_user( true );
                    m_memberCurrentUser = member;
                }
            }
        }
    }
}

std::shared_ptr<multiplayer_session_request>
multiplayer_session::_Session_request() const
{
    return m_sessionRequest;
}

const string_t&
multiplayer_session::multiplayer_correlation_id() const
{
    return m_correlationId;
}

const string_t&
multiplayer_session::search_handle_id() const
{
    return m_searchHandleId;
}

tournament_arbitration_status
multiplayer_session::arbitration_status() const
{
    return m_arbitrationStatus;
}

utility::datetime
multiplayer_session::start_time() const
{
    return m_startTime;
}

utility::datetime
multiplayer_session::date_of_next_timer() const
{
    return m_nextTimer;
}

utility::datetime
multiplayer_session::date_of_session() const
{
    return m_dateOfSession;
}

multiplayer_initialization_stage
multiplayer_session::initialization_stage() const
{
    return m_initializationStage;
}

utility::datetime
multiplayer_session::initializing_stage_start_time() const
{
    return m_initializationStageStartTime;
}

uint32_t
multiplayer_session::intializing_episode() const
{
    return m_initializationEpisode;
}

multiplayer_session_change_types
multiplayer_session::subscribed_change_types() const
{
    if (m_memberCurrentUser == nullptr)
    {
        return multiplayer_session_change_types::none;
    }
    return m_memberCurrentUser->_Subscribed_change_types();
}

std::vector<string_t>
multiplayer_session::host_candidates() const
{
    return m_hostCandidate;
}

const multiplayer_session_reference&
multiplayer_session::session_reference() const
{
    return m_sessionReference;
}

std::shared_ptr<multiplayer_session_constants>
multiplayer_session::session_constants() const
{
    return m_sessionConstants;
}

std::shared_ptr<multiplayer_session_properties>
multiplayer_session::session_properties() const
{
    return m_multiplayerSessionProperties;
}

std::shared_ptr<multiplayer_session_role_types>
multiplayer_session::session_role_types() const
{
    return m_sessionRoleTypes;
}

const std::vector<std::shared_ptr<multiplayer_session_member>>&
multiplayer_session::members() const
{
    return m_members;
}

const multiplayer_session_matchmaking_server&
multiplayer_session::matchmaking_server() const
{
    return m_matchmakingServer;
}

const multiplayer_session_tournaments_server&
multiplayer_session::tournaments_server() const
{
    return m_tournamentsServer;
}

const multiplayer_session_arbitration_server&
multiplayer_session::arbitration_server() const
{
    return m_arbitrationServer;
}

uint32_t
multiplayer_session::members_accepted() const
{
    return m_membersAccepted;
}

const web::json::value&
multiplayer_session::servers_json() const
{
    return m_servers;
}

void
multiplayer_session::set_servers_json(
    _In_ const web::json::value& serversJson
    )
{
    m_servers = serversJson;
    m_sessionRequest->set_servers(m_servers);
}

const string_t&
multiplayer_session::e_tag() const
{
    return m_eTag;
}

std::shared_ptr<multiplayer_session_member>
multiplayer_session::current_user() const
{
    return m_memberCurrentUser;
}

const string_t&
multiplayer_session::branch() const
{
    return m_branch;
}

uint64_t
multiplayer_session::change_number() const
{
    return m_changeNumber;
}

write_session_status
multiplayer_session::write_status() const
{
    return m_writeSessionStatus;
}

void
multiplayer_session::_Set_write_session_status(
    int32_t httpStatusCode
    )
{
    m_writeSessionStatus = convert_http_status_to_write_session_status(httpStatusCode);
}

std::error_code
multiplayer_session::add_member_reservation(
    _In_ const string_t& xboxUserId,
    _In_ const web::json::value& memberCustomConstantsJson
    )
{
    return add_member_reservation_helper(
        xboxUserId,
        memberCustomConstantsJson,
        false,
        false
        );
}

std::error_code
multiplayer_session::add_member_reservation(
    _In_ const string_t& xboxUserId,
    _In_ const web::json::value& memberCustomConstantsJson,
    _In_ bool initializeRequested
    )
{
    return add_member_reservation_helper(
        xboxUserId,
        memberCustomConstantsJson,
        true,
        initializeRequested
        );
}

xbox_live_result<std::shared_ptr<multiplayer_session_member>>
multiplayer_session::join(
    _In_ const web::json::value& memberCustomConstantsJson,
    _In_ bool initializeRequested,
    _In_ bool joinWithActiveStatus,
    _In_ bool addInitializePropertyToRequest
    )
{
    return join_helper(
        memberCustomConstantsJson,
        addInitializePropertyToRequest,
        initializeRequested,
        joinWithActiveStatus
        );
}

void
multiplayer_session::set_visibility(
    _In_ multiplayer_session_visibility visibility
    )
{
    m_sessionConstants->set_visibility(visibility);
}

void
multiplayer_session::set_max_members_in_session(
    _In_ uint32_t maxMembersInSession
    )
{
    m_sessionConstants->set_max_members_in_session(maxMembersInSession);
}

std::error_code
multiplayer_session::set_timeouts(
    _In_ std::chrono::milliseconds memberReservedTimeout,
    _In_ std::chrono::milliseconds memberInactiveTimeout,
    _In_ std::chrono::milliseconds memberReadyTimeout,
    _In_ std::chrono::milliseconds sessionEmptyTimeout
    )
{
    // Call set_timeouts/SetTimeouts before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_timeouts(
        memberReservedTimeout,
        memberInactiveTimeout,
        memberReadyTimeout,
        sessionEmptyTimeout
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_arbitration_timeouts(
    _In_ std::chrono::milliseconds arbitrationTimeout,
    _In_ std::chrono::milliseconds forfeitTimeout
    )
{
    // Call set_arbitration_timeouts/SetArbitrationTimeouts before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_arbitration_timeouts(
        arbitrationTimeout,
        forfeitTimeout
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_quality_of_service_connectivity_metrics(
    _In_ bool enableLatencyMetric,
    _In_ bool enableBandwidthDownMetric,
    _In_ bool enableBandwidthUpMetric,
    _In_ bool enableCustomMetric
    )
{
    // Call set_quality_of_service_connectivity_metrics/SetQualityOfServiceConnectivityMetrics
    // before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_quality_of_service_connectivity_metrics(
        enableLatencyMetric,
        enableBandwidthDownMetric,
        enableBandwidthUpMetric,
        enableCustomMetric
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_managed_initialization(
    _In_ std::chrono::milliseconds joinTimeout,
    _In_ std::chrono::milliseconds measurementTimeout,
    _In_ std::chrono::milliseconds evaluationTimeout,
    _In_ bool autoEvaluate,
    _In_ uint32_t membersNeededToStart
    )
{
    // Call set_managed_initialization/SetManagedInitialization before writing a new session to the service");
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_managed_initialization(
        joinTimeout,
        measurementTimeout,
        evaluationTimeout,
        autoEvaluate,
        membersNeededToStart
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_member_initialization(
    _In_ std::chrono::milliseconds joinTimeout,
    _In_ std::chrono::milliseconds measurementTimeout,
    _In_ std::chrono::milliseconds evaluationTimeout,
    _In_ bool externalEvaluation,
    _In_ uint32_t membersNeededToStart
)
{
    // Call set_member_initialization/SetMemberInitialization before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_member_initialization(
        joinTimeout,
        measurementTimeout,
        evaluationTimeout,
        externalEvaluation,
        membersNeededToStart
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_peer_to_peer_requirements(
    _In_ std::chrono::milliseconds latencyMaximum,
    _In_ uint32_t bandwidthMinimumInKilobitsPerSecond
    )
{
    // Call set_peer_to_peer_requirements/SetPeerToPeerRequirements before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_peer_to_peer_requirements(
        std::move(latencyMaximum),
        bandwidthMinimumInKilobitsPerSecond
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_peer_to_host_requirements(
    _In_ std::chrono::milliseconds latencyMaximum,
    _In_ uint32_t bandwidthDownMinimumInKilobitsPerSecond,
    _In_ uint32_t bandwidthUpMinimumInKilobitsPerSecond,
    _In_ multiplay_metrics hostSelectionMetric
    )
{
    // Call set_peer_to_host_requirements/SetPeerToHostRequirements before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_peer_to_host_requirements(
        std::move(latencyMaximum),
        bandwidthDownMinimumInKilobitsPerSecond,
        bandwidthUpMinimumInKilobitsPerSecond,
        hostSelectionMetric
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_measurement_server_addresses(
    _In_ const std::vector<xbox::services::game_server_platform::quality_of_service_server>& measurementServerAddresses
    )
{
    // Call set_measurement_server_addresses/SetMeasurementServerAddresses
    // before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_measurement_server_addresses(measurementServerAddresses);

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_session_capabilities(
    _In_ const multiplayer_session_capabilities& capabilities
    )
{
    // Call set_session_capabilities/SetSessionCapabilities before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_session_capabilities(
        capabilities
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_cloud_compute_package_json(
    _In_ web::json::value sessionCloudComputePackageConstantsJson
    )
{
    // Call set_cloud_compute_package_json/SetCloudComputePackageJson before writing a new session to the service
    if (!m_newSession)
    {
        return xbox_live_error_code::logic_error;
    }

    m_sessionConstants->_Set_cloud_compute_package_json(sessionCloudComputePackageConstantsJson);

    return xbox_live_error_code::no_error;
}

void
multiplayer_session::set_initialization_status(
    _In_ bool initializationSucceeded
    )
{
    m_sessionRequest->set_write_initialization_status(true);
    m_sessionRequest->set_initialization_succeeded(initializationSucceeded);
}

void
multiplayer_session::set_host_device_token(
    _In_ const string_t& hostDeviceToken
    )
{
    m_sessionRequest->set_write_host_device_token(true);
    m_sessionRequest->set_host_device_token(hostDeviceToken);
}

void
multiplayer_session::set_matchmaking_server_connection_path(
    _In_ const string_t& serverConnectionPath
    )
{
    m_sessionRequest->set_write_matchmaking_server_connection_path(true);
    m_sessionRequest->set_matchmaking_server_connection_path(serverConnectionPath);
}

void
multiplayer_session::set_matchmaking_resubmit(
    _In_ bool matchResubmit
    )
{
    m_sessionRequest->set_write_matchmaking_resubmit(true);
    m_sessionRequest->set_matchmaking_match_resubmit(matchResubmit);
}

void
multiplayer_session::set_closed(
    _In_ bool closed
    )
{
    m_sessionRequest->set_write_closed(true);
    m_sessionRequest->set_closed(closed);
}

void
multiplayer_session::set_locked(
    _In_ bool locked
    )
{
    m_sessionRequest->set_write_locked(true);
    m_sessionRequest->set_locked(locked);
}

void
multiplayer_session::set_allocate_cloud_compute(
    _In_ bool allocateCloudCompute
    )
{
    m_sessionRequest->set_write_allocate_cloud_compute(true);
    m_sessionRequest->set_allocate_cloud_compute(allocateCloudCompute);
}

void
multiplayer_session::set_server_connection_string_candidates(
    _In_ const std::vector<string_t>& serverConnectionStringCandidates
    )
{
    m_sessionRequest->set_write_server_connection_string_candidates(true);
    m_sessionRequest->set_server_connection_string_candidates(serverConnectionStringCandidates);
}

std::error_code
multiplayer_session::set_session_change_subscription(
    _In_ multiplayer_session_change_types changeTypes
    )
{
    if(m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_session_change_subscription(changeTypes, m_sessionSubscriptionGuid);

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::leave()
{
    // Failed trying to leave and join the session at the same time
    if (m_joiningSession)
    {
        return xbox_live_error_code::logic_error;
    }

    for (uint32_t i = 0; i < m_members.size(); ++i)
    {
        std::shared_ptr<multiplayer_session_member> member = m_members.at(i);
        if (member->is_current_user())
        {
            m_members.erase((m_members.begin() + i));
            break;
        }
    }

    m_sessionRequest->leave_session();
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_status(
    _In_ multiplayer_session_member_status status
    )
{
    // Must join the session first before calling SetCurrentUserStatus
    // Can not set member to ready
    // Can not set member to reserved.  Use AddMemberReservation instead
    if (m_memberCurrentUser == nullptr || status == multiplayer_session_member_status::ready || status == multiplayer_session_member_status::reserved)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_current_user_status(status);
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_secure_device_address_base64(
    _In_ const string_t& value
    )
{
    // Must join the session first before calling SetCurrentUserSecureDeviceAddressBase64
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_secure_device_base_address64(value);
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_role_info(
    _In_ const std::unordered_map<string_t, string_t>& roles
    )
{
    // Must join the session first before calling SetCurrentUserRoleInfo
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_role_info(roles);
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_mutable_role_settings(
    _In_ const std::unordered_map<string_t, multiplayer_role_type>& roleTypes
    )
{
    m_sessionRequest->set_mutable_role_settings(roleTypes);
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_members_in_group(
    _In_ const std::vector<std::shared_ptr<multiplayer_session_member>>& membersInGroup
    )
{
    // Must join the session first before calling SetCurrentUserMembersInGroup
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_current_user_members_in_group(membersInGroup);
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_quality_of_service_measurements(
    _In_ std::shared_ptr<std::vector<multiplayer_quality_of_service_measurements>> measurements
    )
{
    // Must join the session first before calling SetCurrentUserQualityOfServiceMeasurements
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_current_user_quality_of_service_measurements(
        measurements
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_quality_of_service_measurements_json(
    _In_ const web::json::value& serverMeasurementsJson
    )
{
    // Must join the session first before calling SetCurrentUserQualityOfServiceServerMeasurementsJson
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_current_user_quality_of_service_server_measurements_json(serverMeasurementsJson);
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_member_custom_property_json(
    _In_ const string_t& name,
    _In_ const web::json::value& valueJson
    )
{
    if (name.empty())
    {
        return xbox_live_error_code::invalid_argument;
    }

    // Must join the session first before calling SetCurrentUserMemberCustomPropertyJson
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::invalid_argument;
    }
    m_memberCurrentUser->_Set_member_custom_property_json(name, valueJson);

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_current_user_member_arbitration_results(
    _In_ const std::unordered_map<string_t, tournament_team_result>& results
    )
{
    // Must join the session first before calling set_current_user_member_arbitration_result
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }

    m_memberCurrentUser->_Set_arbitration_results(results);
    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::delete_current_user_member_custom_property_json(
    _In_ const string_t& name
    )
{
    if (name.empty())
    {
        return xbox_live_error_code::invalid_argument;
    }

    // Must join the session first before calling DeleteCurrentUserMemberCustomPropertyJson
    if (m_memberCurrentUser == nullptr)
    {
        return xbox_live_error_code::logic_error;
    }
    m_memberCurrentUser->_Delete_custom_property_json(name);

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_matchmaking_target_session_constants_json(
    _In_ web::json::value matchmakingTargetSessionConstantsJson
    )
{
    m_multiplayerSessionProperties->_Set_matchmaking_target_session_constants_json(
        matchmakingTargetSessionConstantsJson
        );

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::set_session_custom_property_json(
    _In_ const string_t& name,
    _In_ const web::json::value& valueJson
    )
{
    if (name.empty())
    {
        return xbox_live_error_code::invalid_argument;
    }
    m_multiplayerSessionProperties->_Set_session_custom_property_json(name, valueJson);

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::delete_session_custom_property_json(
    _In_ const string_t& name
    )
{
    if (name.empty())
    {
        return xbox_live_error_code::invalid_argument;
    }

    m_multiplayerSessionProperties->_Delete_session_custom_property_json(name);

    return xbox_live_error_code::no_error;
}

std::error_code
multiplayer_session::add_member_reservation_helper(
    _In_ const string_t& xboxUserId,
    _In_ const web::json::value& memberCustomConstantsJson,
    _In_ bool addInitializePropertyToRequest,
    _In_ bool initializeRequested
    )
{
    if (xboxUserId.empty())
    {
        return xbox_live_error_code::invalid_argument;
    }
    web::json::value customConstantsJson;
    if (!memberCustomConstantsJson.is_null())
    {
        customConstantsJson = memberCustomConstantsJson;
    }

    std::shared_ptr<multiplayer_session_member_request> memberRequest = m_sessionRequest->add_member_request(
        true,
        false,
        xboxUserId,
        customConstantsJson,
        addInitializePropertyToRequest,
        initializeRequested
        );

    std::shared_ptr<multiplayer_session_member> member = std::make_shared<multiplayer_session_member>(
        false,
        0,
        xboxUserId,
        customConstantsJson
        );

    member->_Set_member_request(memberRequest);
    member->_Set_session_request(m_sessionRequest);
    m_members.push_back(member);

    return xbox_live_error_code::no_error;
}

xbox_live_result<std::shared_ptr<multiplayer_session_member>>
multiplayer_session::join_helper(
    _In_ web::json::value memberCustomConstantsJson,
    _In_ bool addInitializePropertyToRequest,
    _In_ bool initializeRequested,
    _In_ bool joinWithActiveStatus
    )
{
    if (m_joiningSession)
    {
        return xbox_live_result<std::shared_ptr<multiplayer_session_member>>(xbox_live_error_code::logic_error, "Failed trying to join the session more than once");
    }

    m_joiningSession = true;

    web::json::value customConstantsJson = web::json::value::null();
    if (!memberCustomConstantsJson.is_null())
    {
        customConstantsJson = memberCustomConstantsJson;
    }

    std::shared_ptr<multiplayer_session_member_request> memberRequest = m_sessionRequest->add_member_request(
        true,
        true,
        m_xboxUserId,
        customConstantsJson,
        addInitializePropertyToRequest,
        initializeRequested
        );

    if (joinWithActiveStatus)
    {
        memberRequest->set_is_active(true);
        memberRequest->set_write_is_active(true);
    }

    std::shared_ptr<multiplayer_session_member> member = std::make_shared<multiplayer_session_member>(
        true,
        0,
        m_xboxUserId,
        customConstantsJson
        );

    member->_Set_member_request(memberRequest);
    member->_Set_session_request(m_sessionRequest);
    m_members.push_back(member);
    m_memberCurrentUser = member;

    return xbox_live_result<std::shared_ptr<multiplayer_session_member>>(member);
}

void
multiplayer_session::ensure_session_subscription_id_initialized()
{
    if (m_sessionSubscriptionGuid.empty())
    {
        m_sessionSubscriptionGuid = utils::create_guid(true);
    }
}

multiplay_metrics
multiplayer_session::_Convert_string_to_multiplayer_host_selection_metric(
    _In_ const string_t& value
    )
{
    if (value.empty())
    {
        return multiplay_metrics::latency;
    }
    else if (utils::str_icmp(value, _T("bandwidthUp")) == 0)
    {
        return multiplay_metrics::bandwidth_up;
    }
    else if (utils::str_icmp(value, _T("bandwidthDown")) == 0)
    {
        return multiplay_metrics::bandwidth_down;
    }
    else if (utils::str_icmp(value, _T("bandwidth")) == 0)
    {
        return multiplay_metrics::bandwidth;
    }
    else if (utils::str_icmp(value, _T("latency")) == 0)
    {
        return multiplay_metrics::latency;
    }

    return multiplay_metrics::unknown;
}

const xbox_live_result<string_t>
multiplayer_session::_Convert_multiplayer_host_selection_metric_to_string(
    _In_ multiplay_metrics multiplayMetric
    )
{
    switch (multiplayMetric)
    {
        case multiplay_metrics::unknown: return xbox_live_result<string_t>(_T("unknown"));

        case multiplay_metrics::bandwidth_up: return xbox_live_result<string_t>(_T("bandwidthUp"));

        case multiplay_metrics::bandwidth_down: return xbox_live_result<string_t>(_T("bandwidthDown"));

        case multiplay_metrics::bandwidth: return xbox_live_result<string_t>(_T("bandwidth"));

        case multiplay_metrics::latency: return xbox_live_result<string_t>(_T("latency"));

        default: return xbox_live_result<string_t>(xbox_live_error_code::invalid_argument, "Enum out of range");
    }
}

multiplayer_initialization_stage
multiplayer_session::_Convert_string_to_multiplayer_initialization_stage(
    _In_ const string_t& value
)
{
    if (value.empty())
    {
        return multiplayer_initialization_stage::none;
    }
    else if (utils::str_icmp(value, _T("joining")) == 0)
    {
        return multiplayer_initialization_stage::joining;
    }
    else if (utils::str_icmp(value, _T("failed")) == 0)
    {
        return multiplayer_initialization_stage::failed;
    }
    else if (utils::str_icmp(value, _T("evaluating")) == 0)
    {
        return multiplayer_initialization_stage::evaluating;
    }
    else if (utils::str_icmp(value, _T("measuring")) == 0)
    {
        return multiplayer_initialization_stage::measuring;
    }

    return multiplayer_initialization_stage::unknown;
}

xbox_live_result<matchmaking_status>
multiplayer_session::_Convert_string_to_matchmaking_status(
    _In_ const string_t& value
    )
{
    if (value.empty())
    {
        return xbox_live_result<matchmaking_status>(xbox_live_error_code::invalid_argument, "Value was empty");
    }

    if (utils::str_icmp(value, _T("searching")) == 0)
    {
        return xbox_live_result<matchmaking_status>(matchmaking_status::searching);
    }
    else if (utils::str_icmp(value, _T("expired")) == 0)
    {
        return xbox_live_result<matchmaking_status>(matchmaking_status::expired);
    }
    else if (utils::str_icmp(value, _T("found")) == 0)
    {
        return xbox_live_result<matchmaking_status>(matchmaking_status::found);
    }
    else if (utils::str_icmp(value, _T("canceled")) == 0)
    {
        return xbox_live_result<matchmaking_status>(matchmaking_status::canceled);
    }

    return xbox_live_result<matchmaking_status>(matchmaking_status::unknown);
}

const xbox_live_result<string_t>
multiplayer_session::_Convert_matchmaking_status_to_string(
    _In_ matchmaking_status matchmakingStatus
    )
{
    switch (matchmakingStatus)
    {
        case matchmaking_status::unknown: return xbox_live_result<string_t>(_T("unknown"));

        case matchmaking_status::searching: return xbox_live_result<string_t>(_T("searching"));

        case matchmaking_status::expired: return xbox_live_result<string_t>(_T("expired"));

        case matchmaking_status::found: return xbox_live_result<string_t>(_T("found"));

        case matchmaking_status::canceled: return xbox_live_result<string_t>(_T("canceled"));

        default: return xbox_live_result<string_t>(xbox_live_error_code::invalid_argument, "Enum out of range");
    }
}

write_session_status
multiplayer_session::convert_http_status_to_write_session_status(
_In_ int32_t httpStatusCode
)
{
    switch (httpStatusCode)
    {
        case 200: return write_session_status::updated;

        case 201: return write_session_status::created;

        case 204: return write_session_status::session_deleted;

        case 401: return write_session_status::access_denied;

        case 404: return write_session_status::handle_not_found;

        case 409: return write_session_status::conflict;

        case 412: return write_session_status::out_of_sync;

        default: return write_session_status::unknown;
    }
}

std::vector<std::shared_ptr<multiplayer_session_member>>
multiplayer_session::_Deserialize_me_member(
    _In_ const web::json::value& json,
    _In_ std::error_code& errc
    )
{
    web::json::value membersInfo = utils::extract_json_field(json, _T("membersInfo"), errc, true);
    uint32_t first = utils::extract_json_int(membersInfo, _T("first"), errc, true);
    web::json::value memberJson = utils::extract_json_field(json, _T("members"), errc, true);
    uint32_t current = first;

    std::vector<std::shared_ptr<multiplayer_session_member>> members;

    auto member = multiplayer_session_member::_Deserialize(
        utils::extract_json_field(
            memberJson,
            _T("me"),
            errc,
            true
            )
        );

    if (member.err())
    {
        errc = member.err();
    }
    std::shared_ptr<multiplayer_session_member> meMember = std::make_shared<multiplayer_session_member>(
        member.payload()
        );

    meMember->_Set_member_id(current);

    members.push_back(meMember);

    return members;
}

std::vector<std::shared_ptr<multiplayer_session_member>>
multiplayer_session::_Deserialize_members_list(
    _In_ const web::json::value& json,
    _In_ std::error_code& errc
    )
{
    web::json::value membersInfo = utils::extract_json_field(json, _T("membersInfo"), errc, false);
    uint32_t first = utils::extract_json_int(membersInfo, _T("first"), errc, false);
    uint32_t count = utils::extract_json_int(membersInfo, _T("count"), errc, false);

    std::vector<std::shared_ptr<multiplayer_session_member>> members;
    uint32_t current = first;
    web::json::value membersJson = utils::extract_json_field(json, _T("members"), errc, false);
    for (uint32_t i = 0; i < count; i++)
    {
        stringstream_t stream;
        stream << current;
        web::json::value memberJsonIndex = utils::extract_json_field(membersJson, stream.str(), errc, true);

        auto member = multiplayer_session_member::_Deserialize(memberJsonIndex);
        if (member.err())
        {
            errc = member.err();
        }

        std::shared_ptr<multiplayer_session_member> currentMember = std::make_shared<multiplayer_session_member>(
            member.payload()
            );

        currentMember->_Set_member_id(current);
        members.push_back(currentMember);

        uint32_t next = utils::extract_json_int(memberJsonIndex, _T("next"), errc, false, current);
        if (next == current)
        {
            break;
        }

        current = next;
    }

    return members;
}

std::error_code
multiplayer_session::_Populate_members_with_members_list(
    _In_ std::vector<std::shared_ptr<multiplayer_session_member>> members
    )
{
    std::error_code errc;
    for (auto& member : members)
    {
        errc = member->set_members_list(members);
    }
    return errc;
}

xbox_live_result<multiplayer_session_change_types>
multiplayer_session::compare_multiplayer_sessions(
    _In_ std::shared_ptr<multiplayer_session> currentSession,
    _In_ std::shared_ptr<multiplayer_session> oldSession
    )
{
    if (currentSession == nullptr || oldSession == nullptr)
    {
        return xbox_live_result<multiplayer_session_change_types>(xbox_live_error_code::invalid_argument, "Cannot compare a null session");
    }

    uint32_t currentType = static_cast<uint32_t>(multiplayer_session_change_types::none);

    if (utils::str_icmp(currentSession->session_properties()->host_device_token(), oldSession->session_properties()->host_device_token()) != 0)
    {
        currentType |= multiplayer_session_change_types::host_device_token_change;
    }

    if (currentSession->initialization_stage() != oldSession->initialization_stage())
    {
        currentType |= multiplayer_session_change_types::initialization_state_change;
    }

    auto currentMatchmakingServer = currentSession->matchmaking_server();
    auto oldMatchmakingServer = oldSession->matchmaking_server();
    if ((currentMatchmakingServer.is_null() != oldMatchmakingServer.is_null()) ||
        (!currentMatchmakingServer.is_null() && currentMatchmakingServer.status() != oldMatchmakingServer.status()) ||
        (!currentMatchmakingServer.is_null() &&
            !currentMatchmakingServer.target_session_ref().is_null() &&
            !oldMatchmakingServer.target_session_ref().is_null() &&
            !_Do_session_references_match(currentMatchmakingServer.target_session_ref(), oldMatchmakingServer.target_session_ref()))
        )
    {
        currentType |= multiplayer_session_change_types::matchmaking_status_change;
    }

    bool hasMemberChanged = false;
    bool memberStatusChanged = false;
    bool memberCustomPropertyChanged = false;

    if (currentSession->members().size() != oldSession->members().size())
    {
        hasMemberChanged = true;
    }

    for (uint32_t i = 0; i < currentSession->members().size(); i++)
    {
        std::shared_ptr<multiplayer_session_member> currentSessionMember = currentSession->members()[i];
        bool isMemberFound = false;
        for (uint32_t j = 0; j < oldSession->members().size(); j++)
        {
            std::shared_ptr<multiplayer_session_member> olderSessionMember = oldSession->members()[j];

            if (utils::str_icmp(currentSessionMember->xbox_user_id(),
                olderSessionMember->xbox_user_id()) == 0)
            {
                isMemberFound = true;

                if (currentSessionMember->status() != olderSessionMember->status())
                {
                    memberStatusChanged = true;
                }

                if (utils::str_icmp(currentSessionMember->member_custom_properties_json().serialize(),
                    olderSessionMember->member_custom_properties_json().serialize()) != 0)
                {
                    memberCustomPropertyChanged = true;
                }
            }
        }

        if (!isMemberFound)
        {
            hasMemberChanged = true;
        }

        if (memberStatusChanged && hasMemberChanged && memberCustomPropertyChanged)
        {
            break;
        }
    }

    if (hasMemberChanged)
    {
        currentType |= multiplayer_session_change_types::member_list_change;
    }

    if (memberStatusChanged)
    {
        currentType |= multiplayer_session_change_types::member_status_change;
    }

    if (memberCustomPropertyChanged)
    {
        currentType |= multiplayer_session_change_types::member_custom_property_change;
    }

    if (currentSession->session_properties()->closed() != oldSession->session_properties()->closed() ||
        currentSession->session_properties()->locked() != oldSession->session_properties()->locked() ||
        currentSession->session_properties()->join_restriction() != oldSession->session_properties()->join_restriction() ||
        (currentSession->members().size() == currentSession->session_constants()->max_members_in_session()) !=
        (oldSession->members().size() == oldSession->session_constants()->max_members_in_session())     // if the session is open again or closed again because the max member has changed
        )
    {
        currentType |= multiplayer_session_change_types::session_joinability_change;
    }

    if (utils::str_icmp(currentSession->session_properties()->session_custom_properties_json().serialize(), oldSession->session_properties()->session_custom_properties_json().serialize()) != 0)
    {
        currentType |= multiplayer_session_change_types::custom_property_change;
    }

    if (!currentSession->tournaments_server()._Is_same(oldSession->tournaments_server()))
    {
        currentType |= multiplayer_session_change_types::tournament_property_change;
    }

    if (!currentSession->arbitration_server()._Is_same(oldSession->arbitration_server()))
    {
        currentType |= multiplayer_session_change_types::arbitration_property_change;
    }

    return xbox_live_result<multiplayer_session_change_types>(static_cast<multiplayer_session_change_types>(currentType));
}

bool
multiplayer_session::_Do_session_references_match(
    _In_ xbox::services::multiplayer::multiplayer_session_reference sessionRef1,
    _In_ xbox::services::multiplayer::multiplayer_session_reference sessionRef2
    )
{
    return  utils::str_icmp(sessionRef1.service_configuration_id(), sessionRef2.service_configuration_id()) == 0 &&
        utils::str_icmp(sessionRef1.session_template_name(), sessionRef2.session_template_name()) == 0 &&
        utils::str_icmp(sessionRef1.session_name(), sessionRef2.session_name()) == 0;
}

xbox_live_result<multiplayer_session>
multiplayer_session::_Deserialize(
    _In_ const web::json::value& json
    )
{
    multiplayer_session returnResult;
    if ( json.is_null() ) return xbox_live_result<multiplayer_session>(returnResult);

    std::error_code errc = xbox_live_error_code::no_error;
    web::json::value initializingJson = utils::extract_json_field(json, _T("initializing"), errc, false);
    web::json::value memberInfoJson = utils::extract_json_field(json, _T("membersInfo"), errc, false);

    returnResult.m_correlationId = utils::extract_json_string(json, _T("correlationId"), errc);
    returnResult.m_searchHandleId = utils::extract_json_string(json, _T("searchHandle"), errc, false);
    returnResult.m_startTime = utils::extract_json_time(json, _T("startTime"), errc);

    auto arbitrationJson = utils::extract_json_field(json, _T("arbitration"), errc, false);
    if (!arbitrationJson.is_null())
    {
        returnResult.m_arbitrationStatus = multiplayer_service::_Convert_string_to_arbitration_status(utils::extract_json_string(arbitrationJson, _T("status"), errc, false));
    }

    returnResult.m_branch = utils::extract_json_string(json, _T("branch"), errc);
    returnResult.m_changeNumber = utils::extract_json_int(json, _T("changeNumber"), errc, false, ULONG_MAX);

    auto sessionConstants = multiplayer_session_constants::_Deserialize(
        utils::extract_json_field(
            json,
            _T("constants"),
            errc,
            true
            )
        );

    if (sessionConstants.err())
    {
        errc = sessionConstants.err();
    }
    returnResult.m_sessionConstants = std::make_shared<multiplayer_session_constants>(
        sessionConstants.payload()
        );

    returnResult.m_nextTimer = utils::extract_json_time(json, _T("nextTimer"), errc);
    returnResult.m_initializationStage = _Convert_string_to_multiplayer_initialization_stage(utils::extract_json_string(initializingJson, _T("stage"), errc));
    returnResult.m_initializationStageStartTime = utils::extract_json_time(initializingJson, _T("stageStartTime"), errc);
    returnResult.m_initializationEpisode = utils::extract_json_int(initializingJson, _T("episode"), errc);
    returnResult.m_hostCandidate = utils::extract_json_vector<string_t>(utils::json_string_extractor, json, _T("hostCandidates"), errc, false);

    web::json::value jsonMembers = utils::extract_json_field(json, _T("members"), errc, false);
    if (jsonMembers.size() != 0)
    {
        if (returnResult.m_sessionConstants->capabilities_large())
        {
            returnResult.m_members = _Deserialize_me_member(json, errc);
        }
        else
        {
            returnResult.m_members = _Deserialize_members_list(json, errc);
        }
    }

    _Populate_members_with_members_list(returnResult.m_members);

    auto multiplayerSessionProperties = multiplayer_session_properties::_Deserialize(
        utils::extract_json_field(
            json,
            _T("properties"),
            errc,
            true
            )
        );

    if (multiplayerSessionProperties.err())
    {
        errc = multiplayerSessionProperties.err();
    }
    returnResult.m_multiplayerSessionProperties = std::make_shared<multiplayer_session_properties>(multiplayerSessionProperties.payload());

    returnResult.m_multiplayerSessionProperties->_Initialize(
        returnResult.m_sessionRequest,
        returnResult.m_members
        );
    returnResult.m_membersAccepted = utils::extract_json_int(memberInfoJson, _T("accepted"));

    auto sessionRoleTypes = multiplayer_session_role_types::_Deserialize(
        utils::extract_json_field(json, _T("roleTypes"), false)
        );

    if (sessionRoleTypes.err())
    {
        errc = sessionRoleTypes.err();
    }
    returnResult.m_sessionRoleTypes = std::make_shared<multiplayer_session_role_types>(sessionRoleTypes.payload());

    auto serversJson = utils::extract_json_field(json, _T("servers"), errc, false);
    auto serversMatchmakingJson = utils::extract_json_field(serversJson, _T("matchmaking"), errc, false);
    auto serversMatchmakingPropertiesJson = utils::extract_json_field(serversMatchmakingJson, _T("properties"), errc, false);

    if (!serversMatchmakingJson.is_null())
    {
        returnResult.m_matchmakingServer =
            multiplayer_session_matchmaking_server::_Deserialize(
                utils::extract_json_field(serversMatchmakingPropertiesJson, _T("system"), errc, false)
                ).payload();

        returnResult.m_hasMatchmakingServer = true;
    }

    auto serversArbitrationJson = utils::extract_json_field(serversJson, _T("arbitration"), errc, false);
    if (!serversArbitrationJson.is_null())
    {
        auto arbitrationServerResult = multiplayer_session_arbitration_server::_Deserialize(serversArbitrationJson);
        if (arbitrationServerResult.err())
        {
            errc = arbitrationServerResult.err();
        }
        returnResult.m_arbitrationServer = arbitrationServerResult.payload();
    }

    auto serversTournamentJson = utils::extract_json_field(serversJson, _T("tournaments"), errc, false);
    if (!serversTournamentJson.is_null())
    {
        auto tournamentServerResult = multiplayer_session_tournaments_server::_Deserialize(serversTournamentJson);
        if (tournamentServerResult.err())
        {
            errc = tournamentServerResult.err();
        }
        returnResult.m_tournamentsServer = tournamentServerResult.payload();

        if (returnResult.m_members.size() > 0 && returnResult.m_tournamentsServer.teams().size() > 0)
        {
            auto teamRefs = returnResult.m_tournamentsServer.teams();
            for (size_t i = 0; i < returnResult.m_members.size(); ++i)
            {
                auto member = returnResult.m_members[i];
                if (teamRefs.find(member->m_teamId) != teamRefs.end())
                {
                    member->m_tournamentTeamSessionRef = teamRefs[member->m_teamId];
                }
                else
                {
                    errc = xbox_live_error_code::json_error;
                }
            }
        }
    }

    returnResult.m_servers = std::move(serversJson);

    return xbox_live_result<multiplayer_session>(returnResult, errc);
}

NAMESPACE_MICROSOFT_XBOX_SERVICES_MULTIPLAYER_CPP_END

redpajama_set_name: RedPajamaGithub


The man I search must not be afraid to take responsibility of me and our future family. He must be brave and serious, wise and mature. I need an experienced man who I would like to follow. My ideal man knows what is good for his woman and he will always make me feel special in any place and in any situation. If you have warm heart, love hugs, ready to change your life and devote yourself to one special woman, I am waiting for you.


TREASON in America: OPERATION AMERICAN FREEDOM! Navy First Class Petty Officer Jim Luadenslager taking ACTION!
HELLO JAG HUNTER, I AM PO-1 LUTHER J. LAUDENSLAGER, U.S. NAVY, RET.
PROVE TO ME YOUR ORDERS TO ME ARE LAWFUL; PROVE TO ME YOU ARE CONSTITUTIONALLY ELIGIBLE TO BE MY COMMANDER IN CHIEF. SIGNED- PO-1 LUTHER J. LAUDENSLAGER, U.S. NAVY, RET.
I HAVE SENT A COPY TO YOU THAT DATE SNAIL MAIL YOU SHOULD RECEIVE IT SHORTLY.
THANK YOU SIR FOR ALL YOU DO, YOU ARE ABSOLUTELY AMAZING TO ME THE WAY YOU KEEP YOUR NOSE TO THE TRAIL OF THE CRIMINAL, NO [kidding].
HOT HOUND DOG ON THE SENT ON THE TRAIL. IF THE IMPOSTOR IN CHIEF IS REMOVED IT WILL BE IN LARGE PART DUE TO YOURS AND OTHER PATRIOTS OF THE SAME STRIPES WHO ARE INSTRUMENTAL IN THAT CAUSE.
I WAS LUCKY IN MY NAVY CAREER TO BE AN AIR CREWMAN IN A P-3 ORION SUBMARINE HUNTER KILLER AIRCRAFT AND WOULD DO IT AGAIN ANYTIME. FAIR SKIES AND TAILWINDS. PO-1 L.J. (JIM) LAUDENSLAGER, U.S. NAVY, RET.
Petty Officer Laudenslager. WELL DONE! Thank you for your generous words. I'll post you letter once received!
Now, how's about the rest of you P-3 airmen? Who's next?
The Grand Jury is the most powerful law enforcement agency known in human history!
Any Indiana State (County) Grand Jury can act to a nullify (quash) the unconstitutional State Supreme Court ruling regarding our IV Amendment constitutional protection against illegal searches and seizure.
Any Indiana State (County) Grand Jury can formally accuse any justice sitting on the Indiana State Supreme Court for their forcible resistance to constitutional (statute) law so as to instally their own rival and competing form of government (TREASON).
TREASON in America: It's over! Foreign-born Domestic Enemy OBAMA CAUGHT in conspiracy to forge a certificate of live birth! Another criminal complaint expected to be filed with the FBI in days!
Thanks to Sharon Rondeau and Miki Booth for the heads up!
TREASON in America: OBAMA is charged over two-years for TREASON specifically named as a FOREIGN-BORN DOMESTIC ENEMY!


text:
Rhinolophus yonghoiseni () è un Pipistrello della famiglia dei Rinolofidi endemico della Penisola malese e del Borneo.

Descrizione

Dimensioni
Pipistrello di piccole dimensioni, con la lunghezza dell'avambraccio tra  e un peso fino a .

Aspetto
L'aspetto esterno è molto simile a R.sedulus. Il cariotipo è 2n=28.

Ecolocazione
Emette ultrasuoni ad alto ciclo di lavoro con impulsi a frequenza costante di  nella Penisola malese,  e  nel Borneo.

Biologia

Comportamento
È stato osservato in canali sotterranei.

Distribuzione e habitat
Questa specie è diffusa nella Penisola malese e nel Borneo.

Vive nelle foreste primarie di Dipterocarpi.

Stato di conservazione
Questa specie, essendo stata scoperta solo recentemente, non è stata sottoposta ancora a nessun criterio di conservazione.

Note

Bibliografia

Altri progetti

Microchirotteri
Fauna asiatica

redpajama_set_name: RedPajamaWikipedia


text:
Community Participation with Schools in Developing Countries
Towards Equitable and Inclusive Basic Education for All
Mikiko Nishimura
Published August 4, 2020 by Routledge
Community Participation with Schools in Developing Countries: Towards Equitable and Inclusive Basic Education for All
The Sustainable Development Goals (SDGs) (2016-2030) set by the United Nations in 2015 restated the importance of universal primary education for all, and specifically discuss quality, equity, and inclusion in basic education. To achieve this, the role of community has been emphasized and participation has become a "buzzword" in international development over the past several decades. Despite the growing attention to community participation in school management, previous literature has shown mixed results in terms of its actual practice and its impacts on quality, equity, and inclusion in education.
This book deepens the contextual understanding of community in developing countries and its involvement in schools in general, and its impact on quality, equity, and inclusion of school education in particular. By presenting various case studies in Asia, Africa, Latin America, and a post-conflict state in Europe, the book analyses commonalities and differences in the ways communities are involved and cast their impacts and challenges. The book contributes knowledge on the ways in which community involvement could work in developing countries, the detailed processes and factors that make community participation work in different dimensions, and remaining challenges that scholars and practitioners still need to be concerned and mindful in the field.
This book will appeal to both researchers and practitioners who are concerned about the community participation approach for the SDGs.
Foreword (David Chapman)
1. Introduction (Mikiko Nishimura)
Part I: Revisiting the Theoretical Framework
2. Community Participation: Policy Discourses and Controversies (James H. Williams, Romina Kasman, Paromita De, Merg Zhou, and Ana Gonzalez)
3. School-Based Management: Theory and Empirical Evidence (Angela Demas)
4. Can Communities Mobilize for Schooling and Learning?: Bottom up Perspectives from Pratham in India (Rukmini Banerji)
Part II: Case Studies on Stakeholder Relationships and Accountability
5. Community Participation in School Management, Relational Trust, and Teacher Motivation toward Pupils' Learning Outcomes: The Case Study from Ghana (Kazuro Shibuya)
6. Connecting Parental Involvement, Adult Education, and Community Organizing though Social Justice Leadership: Lessons from Ciudad Juarez, Mexico (D. Brent Edwards, Jr., David DeMatthews, Anne Spear, and Hillary Hartley)
7. Educational Development through Community-wide Collaboration: How to Establish a Sustainable Community-wide Initiative to Improve Education (Nobuhiro Kunieda, Takao Maruyama, Akiko Kageyama, and Masahiro Hara)
8. Information Sharing and Community Participation: The Case of Maasai Community in Kenya (Tetsuya Yamada and Mikiko Nishimura)
Part III: Case Studies on the Role of Community for Equity and Inclusion
9. Community Participation in School Management in a Post-Coflict Society: The Case of School Boards in Brčko in Bosnia Herzegovina (Taro Komatsu)
10. The Acceptance Situation of Inclusive Education in Kenya: Perceptions of Parents, Communities, and Teachers (Jun Kawaguchi)
11. The Role of Peers as Community in Youth Education and Employment in Tanzania (Nancy Pellowski Wiger)
Part IV: Case Studies on Community Participation and Learning Outcomes
12. Quality Learning through Community-wide Collaboration: A Methodology to Overcome the "Learning Crisis" in Niger (Masahiro Hara, Takao Maruyama, Akiko Kageyama, and Nobuhiro Kunieda)
13. School Autonomy and Learning Outcomes in Burkina Faso and Senegal (Takako Yuki and Kengo Igei)
14. False Advertising and First Principles: Misrepresentation of Research Evidence from El Salvador and the Need to Change the Paradigm of Community Based Management (D. Brent Edwards, Jr.)
15. School-based Management and Learning Outcomes: Empirical Evidence from Colima, Mexico (Vincente A. Garcia-Moreno, Paul Gertler, and Harry A. Patrinos)
16. Conclusion (Mikiko Nishimura)
Mikiko Nishimura is a Professor at the College of Liberal Arts, International Christian University, Japan. She was recently a visiting scholar in the Graduate School of Education and Human Development at George Washington University, USA. She has published extensively on international development and education in both journals and books.
'This book is a must-read volume for both researchers and practitioners, who are concerned about the community participation approach for SDGs.' - Keiichi Ogawa, Professor/Department Chair in the Graduate School of International Cooperation Studies, Kobe University, Japan
Routledge Research in Educational Equality and Diversity

redpajama_set_name: RedPajamaCommonCrawl


← WORKING CONDITIONS IN VENEZUELA SENDING CUBAN DOCTORS TO U.S.
This entry was posted in Blog and tagged Cuba-Canada Relations, International Relations, Organization of American States, US-Cuba Relations. Bookmark the permalink.


text:
Shooting Range Recap
Gun Info
Gun Acronyms
Gun Industry Events
Gun Discounts
TxAT / Aguila Ammunition Announce Director of LE Sales
TEXAS ARMAMENT & TECHNOLOGY/AGUILA AMMUNITION ANNOUNCES NEW DIRECTOR OF LAW ENFORCEMENT/GOVERNMENT SALES
CONROE, TEXAS – December 16, 2015 – (ArmsVault.com) – Texas Armament & Technology (TxAT)/Aguila Ammunition is pleased to announce the addition of Tony Williams to their team as the Director of LE/GOV Sales. This is a new position for the company.
"Tony has been part of the firearms and shooting industry for years and brings vast experience to the company," states Chris Sadler, Director of Operations for TxAT/Aguila Ammunition. "He is accomplished, result-oriented and exactly the person Aguila needs to drive our development and growth."
Before joining the Aguila team, Tony spent three years with Aimpoint, Inc. as their Government Sales Manager, leading some of the company's largest partnerships and managing federal law enforcement and military programs across numerous branches. Prior to his work at Aimpoint, Tony spent time with CamelBak Products, Inc. where he was recognized on four separate occasions for outstanding implementation of new contracts, and with Mar-Vel International/ADS, Inc. Combined, Williams brings a decade of law enforcement and military sales experience to Aguila.
"I'm excited about joining the TxAT and Aguila Ammunition team because of the opportunity for growth and the challenge of developing a new channel," says Williams.
Creating Tony's position is part of an overall growth plan for the company. As the largest ammunition manufacturer in Latin America, the 54-year old company has recently brought its extensive line of ammunition offerings to the United States.
About Aguila Ammunition
Aguila Ammunition, founded in 1961, is manufactured in Cuernavaca, Morelos, Mexico by Industrias Tecnos, S.A. de C.V. As one of the largest rimfire manufacturers in the world, Aquila utilizes cutting-edge technology to manufacture quality rimfire, centerfire and shotshell ammunition. Aguila offers a complete range of products for the self-defense, sport shooting, hunting, law enforcement and military markets. Texas Armament & Technology is the exclusive North American distributor for Aguila Ammunition.
About Texas Armament & Technology
Texas Armament & Technology (TxAT) is a veteran-owned business, and is the exclusive distributor of Aguila Ammunition in the U.S. and Canadian markets. TxAT's mission is to provide technical support and assist in selecting the best ammunition, equipment, and training for customer requirements – ranging from weapons to counterterrorism and national security. TxAT also provides training, consulting services and technical support for clients in the aerospace and defense industries.
For more information on Aguila Ammunition, visit the company website at www.aguilaammo.com or contact:
Kristi Drawe
Texas Armament & Technology/Aguila Ammunition
Kristi@tx-at.com
Share this gun news:
Categories Gun News Tags Aguila Ammunition, Aimpoint, Texas Armament & Technology - TxAT
17437 Carey Rd #121
© 2021 ArmsVault.com


Pnevmatikakis Winery The Winery Pnevmatikakis is located in the province of Kissamos. It has long experience in Viticulture and Wineries. Modern facilities, selected varieties, quality control and passion for wine are elements that differentiate this winery.
Owners of the standard of this unit are the winemaking brothers Michael and Anthony Pnevmatikakis, the family who is dealing with viticulture and winemaking from grandfather to grandfather. The modern winery facilities of Pnevmatikakis are open to all lovers of good Cretan wine.
If you want to visit the vineyards, the modern facilities, the stone basement cellar, the wine museum and try their wines go to Drapania Kissamos. It is very close to the national road from Chania to Kissamos, 4 kilometers before the town of Kissamos.


text:
EU-Russia talks fall through for time being, Estonia still concerned
ERR, ERR News
Angela Merkel, Emmanuel Macron and Vladimir Putin at a 2019 meeting.
The lack of support from European Union member states for a call for talks with the Russian Federation, sponsored by the leaders of France and Germany, while encouraging, does not mean that such initiatives may not go ahead in future. Meanwhile, that the proposal fell through should not mean any bilateral meetings between Russia and any union member state should happen instead, one Estonian Member of the European Parliament says.
EU leaders agreed Thursday evening that no EU-Russia summit would be going ahead for the meantime, scotching a proposal from German Chancellor Angela Merkel and French President Emmanuel Macron to do just that.
Merkel said after lengthy meetings with EU member states' leaders that: "It was not possible today to agree on a summit immediately, at a higher level. However, it is important to me that the format of a dialog is reached and we can work on it. Personally, I would have liked to have seen a bolder step here."
The calls for talks with Russia met with widespread opposition in Estonia, including from Prime Minister Kaja Kallas (Reform), who sought clarity on the rationale behind the call, and former president, Toomas Hendrik Ilves, who in characteristically robust terms, tweeted that the Franco-German leadership pair were either clueless or ignorant of history.
Soon after the 2014 annexation of Crimea by the Russian Federation, the EU has agreed on five principles relating to dealings with Russia, and maintains a demand that Russia comply with the Minsk Protocol, if relations between it and the EU are to progress, MEP Urmas Paet (Reform) notes.
One of the five principles covers selective cooperation with Russia, a cooperation whose terms are to be discussed at European Council-level which in actuality could mean meetings with council president Charles Michel, and also European Commission President Ursula von der Leyen, in any case, Paet noted.
Merkel: Not enough for Russia to meet with US, needs to meet with EU too
Angela Merkel said Thursday that while the EU should stand united against any provocative actions by Russia, this should take place in parallel with sounding out Russia's president, Vladimir Putin, on talks, particularly given his recent tete-a-tete with POTUS Joe Biden.
"It is not enough for the U.S. president to talk to the Russian president," Merkel said, stressing that the EU must also create: "alternative formats of conversation".
However, the joint France-Germany proposal for resuming talks with Russia, seven years after the annexation of Crimea and also the start of the ongoing insurgency war in eastern Ukraine, met with a less than lukewarm response from across the union and not just with the Central and Eastern European (CEE) member states, with only Austria and Denmark pledging support.
ERR's Brussels correspondent Joosep Värk reported that talks continued into the early hours of Friday, and ended with an outcome amenable to the CEE member states.
Kaja Kallas said, however, that discussions overnight Thursday had not shed any light on why Merkel supports dialog with Russia, adding that the collapse of the recent proposal: "Does not mean that any possible dialog with Russia is completely dead and buried. On the contrary, such desires may become more frequent in the future," adding that there is nonetheless widespread opposition to the proposals.
Sanna Marin, the prime minister of Finland, a country which borders with Russia, said that the late-night talks had mainly concerned what cooperation with Russia means in terms of community principles, though declined to say which member states supported, and which opposed, the Merkel-Macron proposal.
"It is essential that we have a common view on the way and principles of dialog with Russia that we adhere to," Marin said, according to ERR's online Estonian news.
Kremlin in favor of talks with EU
One leader who certainly did support the proposal was Vladimir Putin himself; Kremlin spokesperson Dmitri Peskov told reporters that: "We welcome the proposal. Putin is a supporter of dialog mechanisms and contacts between Brussels and Russia."
Both the Kremlin and Washington said in the aftermath of last week's meeting that it could serve to stabilize relations between the two countries, despite tensions.
Estonian MEP: EU should always act as one
MEP Urmas Paet says that the EU must always speak as one in any meetings with Russia, adding that while Estonia can make its voice known in this format, it cannot if bilateral meetings between Russia and one or more EU states go ahead.
"Nor can we ignore the rapid rapprochement between Russia and China, the two great authoritarian regimes, and their impact on Europe," Paet added.
Given the state of current relations between Russia and the EU, he said, such a meeting might not have any clear benefits, while the Kremlin, he added, is already aware of the EU's line on Ukraine and Georgia, while the current poor state of relations is the result of Russian actions in violating international law and human rights.
Russia reportedly fired on a British warship in the Black Sea Wednesday; while not a member state now, the U.K. was still in the EU when the freezing of relations between the bloc and the Russian Federation began, in 2014.
That freeze does not rule out bilateral meetings going ahead, Paet added, meetings which harm unity and in any case do not represent common EU policy, on the part of the member state dialoging with the Kremlin.
An example of this, albeit in his official EU role rather than on behalf of one particular state, was the visit to Moscow a few months ago of the union's high representative of foreign affairs, Josep Borrell, which Paet referred to as having gone "predictably badly."
An added dimension is the EU's Eastern Partnership (EaP) project, which sees the bloc supporting most of the states, such as Ukraine, Moldova and Georgia, which were formerly a part of the Soviet Union but are not EU member states.
EU leaders have generally expressed positive views on the progress of these states, Paet added.
Estonia, Latvia and Lithuania joined the EU, and NATO, in 2004.
The involvement of all member states in the recent talks which saw overtures to Russia removed from the table, for the time being, was right both in its outcome and in the fact that all member states took part, Paet said.
eurussiavladimir putinemmanuel macronangela merkelurmas paeteu-russia relationsfrance-estonia relationsgermany-estonia relations
Prime minister: Afghanistan, Belarus situations gravely concerning
Kontaveit through to Eastbourne semi-finals
Kallas wants to know justification behind proposed new EU-Russia summit
Estonia joins several other EU nations in condemning Hungary LGBT+ stance
NATO planes scrambled eight times last week in response to Russia flights
Estonia's bid for Arctic Council observer status unsuccessful
Jüri Luik: Russia-West relations like a dialogue between a deaf and a mute
Prime Minister joins von der Leyen, Merkel to launch EU digital initiative


text:
Q: QEventLoop discard some signal I have a question about QEventLoop: how to set a QEventLoop  to discard some signal
class MyThread : public QThread
{
    Dialog *_dlg;
public:
    MyThread(Dialog* dlg)
        : _dlg(dlg)
    {

    }
    virtual void run()
    {
        QTimer* _timer;
        _timer = new QTimer(this);
        connect(_timer, SIGNAL(timeout()),
                _dlg, SLOT(timeout()), Qt::BlockingQueuedConnection);
        _timer->start(3000);

        QEventLoop loop;
        loop.exec(QEventLoop::WaitForMoreEvents);
    }
};

Dialog::Dialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Dialog)
{
    ui->setupUi(this);

    connect(ui->pushButton, SIGNAL(clicked()),
            this, SLOT(click()));

    MyThread* thread = new MyThread(this);
    thread->start();
}

Dialog::~Dialog()
{
    delete ui;
}

void Dialog::click()
{
    QMessageBox msgBox(this);
    msgBox.setText("click.");
    msgBox.exec();
}

void Dialog::timeout()
{
    QMessageBox msgBox(this);
    msgBox.setText("timeout.");
    msgBox.exec();
}

this is my code  when start this programe , every 5 second a timeout QMessageBox will be show  .
but i want if i press button then  show the click messagebox and  do not show the  timeout messagebox..
i failed to find any method to do it

redpajama_set_name: RedPajamaStackExchange


Choose the GPISD after-school care proram for your student. Conveniently located on-site at your school, we provide a safe and nurturing environment from school's last bell until 6:30 P.M.
Certified teachers and highly trained child care professionals will lead students in a fun and learning-rich environment without leaving the campus. A daily afternoon snack, dedicated homework time, fun and fitness activities, S.T.E.M. activities and much more, it is a guaranteed great time!
Beyond the Bell After School Program is designed to meet parents' childcare needs, as well as provide social, educational, and recreational opportunities for students. Located on 21 campuses in Grand Prairie ISD, serving Pre-K - 6th grade students who can successfully function in a 1:17 teacher/student ratio. Our program is offered each school day from the ringing of the last bell until 6:30 p.m.
Monday thru Thursday 8 a.m. - 4:30 p.m.
Fridays 8 a.m. - 4 p.m.


text:
Q: Conditional formatting cells in range if the cell value exist in a different column In Google spreadsheet, we have column A which is an input list. Other columns from B to G are filled list. Filled list cells should highlight when cell value matches with input list.
The problem is I can not use MATCH as matching is with the range not column or row.
Here is the expected result.

A: You definetely can use Match. But you need to use it with ISERROR & NOT formula.
You need apply the following Conditional formatting to the entire range starting from B1.
=NOT(ISERROR(MATCH(B1,$A:$A,0)))

Note: if you copy the formula exactly, you need to apply it to the Range starting from B! For it work.


text:
Home > lha > ASJ > Vol. 8 (2019) > No. 1
Kaimangatanga: Maori Perspectives on Veganism and Plant-based Kai
Kirsty Dunn, University of Canterbury, New Zealand
In this paper – drawing from a range of food blogs and social media pages – I consider both the ways in which Māori writers discuss some of the barriers and cultural conflicts experienced within the realm of vegan ethics, as well as their perspectives on various facets of Te Ao Māori (the Māori world) such as kaitiakitanga (guardianship), hauora (holistic health and wellbeing), and rangatiratanga (sovereignty) which have influenced their attitudes and approaches towards veganism and plant-based diets. I argue that these diverse perspectives provide a valuable means of analysing and critiquing both the dominant ethics and attitudes which perpetuate the exploitation of non-human animals in contemporary Western society, as well as the barriers and challenges that exist within the mainstream vegan movement.
Dunn, Kirsty, Kaimangatanga: Maori Perspectives on Veganism and Plant-based Kai, Animal Studies Journal, 8(1), 2019, 42-65.
Available at:https://ro.uow.edu.au/asj/vol8/iss1/4
Agricultural and Resource Economics Commons, Art and Design Commons, Art Practice Commons, Australian Studies Commons, Communication Commons, Creative Writing Commons, Digital Humanities Commons, Education Commons, English Language and Literature Commons, Feminist, Gender, and Sexuality Studies Commons, Film and Media Studies Commons, Fine Arts Commons, Legal Studies Commons, Linguistics Commons, Philosophy Commons, Political Science Commons, Public Health Commons, Race, Ethnicity and Post-Colonial Studies Commons, Sociology Commons, Theatre and Performance Studies Commons
All Issues Vol. 8, No. 1 Vol. 7, No. 2 Vol. 7, No. 1 Vol. 6, No. 2 Vol. 6, No. 1 Vol. 5, No. 2 Vol. 5, No. 1 Vol. 4, No. 2 Vol. 4, No. 1 Vol. 3, No. 2 Vol. 3, No. 1 Vol. 2, No. 2 Vol. 2, No. 1 Vol. 1, No. 1


A wonderful, kind and caring man, Don will be missed by all who knew him. Words cannot express my heartfelt sympathy to you for your loss. Anne, my deepest condolences and a hug. May happy memories bring you comfort and peace.
My thoughts and prayers are with you at this time. Don was a hell of a sailor and ALWAYS made every CYC Regatta for decades. I first meet him when he had his Ensign. Nothing but great memories of Don and sailing out of CYC.
Don was truly one of kind, a man that I respected. He was a generous person whose guidance and advice was intelligent and insightful. I will remember him fondly and appreciate the time I spent with him.
- Im sure he will be watching the crew from heaven guiding them to victory.
Prayers and thoughts to the Esarove family.
Don was a real gentleman, who will be missed by all lucky enough to have known him.
Don was the dot on the i and the cross on the t for many projects that only came to fruition with his generous interest and contribution. He is and will be missed.
I first really got to know Don when we were members of a Board of Directors. He was always thoughtful and caring in everything he did. Don was a good friend and provided assistance and support when needed.
I will sorely miss you, Don. Thanks for being you and a part of my life.
We are sincerely saddened by your loss. We have many fond memories of racing against Sloopy at CYC Yacht Club. Don was a truly lovely man and will be missed.
I enjoyed working with Donald for years. I learned a lot from him and will miss him. My best to Don's family.
My sincere condolences to your family. May God give you comfort during your time of sadness.
Sail on with our love and peace Mr. Esarove you leave an amazing family in your wake.


Serious safety precautions are necessary. The procedure is explained in the Goodyear Video. This video should be available from Hummer dealers or AMG.
Tools used but not pictured: Second pry bar, Rubber Mallet.


text:
Narrow Sort
Brief Report (1)
groin flap (1)
home care services (1)
From: To: Apply
SORT: Best Match Most Recent Oldest
VIEW: Basic | Expanded
Other November 1993
Carol H. Gwin
Am J Occup Ther. 1993; 47(11):1043. https://doi.org/10.5014/ajot.47.11.1043
Book Review April 1991
Assistive Technology Sourcebook
Carol H. Gwin, OTR
Am J Occup Ther. 1991; 45(4):379-380. https://doi.org/10.5014/ajot.45.4.379b
Other August 1989
Home Health Care Revisited: Challenges for the Future
Sharon A. Stoffel; Carol H. Gwin
TOPICS: home care services
Am J Occup Ther. 1989; 43(8):499-502. https://doi.org/10.5014/ajot.43.8.499
Book Review July 1989
Cognitive Rehabilitation Resources for the Apple II Computer
Am J Occup Ther. 1989; 43(7):485. https://doi.org/10.5014/ajot.43.7.485a
Book Review August 1985
Enhancing Productivity in Health Care Facilities
Am J Occup Ther. 1985; 39(8):548. https://doi.org/10.5014/ajot.39.8.548b
Book Review January 1984
Sourcebook of Aid for the Mentally and Physically Handicapped
Am J Occup Ther. 1984; 38(1):54. https://doi.org/10.5014/ajot.38.1.54b
Brief Report August 1983
Versatile Sling-Support for Groin Flap
Carol H. Gwin; A. Lee Dellon
TOPICS: sling, groin flap


text:
Borland John Image 1 Raith Rovers 1922
Home/England & Wales 1921 - 1930, Scotland 1921 - 1930, Scotland 1931 - 1940/Borland John Image 1 Raith Rovers 1922
Borland John Image 1 Raith Rovers 1922 quantity
SKU: borland-john-image-1-raith-1922 Categories: England & Wales 1921 - 1930, Scotland 1921 - 1930, Scotland 1931 - 1940 Tags: Alloa Athletic, Charlton Athletic, Cowdenbeath, Hamilton Academical, Kilmarnock, Merthyr Town, Raith Rovers, Southend United, Stenhousemuir
Rutherglen, Lanarkshire born winger John Borland began his football career with Rutherglen Glencairn in 1921 and joined Scottish League Raith Rovers in 1922, moving to Kilmarnock in 1923 and to Hamilton Academical in 1925 having played on loan at Cowdenbeath in 1924. He moved south of the border to join Third Division (South) Charlton Athletic in 1927, making his Football League debut against Coventry City in January 1928, scoring a debut goal in a 2-1 victory. But after only 6 further appearances he moved on to Merthyr Town in the 1928 close season, where he was a near ever present in 1928-29, missing only one game and scoring 3 times in 43 matches.
Nonetheless he again moved on, this time to Southend United in the summer of 1929, for whom he scored 3 goals in 21 appearances in 1929-30 before returning to Scottish football with Alloa Athletic in 1930. He returned to Rutherglen Glencairn in 1931 and finished his career with Stenhousemuir, whom he joined in 1932.
Booth Bobby Image 1 Southend United 1922
Edwards Evan Image 1 Wolverhampton Wanderers 1923
Clarke Horace Image 1 Exeter City 1922
Lawley George Image 1 Dundee 1928
Bastin Cliff Image 9 Exeter City 1928 £8.95 – £49.95
Bishop Alf Image 4 Wolverhampton Wanderers 1908 £8.95 – £49.95
Gallacher Patsy Image 2 Glasgow Celtic 1923 £8.95 – £49.95
Calladine Charlie Image 1 Birmingham City 1934 £8.95 – £49.95


Wiklund Trading AB was founded in 2003 by Niklas and Henrik Wiklund and Per Liljeblad. Together we have more than 40 years experience dealing in different kind of construction- and roadmachines like; asphaltpavers, asphaltplants, rollers, miniexcavators, wheelloaders, platecompactors, compressors etc. We are the official agent in Sweden selling new KRAMER, YANMAR and CANGINI. We also have a large stock of used machines. We are regularly exporting machines like asphaltpavers and rollers all over the world.
We can offer competetive seafreights by ro/ro or container vessels all over the world. We have different loading facilities on site to allow flatbeds and trailers as well as container loading. "F.A.S." or "CFR" – we can ensure that all our customers will have the best service price required to transport and/or to ship equipment efficiently.


Thread: Where to buy Kayfun lite plus clone in au?
Ordered one from FT and when I read estimated delivery date, is was November this year!
Vaphilia has the Tobeco clone.
I've got 3 of them. The air flow does not work at all on one of them and they leak a little bit.
I think it's coming from the fill screw, which doesn't have an o-ring.
But they vape really nicely.
True, but after a quick look it would appear that lots of people have problems with a slight leak from the fill hole with the clones.
Someone mentioned trying a little bit of teflon tape. I might give that a go.
I have a couple of the Ehpro versions and they have an o-ring under the fill screw. I'm really happy with them.
Where do you get the Ehpro clones from?
Maybe you could machine a step in the base to fit a very small o-ring. That is if there is enough thickness in the base!
These are a kayfun style Atty, with an adjustable airflow ring, I know these aren't in Australia, but this vendor ships pretty quickly, and faster than FT. They are good quality and great for a beginner to learn on. At this price they are IMHO the best way to get into rebuildables without dropping a lot of cash.
I have 3 of these now, and have never had any problems with them, no leaking, no whistling, and they work well every time.
Certainly worth a look if you want to try a kayfun style atty.
It's not a real concern, plus I've also got some on order from FT that might be better in that regard.
Which one did you order from FT? Most seem to be listed in the 5 to 7 day mark.
Sure you didn't confuse the way the Chinese do their dates? They do it like the Americans.
They put the month before the day, so 4/11/14 is the 11th of April, not the 4th of November.
I wonder if they are compatible with the likes of these clear tanks that I've been using with my Tobeco's and Hcigar clones?
Edit : Actually, the more I look at it I doubt that they can be used.
I just noticed also that it has a clear tank included anyway.
I might grab a couple of them.
Last edited by thunderlips; 07-04-14 at 11:47 AM.


Rep. Knute Buehler secured the Republican nomination for governor Tuesday night and will face Gov. Kate Brown in November.
For a race that appeared to only get tighter as it wore on, Rep. Knute Buehler won the Republican nomination by a significant margin Tuesday, defeating his more-conservative opponents by a double-digit margin.
Buehler, R-Bend, secured 47.8 percent of the vote, far outpacing Bend businessman Sam Carpenter's 29.5 percent and former Navy pilot Greg Wooldridge's 17.2 percent, according to ballot returns as of 10 p.m.
"It speaks of the desire for change in the state of Oregon, that the status quo is no longer acceptable," Buehler said.
He will face Gov. Kate Brown in the general election, a rematch of the 2012 race for Secretary of State which Brown won. He said his experience in that race taught him a lot about running for office.
"I learned that I don't like to lose elections and I don't intend to ever do it again," Buehler said.
Carpenter became a frequent foil to Buehler, challenging him on his conservative credentials. He said Tuesday that despite their disagreements, he will support Buehler.
Wooldridge also said in a statement that he supports Buehler as the nominee and will continue to work for the betterment of Oregon.
"Gov. Kate Brown's failed leadership has run the ship of Oregon aground," Wooldridge said. "I am going to be working on advocacy, mobilization and fundraising to help manifest change."
Brown, meanwhile, won the Democratic nomination with a commanding 80.9 percent over Democrat challengers Ed Jones and Candace Neville. This came as no surprise — neither Jones nor Neville ran an aggressive campaign and did not have significant funds to compete in a meaningful way.
Before the Republican winner was known, Brown called on the eventual challenger to join her in at least three debates between now and November.
"Voters deserve to hear directly from us where we stand on the issues," she said. "I'm fighting to ensure every Oregonian has access to a quality education, a good job and affordable health care."
Statewide voter turnout as of Tuesday night was only 29 percent.
In the Independent Party primary, write-in votes surpassed each of the three Independent candidates on the ballot. So far 53.4 percent of ballots returned voted for a write-in.
Independent candidate Patrick Starnes said he believes most of the write-ins are for Brown or Buehler. He said he and other Independent voters have been inundated by ads from the two candidates encouraging voters to write-in their names.
Starnes is a single-issue candidate running on a platform of campaign finance reform, and getting money out of politics is a major goal of the Independent Party, too.
"It would be a shame for the big moneys to steal the Independent nomination," Starnes said. "This proves that point very well if they steal this election from the Independents."
The 10-man Republican primary had appeared to show signs of tightening for the past six weeks, with Buehler seeming to pay closer attention to his opponents with a live debate and broadcast advertising. For state politicos, Buehler was considered a front-runner because of his edge in fundraising and support from top establishment Republicans.
Both of those advantages came into play as election day drew nearer.
The Buehler campaign dramatically increased its spending from the beginning of April to election day, according to Secretary of State campaign finance records.
Buehler started the month of April with about $1.7 million on hand. Between then and May 7 (his most recent posting of financial information), his campaign spent about $1.7 million and received $505,000.
Wooldridge raised nearly $300,000 during his three months on the campaign trail, much of it from out-of-state connections.
Carpenter's campaign brought in about $250,000, but also received $128,000 in loans from Carpenter himself, and had more than $160,000 in outstanding accounts payable and personal expenditures for reimbursement as of Monday.
As of May 7, Buehler's campaign has about $458,000 on hand compared to Brown's $3.8 million. But, analysts said, if national Republican donors believe Buehler has a chance to defeat Brown in November, he will not have to worry about running out of money.
As for establishment support, a week before ballots were due, House Republican Leader Mike McLane, R-Powell Butte, released a letter encouraging Oregon Republicans to vote for Buehler. McLane wrote that Buehler was the one candidate who could mount a successful campaign against Brown.
The letter was signed by 10 other Republican lawmakers.
The argument of which candidate had the best chance to defeat Brown in November was central in the candidate's closing statements to voters.
Buehler relied on his legislative experience and more-moderate record; Wooldridge said he is a "pragmatic conservative" with the right demeanor and leadership experience to guide the state; Carpenter described himself as a Trump conservative who will be able to rally the Republican base needed for victory.
The conservative duo of Carpenter and Wooldridge spent much of the campaign painting Buehler as a near-Democrat who would be unable to rally conservative voters in the fall.
Oregonians will find out on Nov. 6 if those statements were prophetic or just political.


California's South Central Coast region, from San Miguel down to Santa Barbara, now boasts well over 200 wineries and vineywards, plus a variety of inns, hotels and restaurants. The new Quick Access® California South Central Coast Wine Country soft-cover book is filled with lush color photography highlighting the vineyards, wineries, tasting rooms, picturesque towns and attractions in this up and coming area. The book includes regional wine maps, wine-making information, and sections about nearby attractions like Hearst Castle, Santa Barbara and Solvang, and off-the-beaten-track recreational areas.