/*
(non-Javadoc)

@see org.restcomm.protocols.ss7.isup.ISUPMessageFactory#createGRS(int cic)
515479
public CircuitGroupResetMessage createGRS(int cic) {
        CircuitGroupResetMessage msg = createGRS();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
1120667
@Override
    public UserToUserInformationMessage createUSR() {
        UserToUserInformationMessage msg = new UserToUserInformationMessageImpl(_U2U_HOLDER.mandatoryCodes,
                _U2U_HOLDER.mandatoryVariableCodes, _U2U_HOLDER.optionalCodes, _U2U_HOLDER.mandatoryCodeToIndex,
                _U2U_HOLDER.mandatoryVariableCodeToIndex, _U2U_HOLDER.optionalCodeToIndex);
        return msg;
    }
605691
public InitialAddressMessage createIAM(int cic) {
        InitialAddressMessage msg = createIAM();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
719293
func createGRPCServer() {
	// skip if not registered
	if !isGRPCEnabled() {
		log.Infof("Skipping gRPC server creation")
		return
	}

	grpccommon.EnableTracingOpt()

	var opts []grpc.ServerOption
	if GRPCPort != nil && *GRPCCert != "" && *GRPCKey != "" {
		config, err := vttls.ServerConfig(*GRPCCert, *GRPCKey, *GRPCCA)
		if err != nil {
			log.Exitf("Failed to log gRPC cert/key/ca: %v", err)
		}

		// create the creds server options
		creds := credentials.NewTLS(config)
		opts = []grpc.ServerOption{grpc.Creds(creds)}
	}
	// Override the default max message size for both send and receive
	// (which is 4 MiB in gRPC 1.0.0).
	// Large messages can occur when users try to insert or fetch very big
	// rows. If they hit the limit, they'll see the following error:
	// grpc: received message length XXXXXXX exceeding the max size 4194304
	// Note: For gRPC 1.0.0 it's sufficient to set the limit on the server only
	// because it's not enforced on the client side.
	log.Infof("Setting grpc max message size to %d", *grpccommon.MaxMessageSize)
	opts = append(opts, grpc.MaxRecvMsgSize(*grpccommon.MaxMessageSize))
	opts = append(opts, grpc.MaxSendMsgSize(*grpccommon.MaxMessageSize))

	if *GRPCInitialConnWindowSize != 0 {
		log.Infof("Setting grpc server initial conn window size to %d", int32(*GRPCInitialConnWindowSize))
		opts = append(opts, grpc.InitialConnWindowSize(int32(*GRPCInitialConnWindowSize)))
	}

	if *GRPCInitialWindowSize != 0 {
		log.Infof("Setting grpc server initial window size to %d", int32(*GRPCInitialWindowSize))
		opts = append(opts, grpc.InitialWindowSize(int32(*GRPCInitialWindowSize)))
	}

	ep := keepalive.EnforcementPolicy{
		MinTime:             *GRPCKeepAliveEnforcementPolicyMinTime,
		PermitWithoutStream: *GRPCKeepAliveEnforcementPolicyPermitWithoutStream,
	}
	opts = append(opts, grpc.KeepaliveEnforcementPolicy(ep))

	if GRPCMaxConnectionAge != nil {
		ka := keepalive.ServerParameters{
			MaxConnectionAge: *GRPCMaxConnectionAge,
		}
		if GRPCMaxConnectionAgeGrace != nil {
			ka.MaxConnectionAgeGrace = *GRPCMaxConnectionAgeGrace
		}
		opts = append(opts, grpc.KeepaliveParams(ka))
	}

	opts = append(opts, interceptors()...)

	GRPCServer = grpc.NewServer(opts...)
}
620114
public FacilityMessage createFAC(int cic) {
        FacilityMessage msg = createFAC();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
18414
public CircuitGroupUnblockingMessage createCGU(int cic) {
        CircuitGroupUnblockingMessage msg = createCGU();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
1330182
public OverloadMessage createOLM(int cic) {
        OverloadMessage msg = createOLM();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
256929
public UserPartTestMessage createUPT(int cic) {
        UserPartTestMessage msg = createUPT();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
790374
@Override
    public PreReleaseInformationMessage createPRI() {
        PreReleaseInformationMessage msg = new PreReleaseInformationMessageImpl(_PRI_HOLDER.mandatoryCodes, _PRI_HOLDER.mandatoryVariableCodes,
                _PRI_HOLDER.optionalCodes, _PRI_HOLDER.mandatoryCodeToIndex, _PRI_HOLDER.mandatoryVariableCodeToIndex,
                _PRI_HOLDER.optionalCodeToIndex);
        return msg;
    }
922472
@Override
    public BlockingAckMessage createBLA(int cic) {
        BlockingAckMessage msg = createBLA();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
75297
public ResumeMessage createRES(int cic) {
        ResumeMessage msg = createRES();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
806485
@Override
    public TextMessage createTextMessage() throws JMSRuntimeException {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "createTextMessage");

        TextMessage textMessage = null;

        try {
            textMessage = jmsSession.createTextMessage();
        } catch (JMSException jmse) {
            throw (JMSRuntimeException) JmsErrorUtils.getJMS2Exception(jmse, JMSRuntimeException.class);
        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "createTextMessage", new Object[] { textMessage });
        }

        return textMessage;

    }
136971
@Override
    public IdentificationRequestMessage createIDR() {
        IdentificationRequestMessage msg = new IdentificationRequestMessageImpl(_IDR_HOLDER.mandatoryCodes,
                _IDR_HOLDER.mandatoryVariableCodes, _IDR_HOLDER.optionalCodes, _IDR_HOLDER.mandatoryCodeToIndex,
                _IDR_HOLDER.mandatoryVariableCodeToIndex, _IDR_HOLDER.optionalCodeToIndex);
        return msg;
    }
79148
@Override
    public LoopbackAckMessage createLPA(int cic) {
        LoopbackAckMessage msg = createLPA();
        CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
        code.setCIC(cic);
        msg.setCircuitIdentificationCode(code);
        return msg;
    }
1093089
public JsJmsBytesMessage createJmsBytesMessage() throws MessageCreateFailedException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createJmsBytesMessage");
    JsJmsBytesMessage msg = null;
    try {
      msg = new JsJmsBytesMessageImpl(MfpConstants.CONSTRUCTOR_NO_OP);
    }
    catch (MessageDecodeFailedException e) {
      /* No need to FFDC this as JsMsgObject will already have done so */
      // No FFDC code needed
      throw new MessageCreateFailedException(e);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createJmsBytesMessage");
    return msg;
  }
695331
public CircuitGroupQueryResponseMessage createCQR() {
        CircuitGroupQueryResponseMessage msg = new CircuitGroupQueryResponseMessageImpl(_CQR_HOLDER.mandatoryCodes,
                _CQR_HOLDER.mandatoryVariableCodes, _CQR_HOLDER.optionalCodes, _CQR_HOLDER.mandatoryCodeToIndex,
                _CQR_HOLDER.mandatoryVariableCodeToIndex, _CQR_HOLDER.optionalCodeToIndex);

        return msg;
    }
729768
public JsJmsMapMessage createJmsMapMessage() throws MessageCreateFailedException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createJmsMapMessage");
    JsJmsMapMessage msg = null;
    try {
      msg = new JsJmsMapMessageImpl(MfpConstants.CONSTRUCTOR_NO_OP);
    }
    catch (MessageDecodeFailedException e) {
      /* No need to FFDC this as JsMsgObject will already have done so */
      // No FFDC code needed
      throw new MessageCreateFailedException(e);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createJmsMapMessage");
    return msg;
  }