// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

//

/**

 @file

 @internalComponent

*/

#ifndef SYMBIAN_SS_COREPRSTATES_H

#define SYMBIAN_SS_COREPRSTATES_H

#include <comms-infras/ss_nodemessages_serviceprovider.h>

#include <comms-infras/ss_mmcommsprov.h>

#include <comms-infras/ss_nodeinterfaces.h>

#include <elements/mm_mutexpolicies.h>

#include <elements/mm_states.h>

#include <comms-infras/ss_activities.h>

#include <comms-infras/ss_common.h>

//-=========================================================

//

//Panics

//

//-=========================================================

namespace CorePanics

{

enum

	{

	KPanicNoActivity = 1,

	KPanicNoServiceProvider = 2,

	KPanicNoControlProvider =3,

	KPanicNoDataClient = 4,

	KPanicNoCSR = 5,

	KPanicNoSelectionPreferences = 6,

	KPanicNoConnection = 7,

	KPanicNoAvailabilityProvider = 8,

	KPanicExpectedNoCSR = 9,

	KPanicExpectedNoServiceProvider = 10,

	KPanicClientsStillPresent =11,

	KPanicIncorrectMessage = 12,

	KOverridenProvisionMessage =13,

	KPanicPeerMessage =14,

	KPanicDataClient = 15,

	KPanicUnexpectedExecutionPath =16,

	KPanicExtInterfaceNotSupported =17,

	KPanicInterfaceNotSupported = 18,

	KPanicIncorrectState = 19,

	KPanicPeerMisbehaving = 20,

	KPanicActivity = 21,

	KPanicNoContext = 22,

	KPanicMultipleDefaultDataClients = 23

	};

}

namespace CoreStates

{

typedef MeshMachine::TNodeContext<ESock::ACFMMNodeBase, MeshMachine::TContext> TContext;

//-=========================================================

//

//Core Transition Ids 1000..1999

//

//-=========================================================

const TInt KNoPeer              = 1000;

const TInt KPeerPresent         = 1001;

const TInt KPeerReady           = 1002;

const TInt KPeerNotReady        = 1003;

const TInt KUseExisting         = 1004;

const TInt KLoopTag             = 1005;

const TInt KSetIdle             = 1006;

const TInt KRecoverableErrorTag = 1007;

const TInt KRetry               = 1008;

const TInt KIgnore              = 1009;

const TInt KPropagate           = 1010;

const TInt KCommit	            = 1011;

//-=========================================================

//

//States

//

//-=========================================================

class ASetErrorState

    {

protected:

	IMPORT_C static TBool Accept(MeshMachine::TNodeContextBase& aContext, TBool aSuperAccept);

	};

template<class TSTATE, class TCONTEXT = CoreStates::TContext>

class TSetErrorState  : public TSTATE, public ASetErrorState

    {

public:

	NETSM_TPL_DECLARE_CTR(TSetErrorState, NetStateMachine::MState, TCONTEXT)

    explicit TSetErrorState(TCONTEXT& aContext)

    :	TSTATE(aContext)

        {

        }

	virtual TBool Accept()

    	{

    	return ASetErrorState::Accept(this->iContext, TSTATE::Accept());

    	}

    };

EXPORT_DECLARE_SMELEMENT_HEADER( TNeverAccept,  MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TNeverAccept )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingJoinComplete, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingJoinComplete )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingClientLeave, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingClientLeave )

//-=========================================================

//

//State Forks

//

//-=========================================================

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrRecoverableErrorTagOrErrorTag, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrRecoverableErrorTagOrErrorTag )

EXPORT_DECLARE_SMELEMENT_HEADER( TPeerPresent, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TPeerPresent )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrNoPeer, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrNoPeer )

EXPORT_DECLARE_SMELEMENT_HEADER( TRetryOrIgnoreOrPropagate, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TRetryOrIgnoreOrPropagate )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrNoClients, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

  	virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrNoClients )

class ACancelOrErrorOrTag

    {

protected:

	IMPORT_C static TInt TransitionTag(MeshMachine::TNodeContextBase& aContext, TInt aTag);

	};

template<TInt TAG>

class TCancelOrErrorOrTag : public MeshMachine::TStateFork<TContext>, public ACancelOrErrorOrTag

    {

public:

	NETSM_TPL_DECLARE_CTR(TCancelOrErrorOrTag, NetStateMachine::MStateFork, TContext)

    TCancelOrErrorOrTag(TContext& aContext) :

        MeshMachine::TStateFork<TContext>(aContext)

        {

        }

	virtual TInt TransitionTag()

    	{

    	return ACancelOrErrorOrTag::TransitionTag(this->iContext, TAG);

    	}

    };

//-=========================================================

//

//Transitions

//

//-=========================================================

//-=========================================================

// CCFActivityBase::SetError handling transitions and states

//-=========================================================

EXPORT_DECLARE_SMELEMENT_HEADER( TPanic, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

	IMPORT_C virtual void DoL();

DECLARE_SMELEMENT_FOOTER( TPanic )

EXPORT_DECLARE_SMELEMENT_HEADER( TPostToOriginators, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

	IMPORT_C virtual void DoL();

DECLARE_SMELEMENT_FOOTER( TPostToOriginators )

EXPORT_DECLARE_SMELEMENT_HEADER( TSetIdleIfMoreClients, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

	IMPORT_C virtual void DoL();

DECLARE_SMELEMENT_FOOTER( TSetIdleIfMoreClients )

EXPORT_DECLARE_SMELEMENT_HEADER( TAbortAllActivities, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

	IMPORT_C virtual void DoL();

DECLARE_SMELEMENT_FOOTER( TAbortAllActivities )

EXPORT_DECLARE_SMELEMENT_HEADER( TAbortAllActivitiesNodeDeletion, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

	IMPORT_C virtual void DoL();

DECLARE_SMELEMENT_FOOTER( TAbortAllActivitiesNodeDeletion )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagBackwardsOrCancel, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagBackwardsOrCancel )

} //namespace CoreStates

namespace CoreNetStates

{

typedef CoreStates::TContext TContext;

//-=========================================================

//

//Net Core Transition Ids 2000..3999

//

//-=========================================================

const TInt KNoBearer                      = 2000;

const TInt KBearerPresent                 = 2001;

const TInt KBearerReady                   = 2002;

const TInt KNoDataClients                 = 2003;

const TInt KDataClientPresent             = 2004;

const TInt KDataClientReady               = 2005;

const TInt KDataClientNotReady            = 2006;

const TInt KProviderStopped               = 2007;

const TInt KDataClientIdle                = 2008;

const TInt KDataClientNoLongerIdle        = 2009;

const TInt KBearerNoDataClientsToStop     = 2010;

const TInt KNoBearerNoDataClients         = 2011;

const TInt KNonDefault                    = 2012;

const TInt KWaitForIncoming               = 2013;

const TInt KLayerCompleted                = 2014;

const TInt KDataClientsToStop             = 2015;

const TInt KNoDataClientsToStop           = 2016;

const TInt KDataClientsToStart            = 2017;

const TInt KNoDataClientsToStart          = 2018;

const TInt KAlreadyStarted                = 2019;

const TInt KAlreadyStopped                = 2020;

const TInt KBindToComplete                = 2021;

const TInt KNoClients                     = 2022;

const TInt KUnbind                        = 2023;

const TInt KProviderStarted               = 2024;

const TInt KAttachToDefault               = 2025;

//-=========================================================

//

//States

//

//-=========================================================

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientStart, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientStart )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingStart, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingStart )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientStop, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientStop )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingControlClientJoin, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingControlClientJoin )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientJoinRequest, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientJoinRequest )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientJoin, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientJoin )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingBinderResponse, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingBinderResponse )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingBindToComplete, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingBindToComplete )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingStarted, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingStarted )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingProvision, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingProvision )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingGoneDown, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingGoneDown )

DECLARE_SMELEMENT_HEADER( TAwaitingGoneUp, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

    virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingGoneUp )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingBindTo, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingBindTo )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingBindToOrCancel, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingBindToOrCancel )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingStopped, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

 	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingStopped )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingNoBearer, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingNoBearer )

DECLARE_SMELEMENT_HEADER( TAwaitingCSRCreated, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingCSRCreated )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientStarted, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientStarted )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientsStarted, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientsStarted )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingRejoinDataClientComplete, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingRejoinDataClientComplete )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientRejoinOrApplyOrCancel, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientRejoinOrApplyOrCancel )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingApplyResponse, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingApplyResponse )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingParamResponse, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingParamResponse )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingSubConEvent, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingSubConEvent )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingConEvent, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingConEvent )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientRejoin, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientRejoin )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientIdle, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientIdle )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientActive, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientActive )

//Awaiting one data client stopped

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientStopped, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientStopped )

//Awaiting all of the data clients stopped

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientsStopped, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientsStopped )

EXPORT_DECLARE_SMELEMENT_HEADER( TSendDataClientGoneDown, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

	IMPORT_C virtual void DoL();

DECLARE_SMELEMENT_FOOTER( TSendDataClientGoneDown )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientGoneDown, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientGoneDown )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingBinderRequest, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingBinderRequest )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingStop, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingStop )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingProviderStatusChangeOrDataClientStatusChange, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingProviderStatusChangeOrDataClientStatusChange )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDataClientStatusChange, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDataClientStatusChange )

/**

 * State awaiting a message which has derived from TCFSigLegacyRMessage2

 * @publishedPartner

 * @released since tb9.2

 */

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingLegacyRMessage2Ext, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingLegacyRMessage2Ext )

/**

 * State awaiting TLegacyRMessage2Processed message

 * @publishedPartner

 * @released since tb9.2

 */

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingRMessage2Processed, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

    IMPORT_C virtual void Cancel();

DECLARE_SMELEMENT_FOOTER( TAwaitingRMessage2Processed )

//-=========================================================

//

//State Forks

//

//-=========================================================

DECLARE_SERIALIZABLE_STATE(

	TNoTagBlockedByBinderRequest,

	MeshMachine::TActivityIdMutex<ESock::ECFActivityBinderRequest>,

	MeshMachine::TNoTag

	)

DECLARE_SERIALIZABLE_STATE(

	TActiveOrNoTagBlockedByBindTo,

	MeshMachine::TActivityIdMutex<ESock::ECFActivityBindTo>,

	MeshMachine::TActiveOrNoTag<ESock::ECFActivityStartDataClient>

	)

typedef MeshMachine::TActivitiesIdMutex<ESock::ECFActivityStop, ESock::ECFActivityNoBearer> TActivityStopOrNoBearerMutex;

DECLARE_SERIALIZABLE_STATE(

	TNoTagBlockedByStopOrNoBearer,

	TActivityStopOrNoBearerMutex,

	MeshMachine::TNoTag

	)

DECLARE_SERIALIZABLE_STATE(

	TNoTagBlockedByStart,

	MeshMachine::TActivityIdMutex<ESock::ECFActivityStart>,

	MeshMachine::TNoTag

	)

typedef MeshMachine::TNoClientMutex<Messages::TDefaultClientMatchPolicy, ESock::TCFClientType::EServProvider,ESock::TCFClientType::EStarted> TNoServiceProviderStartedMutex;

DECLARE_SERIALIZABLE_STATE(

	TNoTagBlockedByNoServiceProviderStarted,

	TNoServiceProviderStartedMutex,

	MeshMachine::TNoTag

	)

typedef MeshMachine::TNoClientMutex<Messages::TDefaultClientMatchPolicy, ESock::TCFClientType::ECtrl|ESock::TCFClientType::EData|ESock::TCFClientType::EAux> TNoClientsMutex;

typedef MeshMachine::TAggregatedMutex_AND<MeshMachine::TActivityIdMutex<ESock::ECFActivityBindTo>, TNoClientsMutex> TBindToAndNoClientsMutex;

DECLARE_SERIALIZABLE_STATE(

	TNoTagBlockedByBindToAndNoClients,

	TBindToAndNoClientsMutex,

	MeshMachine::TNoTag

	)

DECLARE_SERIALIZABLE_STATE(

	TNoTagBlockedByNoBearer,

	MeshMachine::TActivityIdMutex<ESock::ECFActivityNoBearer>,

	MeshMachine::TNoTag

	)

//[RZ] Please remove this at some point - better use TTag<KBearerPresent>

EXPORT_DECLARE_SMELEMENT_HEADER( TBearerPresent, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

     IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TBearerPresent )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrDataClientPresent, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrDataClientPresent )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrDataClientsToStop, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrDataClientsToStop )

typedef MeshMachine::TClientMutex<Messages::TDefaultClientMatchPolicy, ESock::TCFClientType::EData,ESock::TCFClientType::EStarting> TDataClientStartingMutex;

DECLARE_SERIALIZABLE_STATE(

	TNoTagOrDataClientsToStopBlockedByStarting,

	TDataClientStartingMutex,

	CoreNetStates::TNoTagOrDataClientsToStop

	)

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrNoDataClients, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrNoDataClients )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrUnbindOnStop, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrUnbindOnStop )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrBearerPresent, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

  	IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrBearerPresent )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrBearerPresentOrErrorTag, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

	virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrBearerPresentOrErrorTag )

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrNoBearer, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

  	virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrBearer )

DECLARE_SERIALIZABLE_STATE(