/// <summary> /// The endpoint to which this endpoint is connected. /// </summary> public static Allocation * /*EndpointCore* opt(ExHeap) */ GetPeer(ref EndpointCore ep, out bool marshall) { // kernel methods always access the shadowed copy in deliveryImpl // not the user accessable copy in EndpointCore return(GetPeerABI(ref ep, out marshall)); }
public static bool PeerClosedABI(ref EndpointCore endpoint) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; return(epimp->PeerClosed()); } }
public static void Close(ref EndpointCore endpoint) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; epimp->Close(); } }
public static void TransferBlockOwnership(Allocation *ptr, ref EndpointCore target) { fixed(EndpointCore *ep = &target) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; EndpointCoreImplementation.TransferBlockOwnership((SharedHeap.Allocation *)ptr, ref *epimp); } }
public static void NotifyPeer(ref EndpointCore endpoint) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; epimp->NotifyPeer(); } }
public static int GetPeerProcessIDABI(ref EndpointCore endpoint) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; return(epimp->PeerProcessId); } }
public static void EnableDelegation(ref EndpointCore endpoint, bool allowMediation) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; epimp->EnableDelegation(allowMediation); } }
public static PrincipalHandle GetOwnerPrincipalHandle(ref EndpointCore endpoint) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; return(epimp->OwnerPrincipalHandle); } }
public static bool Dispose(ref EndpointCore endpoint) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; return(epimp->Dispose()); } }
public static void MarshallPointer(ref EndpointCore endpoint, byte *basep, byte **target, SystemType type, byte *parent, int offset) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; epimp->MarshallPointer(basep, target, type, parent, offset); } }
public static Allocation * /*EndpointCore* opt(ExHeap) */ GetPeerABI(ref EndpointCore endpoint, out bool marshall) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; return((Allocation *)epimp->Peer(out marshall)); } }
/// <summary> /// The event to wait for messages on this endpoint. Used by Select. /// </summary> public static SyncHandle GetWaitHandle(ref EndpointCore endpoint) { // kernel methods always access the shadowed copy in deliveryImpl // not the user accessable copy in EndpointCore fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; return(epimp->GetWaitHandle()); } }
public static int GetOwnerProcessID(ref EndpointCore endpoint) { // kernel methods always access the shadowed copy in deliveryImpl // not the user accessable copy in EndpointCore fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; return(epimp->ProcessId); } }
public static void TransferContentOwnership( ref EndpointCore transferee, ref EndpointCore target) { fixed(EndpointCore *ep1 = &transferee, ep2 = &target) { EndpointCoreImplementation *epimp1 = (EndpointCoreImplementation *)ep1; EndpointCoreImplementation *epimp2 = (EndpointCoreImplementation *)ep2; EndpointCoreImplementation.TransferContentOwnership(ref *epimp1, ref *epimp2); } }
public static bool PeerClosed(ref EndpointCore ep) { if (ep.cachedPeer != null) { EndpointCore *peer = (EndpointCore *)SharedHeapService.GetData(ep.cachedPeer); return(peer->cachedClosed); } else { return(PeerClosedABI(ref ep)); } }
public static int GetPeerProcessID(ref EndpointCore ep) { if (ep.peerStateValid) { EndpointCore *peer = (EndpointCore *)SharedHeapService.GetData(ep.cachedPeer); return(peer->cachedOwnerProcessId); } else { return(GetPeerProcessIDABI(ref ep)); } }
unsafe public static void MarshallMessage(ref EndpointCore endpoint, byte *basep, byte *source, int *tagAddress, int msgSize) { fixed(EndpointCore *ep = &endpoint) { EndpointCoreImplementation *epimp = (EndpointCoreImplementation *)ep; epimp->BeginUpdate(basep, source, tagAddress, msgSize); } }
public static Allocation * /*EndpointCore* opt(ExHeap) */ GetPeer(ref EndpointCore ep, out bool marshall) { if (ep.cachedPeer != null) { marshall = ep.cachedMarshall; return(ep.cachedPeer); } else { return(GetPeerABI(ref ep, out marshall)); } }
/// <summary> /// Indicates if the peer endpoint is closed /// </summary> public static bool PeerClosed(ref EndpointCore ep) { // kernel methods always access the shadowed copy in deliveryImpl // not the user accessable copy in EndpointCore return(PeerClosedABI(ref ep)); }
/// <summary> /// Instruct the selectable object to stop signalling events on the given /// AutoResetEvent. /// </summary> public static void UnlinkFromCollection(ref EndpointCore ep, AutoResetEventHandle ev) { ep.collectionEvent = new AutoResetEventHandle(); }
/// <summary> /// Instruct the selectable object to signal events on the given AutoResetEvent /// rather than its normal event in order to aggregate signalling into a set. /// A selectable object need only support being part of a single collection at /// any point in time. /// </summary> public static void LinkIntoCollection(ref EndpointCore ep, AutoResetEventHandle ev) { ep.collectionEvent = ev; }
public static int GetOwnerProcessID(ref EndpointCore ep) { return(ep.cachedOwnerProcessId); }
public static int GetChannelID(ref EndpointCore ep) { return(ep.cachedChannelId); }
public static int GetPeerProcessID(ref EndpointCore ep) { // kernel methods always access the shadowed copy in deliveryImpl // not the user accessable copy in EndpointCore return(GetPeerProcessIDABI(ref ep)); }
unsafe public static extern void MarshallMessage(ref EndpointCore ep, byte *basep, byte *source, int *tagAddress, int size);
unsafe public static extern void MarshallPointer(ref EndpointCore ep, byte *basep, byte **target, SystemType type, byte *parent, int offset);
public static extern int GetPeerProcessIDABI(ref EndpointCore ep);
/// <summary> /// Wait for a message to arrive on this endpoint. /// </summary> public static void Wait(ref EndpointCore ep) { SyncHandle.WaitOne(GetWaitHandle(ref ep)); }
public static extern void EnableDelegation(ref EndpointCore ep, bool allowMediation);
public static extern PrincipalHandle GetPeerPrincipalHandle(ref EndpointCore ep);