Criando um Nó de Processamento de Mensagem ou de Saída em C

CciFactory LilFactoryExportPrefix * LilFactoryExportSuffix
bipGetMessageflowNodeFactory()

{
	CciFactory* factoryObject;
	int rc = 0;
	CciChar factoryName[] = L"MyNodeFactory";
	CCI_EXCEPTION_ST exception_st;

	/* Create the Node Factory for this node */
	factoryObject = cniCreateNodeFactory(0, factoryName);
	if (factoryObject == CCI_NULL_ADDR) {
		/* Any local error handling can go here */
	}
	else {
		/* Define the nodes supported by this factory */
	static CNI_VFT vftable = {CNI_VFT_DEFAULT};

	/* Setup function table with pointers to node implementation functions */
	vftable.iFpCreateNodeContext = _createNodeContext;
	vftable.iFpDeleteNodeContext = _deleteNodeContext;
	vftable.iFpGetAttributeName2 = _getAttributeName2;
	vftable.iFpSetAttribute      = _setAttribute;
	vftable.iFpGetAttribute2     = _getAttribute2;
	vftable.iFpEvaluate          = _evaluate;

	cniDefineNodeClass(0, factoryObject, L"MessageProcessingxNode", &vftable);

	}

	/* Return address of this factory object to the integration node */
	return(factoryObject);
}

Um nó definido pelo usuário se identifica como um nó de processamento de mensagem ou de saída implementando a função cniEvaluate. Os nós definidos pelo usuário devem implementar uma função de implementação cniEvaluate ou cniRun, caso contrário, o nó de integração não carrega o nó definido pelo usuário e a função de utilitário cniDefineNodeClass falha, retornando CCI_MISSING_IMPL_FUNCTION.

Quando um fluxo de mensagens que contém um nó de processamento de mensagens definido pelo usuário é implementado com êxito, a função cniEvaluate do nó é chamada para cada mensagem propagada para o nó.

Os dados do fluxo de mensagens são recebidos no terminal de entrada do nó, ou seja, a mensagem, Environment, LocalEnvironment e ExceptionList.

void cniEvaluate(                
  CciContext* context,                
  CciMessage* localEnvironment,        
  CciMessage* exceptionList,          
  CciMessage* message                 
){                                    
  ...
}

    {
      const CciChar* ucsIn = CciString("in", BIP_DEF_COMP_CCSID) ;
      insInputTerminalListEntry(p, (CciChar*)ucsIn);
      free((void *)ucsIn) ;
    }
    {
      const CciChar* ucsOut = CciString("out", BIP_DEF_COMP_CCSID) ;
      insOutputTerminalListEntry(p, (CciChar*)ucsOut);
      free((void *)ucsOut) ;
    }
    {
      const CciChar* ucsFailure = CciString("failure", BIP_DEF_COMP_CCSID) ;
      insOutputTerminalListEntry(p, (CciChar*)ucsFailure);
      free((void *)ucsFailure) ;
    }

O código anterior inicia as funções insInputTerminalListEntry e insOutputTerminalListEntry. É possível localizar essas funções no código de amostra Common.c; consulte Arquivos do nó de amostra Essas funções definem os terminais para o nó de integração e armazenam identificadores para os terminais. Os identificadores são armazenados na estrutura mencionada pelo valor retornado em CciContext*. Em seguida, o nó pode acessar os identificadores de terminal de dentro das outras funções de implementação (por exemplo, CciEvaluate), porque CciContext é transmitida para essas funções de implementação.

O código a seguir mostra a definição de insInputTerminalListEntry:

TERMINAL_LIST_ENTRY *insInputTerminalListEntry( 
  NODE_CONTEXT_ST* context, 
  CciChar*         terminalName 
){ 
  static char* functionName = (char *)"insInputTerminalListEntry()"; 
  TERMINAL_LIST_ENTRY* entry; 
  int                  rc; 
 
  entry = (TERMINAL_LIST_ENTRY *)malloc(sizeof(TERMINAL_LIST_ENTRY)); 
  if (entry) { 
 
    /* This entry is the current end of the list */ 
    entry->next = 0; 
 
    /* Store the terminal name */ 
    CciCharCpy(entry->name, terminalName); 
 
    /* Create terminal and save its handle */ 
    entry->handle = cniCreateInputTerminal(&rc, context->nodeObject, (CciChar*)terminalName); 
 
    /* Link an existing previous element to this one */ 
    if (context->inputTerminalListPrevious) context->inputTerminalListPrevious->next = entry; 
    else if ((context->inputTerminalListHead) == 0) context->inputTerminalListHead = entry; 
 
    /* Save the pointer to the previous element */ 
    context->inputTerminalListPrevious = entry; 
  } 
  else { 
    /* Error: Unable to allocate memory */ 
  } 
 
  return(entry); 
} 

O exemplo a seguir mostra o código para insOutputTerminalListEntry:

TERMINAL_LIST_ENTRY *insOutputTerminalListEntry( 
  NODE_CONTEXT_ST* context, 
  CciChar*         terminalName 
){ 
  static char* functionName = (char *)"insOutputTerminalListEntry()"; 
  TERMINAL_LIST_ENTRY* entry; 
  int                  rc; 
 
  entry = (TERMINAL_LIST_ENTRY *)malloc(sizeof(TERMINAL_LIST_ENTRY)); 
  if (entry) { 
 
    /* This entry is the current end of the list */ 
    entry->next = 0; 
 
    /* Store the terminal name */ 
    CciCharCpy(entry->name, terminalName); 
 
    /* Create terminal and save its handle */ 
    entry->handle = cniCreateOutputTerminal(&rc, context->nodeObject, (CciChar*)terminalName); 
 
    /* Link an existing previous element to this one */ 
    if (context->outputTerminalListPrevious) context->outputTerminalListPrevious->next = entry; 
    else if ((context->outputTerminalListHead) == 0) context->outputTerminalListHead = entry; 
 
    /* Save the pointer to the previous element */ 
    context->outputTerminalListPrevious = entry; 
  } 
  else { 
    /* Error: Unable to allocate memory */ 
  } 
 
  return(entry); 
}