Skeleton code C

Inizio modificaDi seguito è riportato uno skeleton code per un nodo definito dall'utente in C. Dispone del contenuto minimo richiesto per compilare con esito positivo un nodo definito dall'utente.
#ifdef __WIN32
#include <windows.h>
#endif
#include <BipCos.h>
#include <BipCci.h>
#include <BipCni.h>
#include <malloc.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
){
  /* Numero massimo di caratteri nella rappresentazione 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);  
}

typedef struct {
  CciTerminal* iOutTerminal;
}MyNodeContext;

CciContext* createNodeContext(
  CciFactory*  factoryObject,
  CciChar*     nodeName,
  CciNode*    nodeObject
){
  
  MyNodeContext * p = (MyNodeContext *)malloc(sizeof(MyNodeContext));
  
  /*viene qui creata un'istanza di una struttura di dati
  in cui memorizzare il contesto per questa istanza di nodo. 
  Viene restituito un puntatore a questo struct e tale puntatore 
  verrà passato alle altre funzioni di implementazione */

  /* viene creato un terminale di input per il nodo*/
  cniCreateInputTerminal(NULL, nodeObject, (CciChar*)constTerminalName);
  p->iOutTerminal = cniCreateOutputTerminal(NULL, nodeObject, (CciChar*)constOutTerminalName);
  return((CciContext*)p);
}

/****************************************************************/
/*                                                              */
/* Funzione di implementazione nodo plugin:       cniEvaluate() */
/*                                                              */
/****************************************************************/
void evaluate(
  CciContext*  context,
  CciMessage*   destinationList,
  CciMessage*  exceptionList,
  CciMessage* message
){
  /* ubicazione della logica dell'elaborazione del nodo*/
  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;
  
  /* Prima di procedere è necessario inizializzare tutte le costanti statiche */
  /* che il plug-in potrebbe utilizzare.                                 */
  initNodeConstants();

  /* Crea il produttore di nodi per questo plug-in */
  /* Se si verificano errori/eccezioni    */
  /* durante l'esecuzione di questa funzione di utilità, poiché non è stato   */
  /* fornito l'argomento returnCode, l'eccezione ignorerà il plugin           */
  /* e sarà gestita direttamente dal broker.                                   */
  factoryObject = cniCreateNodeFactory(0, (unsigned short *)constNodeFactory);
  if (factoryObject == CCI_NULL_ADDR) {
    /* L'eventuale gestione errori locale può essere inserita qui */
  }
  else {
    /* Definisce il nodo previsto da questo produttore */
    		static CNI_VFT vftable = {CNI_VFT_DEFAULT};
    	/* Imposta tabella funzioni con puntatori sulle funzioni di implementazione del nodo */
    vftable.iFpCreateNodeContext = createNodeContext;
    vftable.iFpEvaluate          = evaluate;
    vftable.iFpRun               = run;

    /* Definisce un tipo di nodo previsto dal produttore. In caso di errori/eccezioni */
    /* durante l'esecuzione di questa funzione di utilità, poiché non è stato   */
    /* fornito l'argomento returnCode, l'eccezione ignorerà il plugin           */
    /* e sarà gestita direttamente dal broker.                                   */
    cniDefineNodeClass(NULL, factoryObject, (CciChar*)constNodeName, &vftable);
    
  }

  /* Restituisce l'indirizzo di questo oggetto produttore al broker */
  return(factoryObject);
}
#ifdef __cplusplus
}
#endif
Fine modifica

Makefile GNU

Di seguito è riportato un makefile che contiene l'elenco di file, dipendenze e regole mediante cui il nodo definito dall'utente in C deve essere compilato.

.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}
Attività correlate
Creazione di un'estensione definita dall'utente in C
Riferimenti correlati
API del programma di analisi definito dall'utente in linguaggio C
API del nodo definito dall'utente in linguaggio C
Funzioni di implementazione comuni C
Funzioni di utilità comune di C
Informazioni particolari | Marchi | Download | Libreria | Supporto | Commenti
Copyright IBM Corporation 1999, 2006 Ultimo aggiornamento: ago 17, 2006
as24982_