AbstractBaseOpenSPCoop2Message.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.message;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.ByteArrayOutputStream;
  25. import java.io.InputStream;
  26. import java.io.OutputStream;
  27. import java.io.Serializable;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.Map;

  34. import javax.xml.soap.SOAPBody;

  36. import org.openspcoop2.message.constants.Costanti;
  37. import org.openspcoop2.message.constants.MessageRole;
  38. import org.openspcoop2.message.constants.MessageType;
  39. import org.openspcoop2.message.constants.ServiceBinding;
  40. import org.openspcoop2.message.context.ContentLength;
  41. import org.openspcoop2.message.context.ContentTypeParameters;
  42. import org.openspcoop2.message.context.Credentials;
  43. import org.openspcoop2.message.context.ForcedResponse;
  44. import org.openspcoop2.message.context.HeaderParameters;
  45. import org.openspcoop2.message.context.MessageContext;
  46. import org.openspcoop2.message.context.SerializedContext;
  47. import org.openspcoop2.message.context.SerializedParameter;
  48. import org.openspcoop2.message.context.StringParameter;
  49. import org.openspcoop2.message.context.UrlParameters;
  50. import org.openspcoop2.message.exception.MessageException;
  51. import org.openspcoop2.message.exception.MessageNotSupportedException;
  52. import org.openspcoop2.message.exception.ParseException;
  53. import org.openspcoop2.message.exception.ParseExceptionUtils;
  54. import org.openspcoop2.message.soap.SoapUtils;
  55. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  56. import org.openspcoop2.message.utils.TransportUtilities;
  57. import org.openspcoop2.message.xml.MessageDynamicNamespaceContextFactory;
  58. import org.openspcoop2.message.xml.MessageXMLUtils;
  59. import org.openspcoop2.utils.MapKey;
  60. import org.openspcoop2.utils.beans.WriteToSerializerType;
  61. import org.openspcoop2.utils.io.notifier.NotifierInputStream;
  62. import org.openspcoop2.utils.serialization.JavaDeserializer;
  63. import org.openspcoop2.utils.serialization.JavaSerializer;
  64. import org.openspcoop2.utils.transport.Credential;
  65. import org.openspcoop2.utils.transport.TransportRequestContext;
  66. import org.openspcoop2.utils.transport.TransportResponseContext;
  67. import org.openspcoop2.utils.transport.TransportUtils;
  68. import org.openspcoop2.utils.xml.DynamicNamespaceContext;
  69. import org.w3c.dom.Node;

  71. /**
  72.  * AbstractBaseOpenSPCoop2Message
  73.  *
  74.  * @author Andrea Poli (apoli@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */
  78. public abstract class AbstractBaseOpenSPCoop2Message implements org.openspcoop2.message.OpenSPCoop2Message {

  80.     /* Message Factory */
  81.     protected OpenSPCoop2MessageFactory messageFactory;
  82.     
  83.     /* Trasporto */ 
  84.     public TransportRequestContext transportRequestContext;
  85.     public TransportResponseContext transportResponseContext;   
  86.     public Map<String, List<String>> forceTransportHeaders = new HashMap<>();
  87.     public Map<String, List<String>> forceUrlProperties = new HashMap<>();
  88.     public OpenSPCoop2MessageProperties forwardTransportHeader = new OpenSPCoop2MessageProperties();
  89.     public OpenSPCoop2MessageProperties forwardUrlProperties = new OpenSPCoop2MessageProperties();
  90.         
  91.     /* Forced Response */
  92.     public String forcedResponseCode;
  93.     public boolean forcedEmptyResponse;
  94.     public ForcedResponseMessage forcedResponse;
  95.     
  96.     /* Context */   
  97.     //public Map<MapKey<String>, Object> context = new HashMap<MapKey<String>, Object>();
  98.     public org.openspcoop2.utils.Map<Object> context = new org.openspcoop2.utils.Map<Object>();
  99.     private String transactionId;
  100.     
  101.     /* ContentType */
  102.     public Map<String, String> contentTypeParamaters = new HashMap<>();
  103.     
  104.     /* MessageType */
  105.     public MessageType messageType;
  106.     
  107.     /* MessageRole */
  108.     public MessageRole messageRole;
  109.     
  110.     /* Content Length */
  111.     public long outgoingsize = -1;
  112.     public long incomingsize = -1;
  113.     public Long incomingSizeForced = null;
  114.     
  115.     /* Errors */
  116.     public ParseException parseException;
  117.     
  118.     /* Protocol Plugin */
  119.     public String protocolName;
  120.     
  121.     /* Stream */
  122.     public NotifierInputStream notifierInputStream;
  123.     
  124.     private static boolean normalizeNamespaceXSITypeDefault = false;
  125.     public static boolean isNormalizeNamespaceXSITypeDefault() {
  126.         return normalizeNamespaceXSITypeDefault;
  127.     }
  128.     public static void setNormalizeNamespaceXSITypeDefault(boolean normalizeNamespaceXSITypeDefault) {
  129.         AbstractBaseOpenSPCoop2Message.normalizeNamespaceXSITypeDefault = normalizeNamespaceXSITypeDefault;
  130.     }

  132.     /* Indicazione se la normalizzazione dei namespace per gli attributi xsi:type deve essere effettuata */
  133.     private boolean normalizeNamespaceXSIType = false;
  134.     public boolean isNormalizeNamespaceXSIType() {
  135.         return this.normalizeNamespaceXSIType;
  136.     }
  137.     public void setNormalizeNamespaceXSIType(boolean normalizeNamespaceXSIType) {
  138.         this.normalizeNamespaceXSIType = normalizeNamespaceXSIType;
  139.     }
  140.     
  141.     protected AbstractBaseOpenSPCoop2Message(OpenSPCoop2MessageFactory messageFactory) {
  142.         this.messageFactory = messageFactory;
  143.         this.normalizeNamespaceXSIType = isNormalizeNamespaceXSITypeDefault();
  144.     }
  145.     
  146.     
  147.     /* Message Factory */
  148.     
  149.     @Override
  150.     public OpenSPCoop2MessageFactory getFactory() {
  151.         return this.messageFactory;
  152.     }
  153.     
  154.     
  155.     
  156.     /* Normalize to SAAJ */
  157.     
  158.     @Override
  159.     public OpenSPCoop2Message normalizeToSaajImpl() throws MessageException{
  160.         return this;
  161.     }
  162.     
  163.     
  164.     /* Copy Resources to another instance */
  165.     
  166.     @Override
  167.     public void copyResourcesTo(OpenSPCoop2Message newInstance) throws MessageException{
  168.         this.copyResourcesTo(newInstance, false);
  169.     }
  170.     
  171.     @Override
  172.     public void copyResourcesTo(OpenSPCoop2Message newInstance,  boolean skipTransportInfo) throws MessageException{
  173.         
  174.         // Le seguenti risorse non vengono ricopiate poichè varieranno nella nuova versione
  175.         // - contentTypeParamaters
  176.         // - messageType
  177.         // - outgoingsize
  178.         // - notifierInputStream
  179.         
  180.         if(this.parseException!=null){
  181.             throw new MessageException(this.getParseException().getSourceException());
  182.         }
  183.         
  184.         if(newInstance instanceof AbstractBaseOpenSPCoop2Message){
  185.             AbstractBaseOpenSPCoop2Message base = (AbstractBaseOpenSPCoop2Message) newInstance; 
  186.             if(!skipTransportInfo) {
  187.                 base.transportRequestContext = this.transportRequestContext;
  188.                 base.transportResponseContext = this.transportResponseContext;
  189.                 base.forceTransportHeaders = this.forceTransportHeaders;
  190.                 base.forceUrlProperties = this.forceUrlProperties;
  191.                 base.forwardTransportHeader = this.forwardTransportHeader;
  192.                 base.forwardUrlProperties = this.forwardUrlProperties;
  193.                 base.forcedResponseCode = this.forcedResponseCode;
  194.                 base.forcedEmptyResponse = this.forcedEmptyResponse;
  195.                 base.forcedResponse = this.forcedResponse;
  196.             }
  197.             base.context = this.context;
  198.             base.transactionId = this.transactionId;
  199.             base.messageRole = this.messageRole;
  200.             if(!skipTransportInfo) {
  201.                 base.incomingsize = this.incomingsize;
  202.                 base.incomingSizeForced = this.incomingSizeForced;
  203.             }
  204.             base.protocolName = this.protocolName;
  205.         }
  206.         else{
  207.             // Viene riversato solo quello che è possibile riversare
  208.             if(!skipTransportInfo) {
  209.                 newInstance.setTransportRequestContext(this.transportRequestContext);
  210.                 newInstance.setTransportResponseContext(this.transportResponseContext);
  211.                 
  212.                 if(this.forceTransportHeaders!=null && !this.forceTransportHeaders.isEmpty()) {
  213.                     for (String key : this.forceTransportHeaders.keySet()) {
  214.                         List<String> values = this.forceTransportHeaders.get(key);
  215.                         newInstance.forceTransportHeader(key, values);
  216.                     }
  217.                 }
  218.                 if(this.forceUrlProperties!=null && !this.forceUrlProperties.isEmpty()) {
  219.                     for (String key : this.forceUrlProperties.keySet()) {
  220.                         List<String> values = this.forceUrlProperties.get(key);
  221.                         newInstance.forceUrlProperty(key, values);
  222.                     }
  223.                 }
  224.                 
  225.                 newInstance.setForcedResponseCode(this.forcedResponseCode);
  226.                 if(this.forcedEmptyResponse) {
  227.                     newInstance.forceEmptyResponse();
  228.                 }
  229.                 if(this.forcedResponse!=null) {
  230.                     newInstance.forceResponse(this.forcedResponse);
  231.                 }
  232.                 newInstance.setForcedResponseCode(this.forcedResponseCode);
  233.             }
  234.             if(this.context.size()>0){
  235.                 Iterator<MapKey<String>> it = this.context.keySet().iterator();
  236.                 while (it.hasNext()) {
  237.                     MapKey<String> contextKey = (MapKey<String>) it.next();
  238.                     newInstance.addContextProperty(contextKey, this.context.get(contextKey));
  239.                 }
  240.             }   
  241.             newInstance.setTransactionId(this.transactionId);
  242.             newInstance.setMessageRole(this.messageRole);
  243.             newInstance.setProtocolName(this.protocolName);
  244.         }
  245.     }
  246.     
  247.     @Override
  248.     public MessageContext serializeResourcesTo() throws MessageException{
  249.         try {
  250.             MessageContext msgContext = new MessageContext();
  251.             
  252.             /* Trasporto */ 
  253.             if(this.transportRequestContext!=null) {
  254.                 org.openspcoop2.message.context.TransportRequestContext ctx = new org.openspcoop2.message.context.TransportRequestContext();
  255.                 
  256.                 if(this.transportRequestContext.getParameters()!=null && !this.transportRequestContext.getParameters().isEmpty()) {
  257.                     List<StringParameter> l = this._msgContext_convertTo(this.transportRequestContext.getParameters());
  258.                     if(l!=null && l.size()>0) {
  259.                         UrlParameters urlParameters = new UrlParameters();
  260.                         urlParameters.getUrlParameterList().addAll(l);
  261.                         ctx.setUrlParameters(urlParameters);
  262.                     }
  263.                 }           
  264.                 if(this.transportRequestContext.getHeaders()!=null && !this.transportRequestContext.getHeaders().isEmpty()) {
  265.                     List<StringParameter> l = this._msgContext_convertTo(this.transportRequestContext.getHeaders());
  266.                     if(l!=null && l.size()>0) {
  267.                         HeaderParameters headerParameters = new HeaderParameters();
  268.                         headerParameters.getHeaderParameterList().addAll(l);
  269.                         ctx.setHeaderParameters(headerParameters);
  270.                     }
  271.                 }
  272.                 if(this.transportRequestContext.getCredential()!=null) {
  273.                     Credentials credentials = new Credentials();
  274.                     credentials.setPrincipal(this.transportRequestContext.getCredential().getPrincipal());
  275.                     credentials.setSubject(this.transportRequestContext.getCredential().getSubject());
  276.                     credentials.setUsername(this.transportRequestContext.getCredential().getUsername());
  277.                     credentials.setPassword(this.transportRequestContext.getCredential().getPassword());
  278.                     ctx.setCredentials(credentials);
  279.                 }
  280.                 ctx.setWebContext(this.transportRequestContext.getWebContext());
  281.                 ctx.setRequestUri(this.transportRequestContext.getRequestURI());
  282.                 ctx.setRequestType(this.transportRequestContext.getRequestType());
  283.                 ctx.setSource(this.transportRequestContext.getSource());
  284.                 ctx.setProtocolName(this.transportRequestContext.getProtocolName());
  285.                 ctx.setProtocolWebContext(this.transportRequestContext.getProtocolWebContext());
  286.                 ctx.setFunction(this.transportRequestContext.getFunction());
  287.                 ctx.setFunctionParameters(this.transportRequestContext.getFunctionParameters());
  288.                 ctx.setInterfaceName(this.transportRequestContext.getInterfaceName());

  290.                 msgContext.setTransportRequestContext(ctx);
  291.             }
  292.             if(this.transportResponseContext!=null) {
  293.                 org.openspcoop2.message.context.TransportResponseContext ctx = new org.openspcoop2.message.context.TransportResponseContext();
  294.                 
  295.                 if(this.transportResponseContext.getHeaders()!=null && !this.transportResponseContext.getHeaders().isEmpty()) {
  296.                     List<StringParameter> l = this._msgContext_convertTo(this.transportResponseContext.getHeaders());
  297.                     if(l!=null && l.size()>0) {
  298.                         HeaderParameters headerParameters = new HeaderParameters();
  299.                         headerParameters.getHeaderParameterList().addAll(l);
  300.                         ctx.setHeaderParameters(headerParameters);
  301.                     }
  302.                 }
  303.                 ctx.setTransportCode(this.transportResponseContext.getCodiceTrasporto());
  304.                 if(this.transportResponseContext.getContentLength()>=0) {
  305.                     ctx.setContentLength(this.transportResponseContext.getContentLength());
  306.                 }
  307.                 ctx.setError(this.transportResponseContext.getErrore());
  308.                 
  309.                 msgContext.setTransportResponseContext(ctx);
  310.             }
  311.             
  312.             /* Forced Response */
  313.             if(this.forcedResponseCode!=null || this.forcedEmptyResponse || this.forcedResponse!=null) {
  314.                 ForcedResponse forcedResponse = new ForcedResponse();
  315.                 forcedResponse.setResponseCode(this.forcedResponseCode);
  316.                 forcedResponse.setEmptyResponse(this.forcedEmptyResponse);
  317.                 if(this.forcedResponse!=null) {
  318.                     org.openspcoop2.message.context.ForcedResponseMessage forcedResponseMessage = new org.openspcoop2.message.context.ForcedResponseMessage();
  319.                     forcedResponseMessage.setContent(this.forcedResponse.getContent());
  320.                     forcedResponseMessage.setContentType(this.forcedResponse.getContentType());
  321.                     forcedResponseMessage.setResponseCode(this.forcedResponse.getResponseCode());
  322.                     if(this.forcedResponse.getHeadersValues()!=null && !this.forcedResponse.getHeadersValues().isEmpty()) {
  323.                         List<StringParameter> l = this._msgContext_convertTo(this.forcedResponse.getHeadersValues());
  324.                         if(l!=null && l.size()>0) {
  325.                             HeaderParameters headerParameters = new HeaderParameters();
  326.                             headerParameters.getHeaderParameterList().addAll(l);
  327.                             forcedResponseMessage.setHeaderParameters(headerParameters);
  328.                         }
  329.                     }
  330.                     forcedResponse.setResponseMessage(forcedResponseMessage);
  331.                 }
  332.                 msgContext.setForcedResponse(forcedResponse);
  333.             }
  334.                         
  335.             /* Context */   
  336.             if(this.context!=null && this.context.size()>0) {
  337.                 SerializedContext serializedContext = null;
  338.                 Iterator<MapKey<String>> it = this.context.keySet().iterator();
  339.                 JavaSerializer jSerializer = new JavaSerializer();
  340.                 while (it.hasNext()) {
  341.                     MapKey<String> key = (MapKey<String>) it.next();
  342.                     Object o = this.context.get(key);
  343.                     if(o instanceof Serializable) {
  344.                         if(serializedContext==null) {
  345.                             serializedContext = new SerializedContext();
  346.                         }
  347.                         SerializedParameter p = new SerializedParameter();
  348.                         p.setNome(key.getValue());
  349.                         p.setClasse(o.getClass().getName());
  350.                         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  351.                         try {
  352.                             jSerializer.writeObject(o, bout);
  353.                         }catch(Throwable t) {
  354.                             throw new Exception("Serialization error (nome:"+p.getNome()+" classe:"+p.getClasse()+"): "+t.getMessage(), t);
  355.                         }
  356.                         bout.flush();
  357.                         bout.close();
  358.                         p.setBase(bout.toByteArray());
  359.                         serializedContext.addProperty(p);
  360.                     }
  361.                 }
  362.                 msgContext.setSerializedContext(serializedContext);
  363.             }
  364.     
  365.             /* ContentType */
  366.             if(this.contentTypeParamaters!=null && this.contentTypeParamaters.size()>0) {
  367.                 ContentTypeParameters contentTypeParameters = new ContentTypeParameters();
  368.                 Iterator<String> it = this.contentTypeParamaters.keySet().iterator();
  369.                 while (it.hasNext()) {
  370.                     String key = (String) it.next();
  371.                     String value = this.contentTypeParamaters.get(key);
  372.                     StringParameter parameter = new StringParameter();
  373.                     parameter.setNome(key);
  374.                     parameter.setBase(value);
  375.                     contentTypeParameters.addParameter(parameter);
  376.                 }       
  377.                 msgContext.setContentTypeParameters(contentTypeParameters);
  378.             }
  379.             
  380.             /* MessageType */
  381.             msgContext.setMessageType(this.messageType.name());
  382.             
  383.             /* MessageRole */
  384.             msgContext.setMessageRole(this.messageRole.name());
  385.                         
  386.             /* Content Length */
  387.             if(this.outgoingsize >=0 || this.incomingsize >=0 || this.incomingSizeForced!=null) {
  388.                 ContentLength contentLength = new ContentLength();
  389.                 if(this.outgoingsize >=0) {
  390.                     contentLength.setOutgoingSize(this.outgoingsize);
  391.                 }
  392.                 if(this.incomingsize >=0) {
  393.                     contentLength.setIncomingSize(this.incomingsize);
  394.                 }
  395.                 if(this.incomingSizeForced!=null) {
  396.                     contentLength.setIncomingSizeForced(this.incomingSizeForced);
  397.                 }
  398.                 msgContext.setContentLength(contentLength);
  399.             }
  400.             
  401.             /* Errors */
  402.             // non serializzabile
  403.             
  404.             /* Protocol Plugin */
  405.             msgContext.setProtocol(this.protocolName);
  406.             
  407.             /* Stream */
  408.             // non serializzabile
  409.                 
  410.             return msgContext;
  411.             
  412.         }catch(Exception e) {
  413.             throw new MessageException(e.getMessage(),e);
  414.         }       
  415.     }
  416.     protected List<StringParameter> _msgContext_convertTo(Map<String, List<String>> p){
  417.         List<StringParameter> l = new ArrayList<>();
  418.         if(p.size()>0) {
  419.             Iterator<String> keys = p.keySet().iterator();
  420.             while (keys.hasNext()) {
  421.                 String key = (String) keys.next();
  422.                 List<String> values = p.get(key);
  423.                 if(values!=null && !values.isEmpty()) {
  424.                     for (String value : values) {
  425.                         StringParameter sp = new StringParameter();
  426.                         sp.setBase(value);
  427.                         sp.setNome(key);
  428.                         l.add(sp);      
  429.                     }
  430.                 }
  431.             }
  432.         }
  433.         return l;
  434.     }
  435.     
  436.     @Override
  437.     public void serializeResourcesTo(OutputStream os) throws MessageException{
  438.         try {
  439.             MessageContext messageContext = this.serializeResourcesTo();
  440.             messageContext.writeTo(os, WriteToSerializerType.XML_JAXB);
  441.         }catch(Exception e) {
  442.             throw new MessageException(e.getMessage(),e);
  443.         }   
  444.     }
  445.     
  446.     @Override
  447.     public void readResourcesFrom(MessageContext messageContext) throws MessageException{
  448.         
  449.         try {
  450.         
  451.             /* Trasporto */ 
  452.             if(messageContext.getTransportRequestContext()!=null) {
  453.                 this.transportRequestContext = new TransportRequestContext();
  454.                 
  455.                 if(messageContext.getTransportRequestContext().getUrlParameters()!=null &&
  456.                         messageContext.getTransportRequestContext().getUrlParameters().sizeUrlParameterList()>0) {
  457.                     Map<String, List<String>> p = this._msgContext_convertTo(messageContext.getTransportRequestContext().getUrlParameters().getUrlParameterList());
  458.                     if(p!=null && p.size()>0) {
  459.                         this.transportRequestContext.setParameters(p);
  460.                     }   
  461.                 }
  462.                 if(messageContext.getTransportRequestContext().getHeaderParameters()!=null &&
  463.                         messageContext.getTransportRequestContext().getHeaderParameters().sizeHeaderParameterList()>0) {
  464.                     Map<String, List<String>> p = this._msgContext_convertTo(messageContext.getTransportRequestContext().getHeaderParameters().getHeaderParameterList());
  465.                     if(p!=null && p.size()>0) {
  466.                         this.transportRequestContext.setHeaders(p);
  467.                     }   
  468.                 }
  469.                 if(messageContext.getTransportRequestContext().getCredentials()!=null) {
  470.                     Credential credentials = new Credential();
  471.                     credentials.setPrincipal(messageContext.getTransportRequestContext().getCredentials().getPrincipal());
  472.                     credentials.setSubject(messageContext.getTransportRequestContext().getCredentials().getSubject());
  473.                     credentials.setUsername(messageContext.getTransportRequestContext().getCredentials().getUsername());
  474.                     credentials.setPassword(messageContext.getTransportRequestContext().getCredentials().getPassword());
  475.                     this.transportRequestContext.setCredentials(credentials);
  476.                 }
  477.                 if(messageContext.getTransportRequestContext().getWebContext()!=null) {
  478.                     this.transportRequestContext.setWebContext(messageContext.getTransportRequestContext().getWebContext());
  479.                 }
  480.                 if(messageContext.getTransportRequestContext().getRequestUri()!=null) {
  481.                     this.transportRequestContext.setRequestURI(messageContext.getTransportRequestContext().getRequestUri());
  482.                 }
  483.                 if(messageContext.getTransportRequestContext().getRequestType()!=null) {
  484.                     this.transportRequestContext.setRequestType(messageContext.getTransportRequestContext().getRequestType());
  485.                 }
  486.                 if(messageContext.getTransportRequestContext().getSource()!=null) {
  487.                     this.transportRequestContext.setSource(messageContext.getTransportRequestContext().getSource());
  488.                 }
  489.                 if(messageContext.getTransportRequestContext().getProtocolName()!=null) {
  490.                     this.transportRequestContext.setProtocol(messageContext.getTransportRequestContext().getProtocolName(),
  491.                             messageContext.getTransportRequestContext().getProtocolWebContext());
  492.                 }
  493.                 if(messageContext.getTransportRequestContext().getFunction()!=null) {
  494.                     this.transportRequestContext.setFunction(messageContext.getTransportRequestContext().getFunction());
  495.                 }
  496.                 if(messageContext.getTransportRequestContext().getFunctionParameters()!=null) {
  497.                     this.transportRequestContext.setFunctionParameters(messageContext.getTransportRequestContext().getFunctionParameters());
  498.                 }
  499.                 if(messageContext.getTransportRequestContext().getInterfaceName()!=null) {
  500.                     this.transportRequestContext.setInterfaceName(messageContext.getTransportRequestContext().getInterfaceName());
  501.                 }
  502.                 
  503.             }
  504.             if(messageContext.getTransportResponseContext()!=null) {
  505.                 this.transportResponseContext = new TransportResponseContext();
  506.                 
  507.                 if(messageContext.getTransportResponseContext().getHeaderParameters()!=null &&
  508.                         messageContext.getTransportResponseContext().getHeaderParameters().sizeHeaderParameterList()>0) {
  509.                     Map<String, List<String>> p = this._msgContext_convertTo(messageContext.getTransportResponseContext().getHeaderParameters().getHeaderParameterList());
  510.                     if(p!=null && p.size()>0) {
  511.                         this.transportResponseContext.setHeaders(p);
  512.                     }   
  513.                 }
  514.                 this.transportResponseContext.setCodiceTrasporto(messageContext.getTransportResponseContext().getTransportCode());
  515.                 if(messageContext.getTransportResponseContext().getContentLength()!=null) {
  516.                     this.transportResponseContext.setContentLength(messageContext.getTransportResponseContext().getContentLength());
  517.                 }
  518.                 this.transportResponseContext.setErrore(messageContext.getTransportResponseContext().getError());
  519.             }
  520.                 
  521.             /* Forced Response */
  522.             if(messageContext.getForcedResponse()!=null) {
  523.                 this.forcedResponseCode = messageContext.getForcedResponse().getResponseCode();
  524.                 this.forcedEmptyResponse = messageContext.getForcedResponse().isEmptyResponse();
  525.                 if(messageContext.getForcedResponse().getResponseMessage()!=null) {
  526.                     ForcedResponseMessage f = new ForcedResponseMessage();
  527.                     f.setContent(messageContext.getForcedResponse().getResponseMessage().getContent());
  528.                     f.setContentType(messageContext.getForcedResponse().getResponseMessage().getContentType());
  529.                     f.setResponseCode(messageContext.getForcedResponse().getResponseMessage().getResponseCode());
  530.                     if(messageContext.getForcedResponse().getResponseMessage().getHeaderParameters()!=null &&
  531.                             messageContext.getForcedResponse().getResponseMessage().getHeaderParameters().sizeHeaderParameterList()>0) {
  532.                         Map<String, List<String>> p = this._msgContext_convertTo(messageContext.getForcedResponse().getResponseMessage().getHeaderParameters().getHeaderParameterList());
  533.                         if(p!=null && p.size()>0) {
  534.                             f.setHeadersValues(p);
  535.                         }   
  536.                     }
  537.                     this.forcedResponse = f;
  538.                 }
  539.             }
  540.             
  541.             /* Context */   
  542.             if(messageContext.getSerializedContext()!=null) {
  543.                 JavaDeserializer jDeserializer = new JavaDeserializer();
  544.                 for (SerializedParameter p : messageContext.getSerializedContext().getPropertyList()) {
  545.                     Object o = jDeserializer.readObject(new ByteArrayInputStream(p.getBase()), Class.forName(p.getClasse()));
  546.                     this.context.addObject(org.openspcoop2.utils.Map.newMapKey(p.getNome()), o);
  547.                 }
  548.             }
  549.             
  550.             /* ContentType */
  551.             if(messageContext.getContentTypeParameters()!=null &&
  552.                     messageContext.getContentTypeParameters().sizeParameterList()>0){
  553.                 for (StringParameter par : messageContext.getContentTypeParameters().getParameterList()) {
  554.                     this.contentTypeParamaters.put(par.getNome(), par.getBase());
  555.                 }
  556.             }
  557.             
  558.             /* MessageType */
  559.             MessageType mt = MessageType.valueOf(messageContext.getMessageType());
  560.             if(mt==null) {
  561.                 throw new Exception("MessageType ["+messageContext.getMessageType()+"] unknown");
  562.             }
  563.             if(mt.equals(this.messageType)==false) {
  564.                 throw new Exception("MessageType ["+mt+"] different from instance value ["+this.messageType+"]");
  565.             }
  566.             
  567.             /* MessageRole */
  568.             MessageRole mr = MessageRole.valueOf(messageContext.getMessageRole());
  569.             if(mr==null) {
  570.                 throw new Exception("MessageRole ["+messageContext.getMessageRole()+"] unknown");
  571.             }
  572.             if(mr.equals(this.messageRole)==false) {
  573.                 throw new Exception("MessageRole ["+mr+"] different from instance value ["+this.messageRole+"]");
  574.             }
  575.             
  576.             /* Content Length */
  577.             if(messageContext.getContentLength()!=null) {
  578.                 if(messageContext.getContentLength().getOutgoingSize()!=null) {
  579.                     this.outgoingsize = messageContext.getContentLength().getOutgoingSize();
  580.                 }
  581.                 if(messageContext.getContentLength().getIncomingSize()!=null) {
  582.                     this.incomingsize = messageContext.getContentLength().getIncomingSize();
  583.                 }
  584.                 if(messageContext.getContentLength().getIncomingSizeForced()!=null) {
  585.                     this.incomingSizeForced = messageContext.getContentLength().getIncomingSizeForced();
  586.                 }
  587.             }
  588.             
  589.             /* Errors */
  590.             // non serializzabile
  591.             
  592.             /* Protocol Plugin */
  593.             if(messageContext.getProtocol()!=null) {
  594.                 this.protocolName = messageContext.getProtocol();
  595.             }
  596.             
  597.             /* Stream */
  598.             // non serializzabile
  599.             
  600.         }catch(Exception e) {
  601.             throw new MessageException(e.getMessage(),e);
  602.         }   
  603.     }
  604.     protected Map<String, List<String>> _msgContext_convertTo(List<StringParameter> list){
  605.         Map<String, List<String>> p = new HashMap<>();
  606.         if(list.size()>0) {
  607.             for (StringParameter stringParameter : list) {
  608.                 TransportUtils.put(p, stringParameter.getNome(), stringParameter.getBase(), true);
  609.             }
  610.         }
  611.         return p;
  612.     }
  613.     
  614.     @Override
  615.     public void readResourcesFrom(InputStream is) throws MessageException{
  616.         MessageContext messageContext = null;
  617.         try {
  618.             org.openspcoop2.message.context.utils.serializer.JaxbDeserializer deserializer = 
  619.                     new org.openspcoop2.message.context.utils.serializer.JaxbDeserializer();
  620.             messageContext = deserializer.readMessageContext(is);
  621.         }catch(Exception e) {
  622.             throw new MessageException(e.getMessage(),e);
  623.         }   
  624.         this.readResourcesFrom(messageContext);
  625.     }
  626.     
  627.     
  628.     
  629.     /* Cast */
  630.     
  631.     @Override
  632.     public OpenSPCoop2SoapMessage castAsSoap() throws MessageException{
  633.         if(this instanceof OpenSPCoop2SoapMessage){
  634.             return (OpenSPCoop2SoapMessage) this;
  635.         }
  636.         else{
  637.             throw new MessageException("Instance (type:"+this.getMessageType()+" class:"+this.getClass().getName()+") not usable in SOAP Context");
  638.         }
  639.     }
  640.     
  641.     @Override
  642.     public OpenSPCoop2RestMessage<?> castAsRest() throws MessageException{
  643.         if(this instanceof OpenSPCoop2RestMessage){
  644.             return (OpenSPCoop2RestMessage<?>) this;
  645.         }
  646.         else{
  647.             throw new MessageException("Instance (type:"+this.getMessageType()+" class:"+this.getClass().getName()+") not usable in REST Context");
  648.         }
  649.     }
  650.     
  651.     @Override
  652.     public OpenSPCoop2RestXmlMessage castAsRestXml() throws MessageException{
  653.         if(this instanceof OpenSPCoop2RestXmlMessage){
  654.             return (OpenSPCoop2RestXmlMessage) this;
  655.         }
  656.         else{
  657.             throw new MessageException("Instance (type:"+this.getMessageType()+" class:"+this.getClass().getName()+") not usable in REST-Xml Context");
  658.         }
  659.     }
  660.     
  661.     @Override
  662.     public OpenSPCoop2RestJsonMessage castAsRestJson() throws MessageException{
  663.         if(this instanceof OpenSPCoop2RestJsonMessage){
  664.             return (OpenSPCoop2RestJsonMessage) this;
  665.         }
  666.         else{
  667.             throw new MessageException("Instance (type:"+this.getMessageType()+" class:"+this.getClass().getName()+") not usable in REST-Json Context");
  668.         }
  669.     }
  670.     
  671.     @Override
  672.     public OpenSPCoop2RestBinaryMessage castAsRestBinary() throws MessageException{
  673.         if(this instanceof OpenSPCoop2RestBinaryMessage){
  674.             return (OpenSPCoop2RestBinaryMessage) this;
  675.         }
  676.         else{
  677.             throw new MessageException("Instance (type:"+this.getMessageType()+" class:"+this.getClass().getName()+") not usable in REST-Binary Context");
  678.         }
  679.     }
  680.     
  681.     @Override
  682.     public OpenSPCoop2RestMimeMultipartMessage castAsRestMimeMultipart() throws MessageException{
  683.         if(this instanceof OpenSPCoop2RestMimeMultipartMessage){
  684.             return (OpenSPCoop2RestMimeMultipartMessage) this;
  685.         }
  686.         else{
  687.             throw new MessageException("Instance (type:"+this.getMessageType()+" class:"+this.getClass().getName()+") not usable in REST-MimeMultipart Context");
  688.         }
  689.     }
  690.     
  691.     
  692.     

  694.     /* Trasporto */
  695.     
  696.     @Override
  697.     public void setTransportRequestContext(TransportRequestContext transportRequestContext){
  698.         this.transportRequestContext = transportRequestContext;
  699.     }
  700.     @Override
  701.     public TransportRequestContext getTransportRequestContext(){
  702.         return this.transportRequestContext;
  703.     }
  704.     @Override
  705.     public void setTransportResponseContext(TransportResponseContext transportResponseContext){
  706.         this.transportResponseContext = transportResponseContext;
  707.     }
  708.     @Override
  709.     public TransportResponseContext getTransportResponseContext(){
  710.         return this.transportResponseContext;
  711.     }
  712.     @Override
  713.     public void forceTransportHeader(String name, String value) {
  714.         TransportUtils.setHeader(this.forceTransportHeaders, name, value); // deve sovrascrivere l'eventuale esistente
  715.     }
  716.     @Override
  717.     public void forceTransportHeader(String name, List<String> values) {
  718.         TransportUtils.removeObject(this.forceTransportHeaders, name); // deve sovrascrivere l'eventuale esistente
  719.         if(values!=null && !values.isEmpty()) {
  720.             for (String value : values) {
  721.                 TransportUtils.addHeader(this.forceTransportHeaders, name, value);  
  722.             }
  723.         }
  724.     }
  725.     @Override
  726.     public Map<String, List<String>> getForceTransportHeaders(){
  727.         return this.forceTransportHeaders!=null ? new HashMap<>(this.forceTransportHeaders) : null; // viene ritornata una immagine clonata. Per aggiungere un valore usare metodo force
  728.     }
  729.     @Override
  730.     public void forceUrlProperty(String name, String value) {
  731.         TransportUtils.setParameter(this.forceUrlProperties,name, value); // deve sovrascrivere l'eventuale esistente
  732.     }
  733.     @Override
  734.     public void forceUrlProperty(String name, List<String> values) {
  735.         TransportUtils.removeObject(this.forceUrlProperties, name); // deve sovrascrivere l'eventuale esistente
  736.         if(values!=null && !values.isEmpty()) {
  737.             for (String value : values) {
  738.                 TransportUtils.addParameter(this.forceUrlProperties, name, value);  
  739.             }
  740.         }
  741.     }
  742.     @Override
  743.     public Map<String, List<String>> getForceUrlProperties(){
  744.         return this.forceUrlProperties!=null ? new HashMap<>(this.forceUrlProperties) : null; // viene ritornata una immagine clonata. Per aggiungere un valore usare metodo force
  745.     }
  746.     @Override
  747.     public OpenSPCoop2MessageProperties getForwardTransportHeader(ForwardConfig forwardConfig) throws MessageException{
  748.         OpenSPCoop2MessageProperties msg = this._getForwardTransportHeader(forwardConfig);
  749.         if(msg==null) {
  750.             msg = new OpenSPCoop2MessageProperties();           
  751.         }
  752.         if(this.forceTransportHeaders!=null && this.forceTransportHeaders.size()>0) {
  753.             Iterator<String> it = this.forceTransportHeaders.keySet().iterator();
  754.             while (it.hasNext()) {
  755.                 String key = (String) it.next();
  756.                 List<String> values = this.forceTransportHeaders.get(key);
  757.                 msg.removePropertyValues(key);
  758.                 msg.setProperty(key, values);
  759.             }
  760.         }
  761.         return msg;
  762.     }
  763.     protected OpenSPCoop2MessageProperties _getForwardTransportHeader(ForwardConfig forwardConfig) throws MessageException{
  764.         try{
  765.             if(forwardConfig==null || forwardConfig.isForwardEnable()==false) {
  766.                 return this.forwardTransportHeader;
  767.             }
  768.             if(this.forwardTransportHeader.isInitialize()==false){
  769.                 
  770.                 Map<String, List<String>> transportHeaders = null;
  771.                 if(MessageRole.REQUEST.equals(this.messageRole)){
  772.                     if(this.transportRequestContext!=null){
  773.                         transportHeaders = this.transportRequestContext.getHeaders();
  774.                     }
  775.                 }
  776.                 else{
  777.                     // vale sia per la risposta normale che fault
  778.                     if(this.transportResponseContext!=null){ 
  779.                         transportHeaders = this.transportResponseContext.getHeaders();
  780.                     }
  781.                 }
  782.                 
  783.                 if(transportHeaders!=null && transportHeaders.size()>0){
  784.                     TransportUtilities.initializeTransportHeaders(this.forwardTransportHeader, this.messageRole, transportHeaders, forwardConfig);
  785.                     this.forwardTransportHeader.setInitialize(true);
  786.                 }
  787.             
  788.             }
  789.             return this.forwardTransportHeader;
  790.         }catch(Exception e){
  791.             throw new MessageException(e.getMessage(),e);
  792.         }
  793.     }
  794.     
  795.     @Override
  796.     public OpenSPCoop2MessageProperties getForwardUrlProperties(ForwardConfig forwardConfig) throws MessageException{
  797.         OpenSPCoop2MessageProperties msg = this._getForwardUrlProperties(forwardConfig);
  798.         if(msg==null) {
  799.             msg = new OpenSPCoop2MessageProperties();           
  800.         }
  801.         if(this.forceUrlProperties!=null && this.forceUrlProperties.size()>0) {
  802.             Iterator<String> it = this.forceUrlProperties.keySet().iterator();
  803.             while (it.hasNext()) {
  804.                 String key = (String) it.next();
  805.                 List<String> values = this.forceUrlProperties.get(key);
  806.                 msg.removePropertyValues(key);
  807.                 msg.setProperty(key, values);
  808.             }
  809.         }
  810.         return msg;
  811.     }
  812.     protected OpenSPCoop2MessageProperties _getForwardUrlProperties(ForwardConfig forwardConfig) throws MessageException{
  813.         try{
  814.             if(forwardConfig==null || forwardConfig.isForwardEnable()==false) {
  815.                 return this.forwardUrlProperties;
  816.             }
  817.             if(this.forwardUrlProperties.isInitialize()==false){
  818.                 
  819.                 Map<String, List<String>> forwardUrlParamters = null;
  820.                 if(this.transportRequestContext!=null){
  821.                     forwardUrlParamters = this.transportRequestContext.getParameters();
  822.                 }
  823.                 
  824.                 if(forwardUrlParamters!=null && forwardUrlParamters.size()>0){
  825.                     TransportUtilities.initializeForwardUrlParameters(this.forwardUrlProperties, this.messageRole, forwardUrlParamters, forwardConfig);
  826.                     this.forwardUrlProperties.setInitialize(true);
  827.                 }
  828.             
  829.             }
  830.             return this.forwardUrlProperties;
  831.         }catch(Exception e){
  832.             throw new MessageException(e.getMessage(),e);
  833.         }
  834.     }
  835.     
  836.     
  837.     /* Forced Response */
  838.     
  839.     @Override
  840.     public void setForcedResponseCode(String code){
  841.         this.forcedResponseCode = code;
  842.     }
  843.     @Override
  844.     public String getForcedResponseCode(){
  845.         return this.forcedResponseCode;
  846.     }
  847.     @Override
  848.     public boolean isForcedEmptyResponse() {
  849.         return this.forcedEmptyResponse;
  850.     }
  851.     @Override
  852.     public void forceEmptyResponse() {
  853.         this.forcedEmptyResponse = true;
  854.     }
  855.     @Override
  856.     public void forceResponse(ForcedResponseMessage msg) {
  857.         this.forcedResponse = msg;
  858.     }
  859.     @Override
  860.     public ForcedResponseMessage getForcedResponse() {
  861.         return this.forcedResponse;
  862.     }
  863.     

  865.     /* Context */
  866.     
  867.     @Override
  868.     public void addContextProperty(MapKey<String> property, Object value){
  869.         this.context.put(property, value);
  870.     }
  871.     @Override
  872.     public Iterator<MapKey<String>> keysContextProperty(){
  873.         return this.context.keySet().iterator();
  874.     }
  875.     @Override
  876.     public Object getContextProperty(MapKey<String> property){
  877.         return this.context.get(property);
  878.     }
  879.     @Override
  880.     public Object removeContextProperty(MapKey<String> property){
  881.         return this.context.remove(property);
  882.     }
  883.     
  884.     @Override
  885.     public void setTransactionId(String transactionId) {
  886.         this.transactionId = transactionId;
  887.     }
  888.     @Override
  889.     public String getTransactionId() {
  890.         return this.transactionId;
  891.     }
  892.     
  893.     
  894.     /* ContentType */
  895.     
  896.     @Override
  897.     public void addContentTypeParameter(String name,String value) throws MessageException{
  898.         this.contentTypeParamaters.put(name, value);
  899.     }
  900.     
  901.     @Override
  902.     public void removeContentTypeParameter(String name) throws MessageException{
  903.         this.contentTypeParamaters.remove(name);
  904.     }
  905.     
  906.     
  907.     /* MessageType */
  908.     
  909.     @Override
  910.     public MessageType getMessageType(){
  911.         return this.messageType;
  912.     }
  913.     
  914.     @Override
  915.     public void setMessageType(MessageType messageType){
  916.         this.messageType = messageType;
  917.     }
  918.     
  919.     
  920.     /* MessageRole */
  921.     
  922.     @Override
  923.     public MessageRole getMessageRole() {
  924.         return this.messageRole;
  925.     }
  926.     
  927.     @Override
  928.     public void setMessageRole(MessageRole messageRole) {
  929.         this.messageRole = messageRole;
  930.     }
  931.     
  932.     protected SOAPBody _getSOAPBody_internalAnalyze()throws MessageException, MessageNotSupportedException {
  933.         OpenSPCoop2SoapMessage soapMsg = this.castAsSoap();
  934.         return soapMsg.getSOAPBody();
  935.     }
  936.     @Override
  937.     public boolean isFault() throws MessageException {
  938.         try {
  939.             boolean isFault = false;
  940.             if(ServiceBinding.SOAP.equals(this.getServiceBinding())){
  941.                 if(MessageRole.FAULT.equals(this.getMessageRole())){
  942.                     isFault =  true;
  943.                 }
  944.                 else {              
  945.                     OpenSPCoop2SoapMessage soapMsg = this.castAsSoap();     
  946.                     OpenSPCoop2MessageSoapStreamReader soapReader = soapMsg.getSoapReader();
  947.                     if(soapReader!=null && soapReader.isParsingComplete()) {
  948.                         isFault = soapReader.isFault();
  949.                     }
  950.                     else {
  951.                         SOAPBody soapBody = this._getSOAPBody_internalAnalyze();
  952.                         boolean hasContent = soapBody!=null;
  953.                         if(hasContent){
  954.                             hasContent = SoapUtils.getFirstNotEmptyChildNode(this.messageFactory, soapBody, false)!=null;
  955.                         }
  956.                         isFault = (hasContent && soapBody.hasFault());
  957.                     }
  958.                 }
  959.             }
  960.             else{
  961.                 if(MessageRole.FAULT.equals(this.getMessageRole())){
  962.                     isFault =  true;
  963.                 }
  964.                 else {
  965.                     OpenSPCoop2RestMessage<?> restMsg = this.castAsRest();
  966.                     isFault = restMsg.isProblemDetailsForHttpApis_RFC7807();
  967.                 }
  968.             }
  969.             return isFault;
  970.         }catch(Exception e) {
  971.             throw new MessageException(e.getMessage(),e);
  972.         }
  973.     }
  974.     
  975.     
  976.     /* ServiceBinding */
  977.     
  978.     @Override
  979.     public ServiceBinding getServiceBinding(){
  980.         if(this instanceof OpenSPCoop2SoapMessage){
  981.             return ServiceBinding.SOAP;
  982.         }
  983.         else{
  984.             return ServiceBinding.REST;
  985.         }
  986.     }
  987.     
  988.     
  989.     
  990.     /* Content Length */
  991.     
  992.     @Override
  993.     public void updateIncomingMessageContentLength(){
  994.         // NOP (Viene letta tutta nel costruttore)
  995.     }
  996.     
  997.     @Override
  998.     public void updateIncomingMessageContentLength(long incomingsize){
  999.         this.incomingSizeForced = incomingsize;
  1000.     }
  1001.     
  1002.     @Override
  1003.     public long getIncomingMessageContentLength() {
  1004.         if(this.incomingSizeForced!=null){
  1005.             return this.incomingSizeForced;
  1006.         }else{
  1007.             return this.incomingsize;
  1008.         }
  1009.     }

  1011.     @Override
  1012.     public void updateOutgoingMessageContentLength(long outgoingsize){
  1013.         this.outgoingsize = outgoingsize;
  1014.     }
  1015.     
  1016.     @Override
  1017.     public long getOutgoingMessageContentLength() {
  1018.         return this.outgoingsize;
  1019.     }
  1020.     
  1021.     
  1022.     
  1023.     /* Node Utilities */
  1024.     
  1025.     @Override
  1026.     public String getAsString(Node ele, boolean consume){
  1027.         try {
  1028.             return MessageXMLUtils.getInstance(this.messageFactory).toString(ele,true);
  1029.         } catch (Exception e) {
  1030.             throw new RuntimeException(e);
  1031.         } 
  1032.     }
  1033.     
  1034.     @Override
  1035.     public byte[] getAsByte(Node ele, boolean consume){
  1036.         try {
  1037.             return MessageXMLUtils.getInstance(this.messageFactory).toByteArray(ele,true);
  1038.         } catch (Exception e) {
  1039.             throw new RuntimeException(e);
  1040.         } 
  1041.     }
  1042.     
  1043.     @Override
  1044.     public void addNamespaceXSITypeIfNotExists(Node element, Node root) throws MessageException {
  1045.         try {
  1046.             if(this.normalizeNamespaceXSIType) {
  1047.                 DynamicNamespaceContext dnc = null;
  1048.                 MessageDynamicNamespaceContextFactory dncFactory = MessageDynamicNamespaceContextFactory.getInstance(this.messageFactory);
  1049.                 if(root instanceof javax.xml.soap.SOAPEnvelope) {
  1050.                     javax.xml.soap.SOAPEnvelope soapEnvelope = (javax.xml.soap.SOAPEnvelope) root;
  1051.                     if(Costanti.SOAP12_ENVELOPE_NAMESPACE.equals(soapEnvelope.getNamespaceURI())) {
  1052.                         dnc = dncFactory.getNamespaceContextFromSoapEnvelope12(soapEnvelope);
  1053.                     }
  1054.                     else {
  1055.                         dnc = dncFactory.getNamespaceContextFromSoapEnvelope11(soapEnvelope);
  1056.                     }
  1057.                 }
  1058.                 else {
  1059.                     dnc = dncFactory.getNamespaceContext(root);
  1060.                 }
  1061.                 MessageXMLUtils.getInstance(this.messageFactory).addNamespaceXSITypeIfNotExists(element, dnc, true);
  1062.             }
  1063.         }catch(Exception e) {
  1064.             throw new MessageException(e.getMessage(),e);
  1065.         }
  1066.     }
  1067.     
  1068.     
  1069.     
  1070.     /* Errors */
  1071.     
  1072.     @Override
  1073.     public ParseException getParseException(){
  1074.         return this.parseException;
  1075.     }

  1077.     @Override
  1078.     public void setParseException(ParseException e){
  1079.         this.parseException = e;
  1080.     }
  1081.     
  1082.     @Override
  1083.     public void setParseException(Throwable e){
  1084.         this.parseException = ParseExceptionUtils.buildParseException(e, this.messageRole);
  1085.     }
  1086.     
  1087.     
  1088.     /* Protocol Plugin */
  1089.     
  1090.     @Override
  1091.     public void setProtocolName(String protocolName) {
  1092.         this.protocolName = protocolName;
  1093.     }

  1095.     @Override
  1096.     public String getProtocolName() {
  1097.         return this.protocolName;
  1098.     }
  1099.     
  1100.     
  1101.     /* Stream */
  1102.     
  1103.     @Override
  1104.     public void setNotifierInputStream(NotifierInputStream is) {
  1105.         this.notifierInputStream = is;
  1106.     }

  1108.     @Override
  1109.     public NotifierInputStream getNotifierInputStream() {
  1110.         return this.notifierInputStream;
  1111.     }
  1112.     
  1113. }
Created with JaCoCo 0.8.8.202204050719