/// <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);
