public void Write(Dimse dimse)
{
lock(this)
{
pcid = dimse.pcid();
System.String tsUID = fsm.GetAcceptedTransferSyntaxUID(pcid);
if (tsUID == null)
{
throw new System.SystemException();
}
((Dimse) dimse).TransferSyntaxUID = tsUID;
fsm.FireWrite(dimse);
if (pDataTF == null)
{
pDataTF = new PDataTF(fsm.WriteMaxLength);
}
pDataTF.OpenPDV(pcid, cmd = true);
Stream outs = new PDataTFOutputStream(this);
Command c = dimse.Command;
try
{
c.Write(outs);
}
finally
{
outs.Close();
}
if (c.HasDataset())
{
pDataTF.OpenPDV(pcid, cmd = false);
outs = new PDataTFOutputStream(this);
try
{
dimse.WriteTo(outs, tsUID);
}
finally
{
outs.Close();
}
}
FlushPDataTF();
}
}
public virtual void c_store(ActiveAssociation assoc, Dimse rq)
{
Command rqCmd = rq.Command;
Command rspCmd = objFact.NewCommand();
rspCmd.InitCStoreRSP(rqCmd.MessageID, rqCmd.AffectedSOPClassUID, rqCmd.AffectedSOPInstanceUID, SUCCESS);
try
{
DoCStore(assoc, rq, rspCmd);
}
catch (DcmServiceException e)
{
e.WriteTo(rspCmd);
}
Dimse rsp = assocFact.NewDimse(rq.pcid(), rspCmd);
assoc.Association.Write(rsp);
DoAfterRsp(assoc, rsp);
}
public virtual void c_move(ActiveAssociation assoc, Dimse rq)
{
Command rqCmd = rq.Command;
Command rspCmd = objFact.NewCommand();
rspCmd.InitCMoveRSP(rqCmd.MessageID, rqCmd.AffectedSOPClassUID, PENDING);
try
{
DoMultiRsp(assoc, rq, rspCmd, DoCMove(assoc, rq, rspCmd));
}
catch (DcmServiceException e)
{
e.WriteTo(rspCmd);
Dimse rsp = assocFact.NewDimse(rq.pcid(), rspCmd);
assoc.Association.Write(rsp);
DoAfterRsp(assoc, rsp);
}
}
internal void FireWrite(Dimse dimse)
{
if (log.IsInfoEnabled)
{
log.Info("sending " + dimse);
}
if (assocListener != null)
assocListener.Write(assoc, dimse);
}
public virtual void Received(Association src, Dimse dimse)
{
a.Received(src, dimse);
b.Received(src, dimse);
}
public void Write(Dimse dimse)
{
NDC.Push(name);
try
{
msgID = System.Math.Max(dimse.Command.MessageID, msgID);
writer.Write(dimse);
}
finally
{
NDC.Pop();
}
}
// Private -------------------------------------------------------
private void DoMultiRsp(ActiveAssociation assoc, Dimse rq, Command rspCmd, MultiDimseRsp mdr)
{
try
{
assoc.AddCancelListener(rspCmd.MessageIDToBeingRespondedTo, mdr.CancelListener);
do
{
Dataset rspData = mdr.next(assoc, rq, rspCmd);
Dimse rsp = assocFact.NewDimse(rq.pcid(), rspCmd, rspData);
assoc.Association.Write(rsp);
DoAfterRsp(assoc, rsp);
}
while (rspCmd.IsPending());
}
finally
{
mdr.release();
}
}
protected virtual void DoCEcho(ActiveAssociation assoc, Dimse rq, Command rspCmd)
{
// rq.getDataset(); // read out dataset
throw defEx;
}
public virtual void Set(Dimse rsp)
{
lock(this)
{
this.rsp = rsp;
ready = true;
System.Threading.Monitor.PulseAll(this);
}
}
public virtual void Received(Association src, Dimse dimse)
{
}
public virtual void DimseReceived(Association assoc, Dimse dimse)
{
if (dimse.Command.IsPending())
{
pending.Add(dimse);
}
else
{
Set(dimse);
}
}
/// <summary>
/// Handle DIMSE response
/// </summary>
/// <param name="dimse"></param>
private void HandleResponse(Dimse dimse)
{
Command cmd = dimse.Command;
Dataset ds = dimse.Dataset; // read out dataset, if any
int msgID = cmd.MessageIDToBeingRespondedTo;
DimseListenerI l = null;
if (cmd.IsPending())
{
l = (DimseListenerI) rspDispatcher[msgID];
}
else
lock(rspDispatcher)
{
l = (DimseListenerI) rspDispatcher[msgID];
rspDispatcher.Remove(msgID);
System.Threading.Monitor.Pulse(rspDispatcher);
}
if (l != null)
l.DimseReceived(assoc, dimse);
}
/// <summary>
/// Handler DIMSE cancel request
/// </summary>
/// <param name="dimse"></param>
private void HandleCancel(Dimse dimse)
{
Command cmd = dimse.Command;
int msgID = cmd.MessageIDToBeingRespondedTo;
DimseListenerI l = (DimseListenerI)cancelDispatcher[msgID];
cancelDispatcher.Remove(msgID);
if (l != null)
l.DimseReceived(assoc, dimse);
}
/// <summary>
/// Send a DIMSE message
/// </summary>
/// <param name="rq"></param>
/// <returns></returns>
public FutureRSP Invoke(Dimse rq)
{
FutureRSP retval = new FutureRSP();
assoc.AddAssociationListener(retval);
Invoke(rq, retval);
return retval;
}
/// <summary>
/// Send a DIMSE message
/// </summary>
/// <param name="rq"></param>
/// <param name="l"></param>
public void Invoke(Dimse rq, DimseListenerI l)
{
int msgID = rq.Command.MessageID;
int maxOps = assoc.MaxOpsInvoked;
if (maxOps == 0)
{
rspDispatcher.Add(msgID, l);
}
else
lock(rspDispatcher)
{
while (rspDispatcher.Count >= maxOps)
{
System.Threading.Monitor.Wait(rspDispatcher);
}
rspDispatcher.Add(msgID, l);
}
assoc.Write(rq);
}
public virtual void n_set(ActiveAssociation assoc, Dimse rq)
{
Command rqCmd = rq.Command;
Command rspCmd = objFact.NewCommand();
rspCmd.InitNSetRSP(rqCmd.MessageID, rqCmd.RequestedSOPClassUID, rqCmd.RequestedSOPInstanceUID, SUCCESS);
Dataset rspData = null;
try
{
rspData = DoNSet(assoc, rq, rspCmd);
}
catch (DcmServiceException e)
{
e.WriteTo(rspCmd);
}
Dimse rsp = assocFact.NewDimse(rq.pcid(), rspCmd, rspData);
assoc.Association.Write(rsp);
DoAfterRsp(assoc, rsp);
}
protected virtual void DoAfterRsp(ActiveAssociation assoc, Dimse rsp)
{
}
public virtual void Write(Association src, Dimse dimse)
{
}
protected virtual Dataset DoNSet(ActiveAssociation assoc, Dimse rq, Command rspCmd)
{
org.dicomcs.data.Dataset generatedAux = rq.Dataset; // read out dataset
throw defEx;
}
protected override void DoCStore(ActiveAssociation assoc, Dimse rq, Command rspCmd)
{
Command rqCmd = rq.Command;
Stream ins = rq.DataAsStream;
try
{
String instUID = rqCmd.AffectedSOPInstanceUID;
String classUID = rqCmd.AffectedSOPClassUID;
DcmDecodeParam decParam = DcmDecodeParam.ValueOf(rq.TransferSyntaxUID);
Dataset ds = objFact.NewDataset();
DcmParser parser = parserFact.NewDcmParser(ins);
parser.DcmHandler = ds.DcmHandler;
parser.ParseDataset(decParam, Tags.PixelData);
ds.SetFileMetaInfo( objFact.NewFileMetaInfo(classUID, instUID, rq.TransferSyntaxUID) );
FileInfo file = toFile(ds);
storeToFile(parser, ds, file, (DcmEncodeParam) decParam);
rspCmd.PutUS(Tags.Status, SUCCESS);
}
catch (System.Exception e)
{
log.Error(e.Message, e);
throw new DcmServiceException(PROCESSING_FAILURE, e);
}
finally
{
ins.Close();
}
}
protected override void DoCEcho(ActiveAssociation assoc, Dimse rq, Command rspCmd)
{
rspCmd.PutUS(Tags.Status,DcmServiceBase.SUCCESS);
}
/// <summary>
/// Read DIMSE message from the current association
/// </summary>
/// <param name="timeout"></param>
/// <returns></returns>
public Dimse Read(int timeout)
{
lock(this)
{
this.timeout = timeout;
if (!NextPDV())
{
return null;
}
if (!pdv.cmd())
{
Abort("Command PDV expected, but received " + pdv);
}
int pcid = pdv.pcid();
String tsUID = fsm.GetAcceptedTransferSyntaxUID(pcid);
if (tsUID == null)
{
Abort("No Presentation Context negotiated with pcid:" + pcid);
}
Stream ins = new PDataTFInputStream(this, pdv.InputStream);
cmd = dcmObjFact.NewCommand();
bool ds = false;
try
{
cmd.Read(ins);
ds = cmd.HasDataset();
}
catch (ArgumentException e)
{
Abort(e.Message);
}
catch (DcmValueException e)
{
Abort(e.Message);
}
finally
{
ins.Close();
ins= null;
}
if (ds)
{
if (!NextPDV())
{
throw new EndOfStreamException("Association released during receive of DIMSE");
}
if (pdv.cmd())
{
Abort("Data PDV expected, but received " + pdv);
}
if (pcid != pdv.pcid())
{
Abort("Mismatch between Command PDV pcid: " + pcid + " and " + pdv);
}
ins = new PDataTFInputStream(this, pdv.InputStream);
}
else
{
// no Dataset
// if no Data Fragment
ForkNextReadNext();
}
Dimse retval = new Dimse(pcid, tsUID, cmd, ins);
fsm.FireReceived(retval);
return retval;
}
}
internal void FireReceived(Dimse dimse)
{
if (log.IsInfoEnabled)
{
log.Info("received " + dimse);
}
if (assocListener != null)
assocListener.Received(assoc, dimse);
}
public virtual void Write(Association src, Dimse dimse)
{
a.Write(src, dimse);
b.Write(src, dimse);
}
