código de estrutura C

A seguir está um código de estrutura para um nó definido pelo usuário C. Ele possui o conteúdo mínimo requerido para compilar um nó definido pelo usuário com êxito.
#ifdef __WIN32__
#include <windows.h>
#endif
#include <BipCos.h>
#include <BipCci.h>
#include <BipCni.h>
#include <cstring>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>
#define BIP_DEF_COMP_CCSID 437
CciChar* constNodeFactory = 0;
CciChar* constNodeName = 0;
CciChar* constTerminalName = 0;
CciChar* constOutTerminalName = 0;
CciChar* CciString(
const char* source,
int codepage
){
/* Número máximo de caracteres na representação Unicode */
int maxChars = strlen(source) + 1 ;
CciChar* buffer = (CciChar*)malloc(maxChars * sizeof(CciChar)) ;
int rc ;
cciMbsToUcs(&rc, source, buffer, maxChars, codepage) ;
return buffer ;
}
void initNodeConstants(){
constNodeFactory = CciString("myNodeFactory", BIP_DEF_COMP_CCSID);
constNodeName = CciString("myNode",BIP_DEF_COMP_CCSID);
constTerminalName = CciString("in",BIP_DEF_COMP_CCSID);
constOutTerminalName = CciString("out",BIP_DEF_COMP_CCSID);
}
struct MyNodeContext {
CciTerminal* iOutTerminal;
};
CciContext* createNodeContext(
CciFactory* factoryObject,
CciChar* nodeName,
CciNode* nodeObject
){
MyNodeContext * p = (MyNodeContext *)malloc(sizeof(MyNodeContext));
/*aqui seria criada uma instância de alguma estrutura de dados
em que poderia ser armazenado um contexto sobre esta instância do nó.
Seria retornado um ponteiro para esta estrutura e esse ponteiro
seria transmitido para as outras funções de implementação */
/* agora foi criado um terminal de entrada para o nó*/
cniCreateInputTerminal(NULL, nodeObject, (CciChar*)constTerminalName);
p->iOutTerminal = cniCreateOutputTerminal(NULL, nodeObject, (CciChar*)constOutTerminalName);
return((CciContext*)p);
}
/****************************************************************/
/* */
/* Função de Implementação do Nó de Plugin:           cniEvaluate() */
/* */
/****************************************************************/
void evaluate(
CciContext* context,
CciMessage* destinationList,
CciMessage* exceptionList,
CciMessage* message
){
/* a lógica de processamento do nó seria colocada aqui*/
return;
}
int run(
CciContext* context,
CciMessage* destinationList,
CciMessage* exceptionList,
CciMessage* message
)
{
char* buffer="<doc><test>hello</test></doc>";
CciChar* wBuffer=CciString(buffer,BIP_DEF_COMP_CCSID);
//cniSetInputBuffer(NULL,message,(void*)wBuffer,strlen(buffer) * sizeof(CciChar));
cniSetInputBuffer(NULL,message,(void*)buffer,strlen(buffer));
cniFinalize(NULL,message,0);
cniPropagate(NULL,((MyNodeContext*)context)->iOutTerminal,destinationList,exceptionList,message);
return CCI_SUCCESS_CONTINUE;
}
#ifdef __cplusplus
extern "C"{
#endif
CciFactory LilFactoryExportPrefix * LilFactoryExportSuffix bipGetMessageflowNodeFactory()
{
CciFactory* factoryObject;
  /* Antes de prosseguir é preciso inicializar todas as constantes estáticas */
/* que podem ser utilizadas pelo plug-in. */
initNodeConstants();
/* Crie o Depósito de Informações do Provedor do Nó para este plug-in */
/* Se ocorrem erros/exceções    */
/* durante a execução desta função de utilitário, como não seria fornecido o argumento */
/* returnCode, a exceção ignorará o plugin   */
/* e será diretamente manipulada pelo intermediário. */
factoryObject = cniCreateNodeFactory(0, (unsigned short *)constNodeFactory);
if (factoryObject == CCI_NULL_ADDR) {
			/* Qualquer tratamento de erro local adicional pode ir aqui */
}
else {
/* Defina o nó suportado por este depósito de informações do provedor */
	static CNI_VFT vftable = {CNI_VFT_DEFAULT};
/* Configurar tabela de funções com ponteiros para funções de
implementação do nó */
vftable.iFpCreateNodeContext = createNodeContext;
vftable.iFpEvaluate          = evaluate;
vftable.iFpRun               = run;
/* Defina um tipo de nó suportado por nosso depósito de informações do provedor. Se ocorrerem erros/exceções */
/* durante a execução desta função de utilitário, como não seria fornecido o argumento */
/* returnCode, a exceção ignorará o plugin   */
/* e será diretamente manipulada pelo intermediário. */
cniDefineNodeClass(NULL, factoryObject, (CciChar*)constNodeName, &vftable);
}
/* Retornar o endereço deste objeto de fábrica para o intermediário */
return(factoryObject);
}
#ifdef __cplusplus
}
#endif

Arquivo Pronto GNU

A seguir está um arquivo pronto que lista os arquivos, dependências e regras pelos quais o nó definido pelo usuário C deve ser compilado.

.SUFFIXES : .so .a .o .c
R1INC = .
R1LIB = .
# WMQI
MQSIDIR = /cmvc/back/inst.images/x86_linux_2/shipdata/opt/mqsi
MQSIINC		= $(MQSIDIR)/include
MQSILIB		= $(MQSIDIR)/lib
# WMQ
MQIDIR = /usr/mqm
CC = /usr/bin/g++
LD = ${CC}
OBJ = .o
LIL = .lil
THINGSTOCLEAN = *${OBJ}
CFLAGS		= -fpic -c #-pedantic -x c -Wall
CFLAGSADD	= -I${R1INC} -I${MQSIINC} -I${MQSIINC}/plugin ${DEFINES}
DEFINES = -DLINUX
LIBADD		= -L${MQSILIB} -limbdfplg
LDFLAG = -shared ${LIBADD}
#CC = /usr/bin/gcc
#LD = ${CC}
OBJECTS = skeleton${OBJ}
.c.o : ; ${CC} ${CFLAGS} ${CFLAGSADD} $<
ALL : ${OBJECTS} Samples${LIL}
clean:
rm *${OBJ} *${LIL}
skeleton${OBJ}:	skeleton.c
Samples${LIL}: ${OBJECTS}
${LD} -o $@ ${OBJECTS} ${LDFLAG}
Tarefas relacionadas
Criando uma Extensão Definida pelo Usuário em C
Referências relacionadas
API do Analisador Definido pelo Usuário de Linguagem C
API do Nó Definido pelo Usuário de Linguagem C
Funções de Implementação Comum C
Funções de Utilitários Comuns C
Notices | Trademarks | Downloads | Library | Support | Feedback
Copyright IBM Corporation 1999, 2006 Last updated: 5월 25, 2006
as24982_