inc_builddir=$(top_builddir)/include/salome
@SET_MAKE@
-SHELL=/bin/sh
+SHELL=@SHELL@
# header missing
LIBS=@LIBS@
LIBSFORBIN=@LIBS@
-LDFLAGS=@LDFLAGS@ -L$(top_builddir)/lib/salome -Xlinker -rpath-link -Xlinker $(top_builddir)/lib/salome
-LDFLAGSFORBIN=@LDFLAGS@ -L$(top_builddir)/lib/salome -Xlinker -rpath-link -Xlinker $(KERNEL_ROOT_DIR)/lib/salome
+LDFLAGS=@LDFLAGS@ -L$(top_builddir)/lib/salome
+LDFLAGSFORBIN=@LDFLAGS@ -L$(top_builddir)/lib/salome
# add libstdc++ to link c++ library with libtool !
-LDFLAGS+= -lstdc++
-LDFLAGSFORBIN+= -lstdc++
+LDFLAGS+= @STDLIB@
+LDFLAGSFORBIN+= @STDLIB@
CP=@CP@
ln -sf $(patsubst %.la, %.so, $(CURDIR)/.libs/$<).0 \
$(patsubst %.la, %.so, $@).0 || true
- if ! test -z $(LIB_SWIG) ; then \
+ if test "X$(LIB_SWIG)" != "X"; then \
ln -sf $(patsubst %.la,%.so, $(CURDIR)/.libs/$<) $(top_builddir)/lib/salome/_$(LIB_SWIG) || true;\
fi;
($(LT_INSTALL_LIB) $$f $(libdir)/. || exit 1); \
fi; \
done
- @if ! test -z $(LIB_SWIG) ; then \
+ @if test "X$(LIB_SWIG)" != "X"; then \
(cd $(libdir); ln -sf $(patsubst %.so, %cmodule.so, $(LIB_SWIG)) _$(LIB_SWIG) || true); \
fi;
@for f in X $(BIN); do \
-#!/bin/bash
+#!/bin/sh
#
# Tool for updating list of .in file for the SALOME project
find_in()
{
- local i
- local f=$2
+ i=0
+ f=$2
# if the first argument is not a directory, returns
# Common part of the configure.in file
#
chmod u+w configure.in.base
-if ! \cp -f configure.in.base configure.in_tmp1
+if \cp -f configure.in.base configure.in_tmp1
then
+ echo
+else
echo
echo "error : can't create files in" ${CONF_DIR}
echo "aborting ..."
fi
else
echo -n "Updating 'configure.in' file ... "
- if ! \cp configure.in configure.in_old >& /dev/null
+ if \cp configure.in configure.in_old >& /dev/null
then
+ echo
+ else
echo
echo
echo "Can't backup previous configure.in"
echo
echo
+AC_CHECK_PROG(SHELL,sh)
+AC_SUBST(SHELL)
+
if test -z "$AR"; then
AC_CHECK_PROGS(AR,ar xar,:,$PATH)
fi
dnl full-path to the binary instead.
case "$INSTALL" in
*install-sh*)
- INSTALL='\${KERNEL_ROOT_DIR}'/salome_adm/unix/config_files/install-sh
+ INSTALL="${KERNEL_ROOT_DIR}/salome_adm/unix/config_files/install-sh -c"
;;
esac
dnl inutil car libtool
dnl AC_PROG_CC
AC_PROG_CXX
+AC_CXX_WARNINGS
+AC_CXX_TEMPLATE_OPTIONS
AC_DEPEND_FLAG
# AC_CC_WARNINGS([ansi])
cc_ok=yes
dnl Library libdl :
AC_CHECK_LIB(dl,dlopen)
+dnl Library librt : for alpha/osf
+AC_CHECK_LIB(rt,nanosleep)
+
dnl add library libm :
AC_CHECK_LIB(m,ceil)
-dnl
-dnl Well we use sstream which is not in gcc pre-2.95.3
-dnl We must test if it exists. If not, add it in include !
+AC_CXX_USE_STD_IOSTREAM
+AC_CXX_HAVE_SSTREAM
+
+dnl
+dnl ---------------------------------------------
+dnl testing linker
+dnl ---------------------------------------------
dnl
-AC_CXX_HAVE_SSTREAM
+AC_LINKER_OPTIONS
+
+AC_LINKER_OPTIONS
+
+echo
+echo ---------------------------------------------
+echo testing threads
+echo ---------------------------------------------
+echo
+
+ENABLE_PTHREADS
+
+dnl
+dnl ---------------------------------------------
+dnl testing WITHIHM
+dnl ---------------------------------------------
+dnl
+
+CHECK_WITHIHM
dnl
dnl ---------------------------------------------
-dnl testing MPICH
+dnl testing MPI
dnl ---------------------------------------------
dnl
-CHECK_MPICH
+CHECK_MPI
+
+dnl
+dnl ---------------------------------------------
+dnl testing sockets
+dnl ---------------------------------------------
+dnl
+
+CHECK_SOCKETS
+
+dnl
+dnl ---------------------------------------------
+dnl testing OpenPBS
+dnl ---------------------------------------------
+dnl
+
+echo
+echo ---------------------------------------------
+echo testing OpenPBS
+echo ---------------------------------------------
+echo
+
+openpbs_ok=no
+CHECK_OPENPBS
+dnl openpbs_ok is set to yes by CHECK_OPENPBS
+
+dnl
+dnl ---------------------------------------------
+dnl testing LSF
+dnl ---------------------------------------------
+dnl
+
+echo
+echo ---------------------------------------------
+echo testing LSF
+echo ---------------------------------------------
+echo
+
+lsf_ok=no
+CHECK_LSF
+dnl lsf_ok is set to yes by CHECK_LSF
+
+dnl
+dnl ---------------------------------------------
+dnl testing Batch
+dnl ---------------------------------------------
+dnl
+
+WITH_BATCH=no
+test x$openpbs_ok = xyes || test x$lsf_ok = xyes && WITH_BATCH=yes
+AC_SUBST(WITH_BATCH)
echo
echo ---------------------------------------------
CHECK_SWIG
-echo
-echo ---------------------------------------------
-echo testing threads
-echo ---------------------------------------------
-echo
-
-ENABLE_PTHREADS
-
echo
echo ---------------------------------------------
echo testing omniORB
corba=make_$ORB
CORBA=adm_local/unix/$corba
-echo
-echo ---------------------------------------------
-echo testing openGL
-echo ---------------------------------------------
-echo
-
-CHECK_OPENGL
-
echo
echo ---------------------------------------------
echo testing QT
CHECK_QT
-echo
-echo ---------------------------------------------
-echo testing VTK
-echo ---------------------------------------------
-echo
+if test "X$WITHIHM" = "Xyes"; then
+ echo
+ echo ---------------------------------------------
+ echo Testing sip
+ echo ---------------------------------------------
+ echo
+
+ CHECK_SIP
+
+ echo
+ echo ---------------------------------------------
+ echo testing openGL
+ echo ---------------------------------------------
+ echo
+
+ CHECK_OPENGL
+
+ echo
+ echo ---------------------------------------------
+ echo testing VTK
+ echo ---------------------------------------------
+ echo
+
+ CHECK_VTK
+
+ echo
+ echo ---------------------------------------------
+ echo Testing pyqt
+ echo ---------------------------------------------
+ echo
-CHECK_VTK
+ CHECK_PYQT
+
+ echo
+ echo ---------------------------------------------
+ echo Testing qwt
+ echo ---------------------------------------------
+ echo
+
+ CHECK_QWT
+fi
echo
echo ---------------------------------------------
CHECK_HDF5
-#echo
+echo
echo ---------------------------------------------
echo testing MED
echo ---------------------------------------------
CHECK_MED
+echo
echo ---------------------------------------------
echo testing MED2
echo ---------------------------------------------
echo
echo Configure
-variables="cc_ok lex_yacc_ok python_ok swig_ok threads_ok OpenGL_ok qt_ok vtk_ok hdf5_ok med2_ok omniORB_ok occ_ok doxygen_ok graphviz_ok Kernel_ok"
+if test "X$WITHIHM" = "Xyes"; then
+variables="cc_ok lex_yacc_ok mpi_ok python_ok swig_ok threads_ok OpenGL_ok qt_ok vtk_ok hdf5_ok med2_ok omniORB_ok occ_ok sip_ok pyqt_ok qwt_ok"
+fi
+if test "X$WITHIHM" = "Xno"; then
+variables="cc_ok mpi_ok python_ok swig_ok threads_ok OpenGL_ok qt_ok hdf5_ok med2_ok omniORB_ok occ_ok "
+fi
for var in $variables
do
eval echo \$$var
done
+echo "---Optional:"
+variables="cppunit_ok openpbs_ok lsf_ok doxygen_ok graphviz_ok"
+
+for var in $variables
+do
+ eval toto=\$$var
+ if test x$toto != "x"; then
+ printf " %10s : " `echo \$var | sed -e "s,_ok,,"`
+ eval echo \$$var
+ fi
+done
+
echo
echo "Default ORB : $DEFAULT_ORB"
echo
mkdir -p bin/salome
cd bin/salome
-for i in $ROOT_SRCDIR/bin/*
+for i in `find $ROOT_SRCDIR/bin`
do
- local_bin=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
+ local_bin=`echo $i | sed -e "s,$ROOT_SRCDIR/bin,.,"`
case "$local_bin" in
*.in | *~) ;;
- ./bin/CVS | ./bin/salome) ;;
- *) /usr/bin/install -c $i .; echo $local_bin ;;
+ . | */CVS | */CVS/* | ./salome) ;;
+ *) $INSTALL $i $local_bin; echo $local_bin ;;
esac
done
cd $ROOT_BUILDDIR
echo
AC_OUTPUT_COMMANDS([ \
- chmod +x ./bin/* \
+ chmod +x ./bin/*; \
+ chmod +x ./bin/salome/* \
])
## do not delete this line
-// SALOME Container : implementation of container and engine for Kernel
+// SuperVisionTest AddComponent : example of component that adds two numbers
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
//
//
-// File : SALOME_Container.cxx
-// Author : Paul RASCLE, EDF - MARC TAJCHMAN, CEA
-// Module : SALOME
+// File : AddComponent_CheckOfUndefined.cxx
+// Author : Jean Rahuel
+// Module : SuperVisionTest
// $Header$
#include <iostream>
+#include <strstream>
#include <string>
#include <stdio.h>
#include <mpi.h>
#endif
+//CCRT
+#include <sstream>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+//end-CCRT
+
#include "Container_init_python.hxx"
using namespace std;
// add new container to the kill list
#ifndef WNT
- char aCommand[40];
- sprintf(aCommand, "addToKillList.py %d SALOME_Container", getpid());
- system(aCommand);
+ ostrstream aCommand ;
+ aCommand << "addToKillList.py " << getpid() << " SALOME_Container" << ends ;
+ system(aCommand.str());
#endif
Engines_Container_i * myContainer
// Author : Jean Rahuel, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
#include "AddComponent_Impl.hxx"
#include "Adder_Impl.hxx"
+using namespace std;
+
AddComponent_Impl::AddComponent_Impl( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
AddComponent_Impl::~AddComponent_Impl() {
}
-double AddComponent_Impl::Add( double x , double y , double & z ) {
+CORBA::Double AddComponent_Impl::Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " AddComponent_Impl::Add" );
z = x + y ;
int S;
return (x - y) ;
}
-double AddComponent_Impl::AddWithoutSleep( double x , double y , double & z ) {
+CORBA::Double AddComponent_Impl::AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " AddComponent_Impl::AddWithoutSleep" );
z = x + y ;
LastAddition = z ;
return (x - y) ;
}
-long AddComponent_Impl::Sigma( long n ) {
+CORBA::Long AddComponent_Impl::Sigma( CORBA::Long n ) {
long sigma = 0 ;
int i , j ;
beginService( " AddComponent_Impl::Sigma" );
return sigma ;
}
-void AddComponent_Impl::Setx( double x ) {
+void AddComponent_Impl::Setx( CORBA::Double x ) {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
xx = x ;
}
-void AddComponent_Impl::Sety( double y ) {
+void AddComponent_Impl::Sety( CORBA::Double y ) {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
yy = y ;
}
-double AddComponent_Impl::Addxy() {
+CORBA::Double AddComponent_Impl::Addxy() {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
return zz;
}
-double AddComponent_Impl::AddyTox( double y ) {
+CORBA::Double AddComponent_Impl::AddyTox( CORBA::Double y ) {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
return zz;
}
-double AddComponent_Impl::LastResult() {
+CORBA::Double AddComponent_Impl::LastResult() {
beginService( " AddComponent_Impl::LastResult" );
sendMessage(NOTIF_STEP, "AddComponent_Impl::LastResult is Computing");
endService( " AddComponent_Impl::LastResult" );
// return SuperVisionTest::Adder::_duplicate(iobject) ;
}
-bool AddComponent_Impl::AdditionObjRef1( SuperVisionTest::Adder_out aAdder ) {
+CORBA::Boolean AddComponent_Impl::AdditionObjRef1( SuperVisionTest::Adder_out aAdder ) {
beginService( "AddComponent_Impl::Addition" );
sendMessage(NOTIF_STEP, "AddComponent_Impl creates Adder_Impl");
Adder_Impl * myAdder ;
return true ;
}
-void AddComponent_Impl::AdditionObjRef2( bool & FuncValue ,
+void AddComponent_Impl::AdditionObjRef2( CORBA::Boolean & FuncValue ,
SuperVisionTest::Adder_out aAdder ) {
beginService( "AddComponent_Impl::Addition" );
sendMessage(NOTIF_STEP, "AddComponent_Impl creates Adder_Impl");
FuncValue = true ;
}
-bool AddComponent_Impl::AdditionObjRefs( const SuperVisionTest::AddComponent_ptr AddComponent1 ,
- const SuperVisionTest::AddComponent_ptr Adder2 ,
- const SuperVisionTest::AddComponent_ptr Adder3 ,
- SuperVisionTest::AddComponent_out RetAddComponent1 ,
- SuperVisionTest::AddComponent_out RetAdder2 ,
- SuperVisionTest::AddComponent_out RetAdder3 ) {
+CORBA::Boolean AddComponent_Impl::AdditionObjRefs( SuperVisionTest::AddComponent_ptr AddComponent1 ,
+ SuperVisionTest::AddComponent_ptr Adder2 ,
+ SuperVisionTest::AddComponent_ptr Adder3 ,
+ SuperVisionTest::AddComponent_out RetAddComponent1 ,
+ SuperVisionTest::AddComponent_out RetAdder2 ,
+ SuperVisionTest::AddComponent_out RetAdder3 ) {
bool RetVal = true ;
beginService( "AddComponent_Impl::AdditionObjRefs" );
cout << "beginService AddComponent_Impl::AdditionObjRefs" << endl ;
virtual ~AddComponent_Impl();
- virtual double Add( double x , double y , double & z ) ;
- virtual double AddWithoutSleep( double x , double y , double & z ) ;
+ virtual CORBA::Double Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
+ virtual CORBA::Double AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
- virtual void Setx( double x ) ;
- virtual void Sety( double y ) ;
- virtual double Addxy() ;
- virtual double AddyTox( double y ) ;
+ virtual void Setx( CORBA::Double x ) ;
+ virtual void Sety( CORBA::Double y ) ;
+ virtual CORBA::Double Addxy() ;
+ virtual CORBA::Double AddyTox( CORBA::Double y ) ;
- virtual long Sigma( long n ) ;
+ virtual CORBA::Long Sigma( CORBA::Long n ) ;
- virtual double LastResult() ;
+ virtual CORBA::Double LastResult() ;
virtual SuperVisionTest::Adder_ptr Addition() ;
- virtual bool AdditionObjRef1( SuperVisionTest::Adder_out ) ;
+ virtual CORBA::Boolean AdditionObjRef1( SuperVisionTest::Adder_out ) ;
- virtual void AdditionObjRef2( bool & FuncValue , SuperVisionTest::Adder_out ) ;
+ virtual void AdditionObjRef2( CORBA::Boolean & FuncValue , SuperVisionTest::Adder_out ) ;
- virtual bool AdditionObjRefs( const SuperVisionTest::AddComponent_ptr AddComponent1 ,
- const SuperVisionTest::AddComponent_ptr Adder2 ,
- const SuperVisionTest::AddComponent_ptr Adder3 ,
- SuperVisionTest::AddComponent_out RetAddComponent1 ,
- SuperVisionTest::AddComponent_out RetAdder2 ,
- SuperVisionTest::AddComponent_out RetAdder3 ) ;
+ virtual CORBA::Boolean AdditionObjRefs( SuperVisionTest::AddComponent_ptr AddComponent1 ,
+ SuperVisionTest::AddComponent_ptr Adder2 ,
+ SuperVisionTest::AddComponent_ptr Adder3 ,
+ SuperVisionTest::AddComponent_out RetAddComponent1 ,
+ SuperVisionTest::AddComponent_out RetAdder2 ,
+ SuperVisionTest::AddComponent_out RetAdder3 ) ;
private:
// Author : Jean Rahuel, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
#include "Adder_Impl.hxx"
+using namespace std;
+
Adder_Impl::Adder_Impl( CORBA::ORB_ptr orb ,
PortableServer::POA_ptr poa ,
PortableServer::ObjectId * contId ,
_thisObj->_remove_ref();
}
-double Adder_Impl::Add( double x , double y , double & z ) {
+CORBA::Double Adder_Impl::Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " Adder_Impl::Add" );
z = x + y ;
int S;
return -(x - y) ;
}
-double Adder_Impl::AddWithoutSleep( double x , double y , double & z ) {
+CORBA::Double Adder_Impl::AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " Adder_Impl::AddWithoutSleep" );
z = x + y ;
endService( " Adder_Impl::AddWithoutSleep" );
return -(x - y) ;
}
-double Adder_Impl::AddAndCompare( const double x , const double y ,
- const SuperVisionTest::Adder_ptr anOtherAdder ,
- double & z ) {
+CORBA::Double Adder_Impl::AddAndCompare( CORBA::Double x , CORBA::Double y ,
+ SuperVisionTest::Adder_ptr anOtherAdder ,
+ CORBA::Double & z ) {
beginService( " Adder_Impl::AddAndCompare" );
z = x + y ;
int S;
return ValFunc ;
}
-void Adder_Impl::SetLastResult( double z ) {
+void Adder_Impl::SetLastResult( CORBA::Double z ) {
beginService( " Adder_Impl::SetLastResult" );
sendMessage(NOTIF_STEP, "Adder_Impl::SetLastResult is Computing");
int S;
return ;
}
-void Adder_Impl::LastResult( double & z ) {
+void Adder_Impl::LastResult( CORBA::Double & z ) {
beginService( " Adder_Impl::LastResult" );
sendMessage(NOTIF_STEP, "Adder_Impl::LastResult is Computing");
int S;
virtual void destroy() ;
- virtual double Add( double x , double y , double & z ) ;
+ virtual CORBA::Double Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
- virtual double AddWithoutSleep( double x , double y , double & z ) ;
+ virtual CORBA::Double AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
- virtual double AddAndCompare( const double x , const double y ,
- const SuperVisionTest::Adder_ptr anOtherAdder ,
- double & z ) ;
+ virtual CORBA::Double AddAndCompare( CORBA::Double x , CORBA::Double y ,
+ SuperVisionTest::Adder_ptr anOtherAdder ,
+ CORBA::Double & z ) ;
- virtual void SetLastResult( double z ) ;
+ virtual void SetLastResult( CORBA::Double z ) ;
- virtual void LastResult( double & z ) ;
+ virtual void LastResult( CORBA::Double & z ) ;
virtual Engines::Component_ptr LccAddComponent( const char * aContainer ,
const char * aComponentName ) ;
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -g -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace -lSalomeNS -lSalomeLifeCycleCORBA
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace -lSalomeNS -lSalomeLifeCycleCORBA
+LIBSFORBIN= $(LIBS)
LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
// File : AddComponent_CheckOfUndefined.cxx
// Module : SuperVisionTest
-using namespace std;
#include <iostream>
#include <fstream>
#include <unistd.h>
#include "AdditionComponent_Impl.hxx"
+using namespace std;
+
int main(int argc, char **argv) {
return 0;
}
// Author : Jean Rahuel, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
#include "AdditionComponent_Impl.hxx"
#include "Adder_Impl.hxx"
+using namespace std;
+
AdditionInterface_Impl::AdditionInterface_Impl( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
AdditionInterface_Impl::~AdditionInterface_Impl() {
}
-double AdditionInterface_Impl::Add( double x , double y , double & z ) {
+CORBA::Double AdditionInterface_Impl::Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " AdditionInterface_Impl::Add" );
z = x + y ;
int S;
return (x - y) ;
}
-double AdditionInterface_Impl::AddWithoutSleep( double x , double y , double & z ) {
+CORBA::Double AdditionInterface_Impl::AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " AdditionInterface_Impl::AddWithoutSleep" );
z = x + y ;
LastAddition = z ;
return (x - y) ;
}
-long AdditionInterface_Impl::Sigma( long n ) {
+CORBA::Long AdditionInterface_Impl::Sigma( CORBA::Long n ) {
long sigma = 0 ;
int i , j ;
beginService( " AdditionInterface_Impl::Sigma" );
return sigma ;
}
-void AdditionInterface_Impl::Setx( double x ) {
+void AdditionInterface_Impl::Setx( CORBA::Double x ) {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
xx = x ;
}
-void AdditionInterface_Impl::Sety( double y ) {
+void AdditionInterface_Impl::Sety( CORBA::Double y ) {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
yy = y ;
}
-double AdditionInterface_Impl::Addxy() {
+CORBA::Double AdditionInterface_Impl::Addxy() {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
return zz;
}
-double AdditionInterface_Impl::AddyTox( double y ) {
+CORBA::Double AdditionInterface_Impl::AddyTox( CORBA::Double y ) {
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
while ( S ) {
S = sleep(S);
return zz;
}
-double AdditionInterface_Impl::LastResult() {
+CORBA::Double AdditionInterface_Impl::LastResult() {
beginService( " AdditionInterface_Impl::LastResult" );
sendMessage(NOTIF_STEP, "AdditionInterface_Impl::LastResult is Computing");
endService( " AdditionInterface_Impl::LastResult" );
return true ;
}
-void AdditionInterface_Impl::AdditionObjRef2( bool & FuncValue ,
- AdditionComponent::Adder_out aAdder ) {
+void AdditionInterface_Impl::AdditionObjRef2( CORBA::Boolean & FuncValue ,
+ AdditionComponent::Adder_out aAdder ) {
beginService( "AdditionInterface_Impl::Addition" );
sendMessage(NOTIF_STEP, "AdditionInterface_Impl creates Adder_Impl");
Adder_Impl * myAdder ;
FuncValue = true ;
}
-bool AdditionInterface_Impl::AdditionObjRefs( const AdditionComponent::AdditionInterface_ptr AdditionInterface1 ,
- const AdditionComponent::AdditionInterface_ptr Adder2 ,
- const AdditionComponent::AdditionInterface_ptr Adder3 ,
- AdditionComponent::AdditionInterface_out RetAdditionInterface1 ,
- AdditionComponent::AdditionInterface_out RetAdder2 ,
- AdditionComponent::AdditionInterface_out RetAdder3 ) {
+CORBA::Boolean AdditionInterface_Impl::AdditionObjRefs( AdditionComponent::AdditionInterface_ptr AdditionInterface1 ,
+ AdditionComponent::AdditionInterface_ptr Adder2 ,
+ AdditionComponent::AdditionInterface_ptr Adder3 ,
+ AdditionComponent::AdditionInterface_out RetAdditionInterface1 ,
+ AdditionComponent::AdditionInterface_out RetAdder2 ,
+ AdditionComponent::AdditionInterface_out RetAdder3 ) {
bool RetVal = true ;
beginService( "AdditionInterface_Impl::AdditionObjRefs" );
cout << "beginService AdditionInterface_Impl::AdditionObjRefs" << endl ;
virtual ~AdditionInterface_Impl();
- virtual double Add( double x , double y , double & z ) ;
- virtual double AddWithoutSleep( double x , double y , double & z ) ;
+ virtual CORBA::Double Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
+ virtual CORBA::Double AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
- virtual void Setx( double x ) ;
- virtual void Sety( double y ) ;
- virtual double Addxy() ;
- virtual double AddyTox( double y ) ;
+ virtual void Setx( CORBA::Double x ) ;
+ virtual void Sety( CORBA::Double y ) ;
+ virtual CORBA::Double Addxy() ;
+ virtual CORBA::Double AddyTox( CORBA::Double y ) ;
- virtual long Sigma( long n ) ;
+ virtual CORBA::Long Sigma( CORBA::Long n ) ;
- virtual double LastResult() ;
+ virtual CORBA::Double LastResult() ;
virtual AdditionComponent::Adder_ptr Addition() ;
virtual bool AdditionObjRef1( AdditionComponent::Adder_out ) ;
- virtual void AdditionObjRef2( bool & FuncValue , AdditionComponent::Adder_out ) ;
+ virtual void AdditionObjRef2( CORBA::Boolean & FuncValue , AdditionComponent::Adder_out ) ;
- virtual bool AdditionObjRefs( const AdditionComponent::AdditionInterface_ptr AdditionInterface1 ,
- const AdditionComponent::AdditionInterface_ptr Adder2 ,
- const AdditionComponent::AdditionInterface_ptr Adder3 ,
- AdditionComponent::AdditionInterface_out RetAdditionInterface1 ,
- AdditionComponent::AdditionInterface_out RetAdder2 ,
- AdditionComponent::AdditionInterface_out RetAdder3 ) ;
+ virtual CORBA::Boolean AdditionObjRefs( AdditionComponent::AdditionInterface_ptr AdditionInterface1 ,
+ AdditionComponent::AdditionInterface_ptr Adder2 ,
+ AdditionComponent::AdditionInterface_ptr Adder3 ,
+ AdditionComponent::AdditionInterface_out RetAdditionInterface1 ,
+ AdditionComponent::AdditionInterface_out RetAdder2 ,
+ AdditionComponent::AdditionInterface_out RetAdder3 ) ;
private:
// Author : Jean Rahuel, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
#include "Addition_Adder_Impl.hxx"
+using namespace std;
+
Adder_Impl::Adder_Impl( CORBA::ORB_ptr orb ,
PortableServer::POA_ptr poa ,
PortableServer::ObjectId * contId ,
_thisObj->_remove_ref();
}
-double Adder_Impl::Add( double x , double y , double & z ) {
+CORBA::Double Adder_Impl::Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " Adder_Impl::Add" );
z = x + y ;
int S;
return -(x - y) ;
}
-double Adder_Impl::AddWithoutSleep( double x , double y , double & z ) {
+CORBA::Double Adder_Impl::AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
beginService( " Adder_Impl::AddWithoutSleep" );
z = x + y ;
endService( " Adder_Impl::AddWithoutSleep" );
return -(x - y) ;
}
-double Adder_Impl::AddAndCompare( const double x , const double y ,
- const AdditionComponent::Adder_ptr anOtherAdder ,
- double & z ) {
+CORBA::Double Adder_Impl::AddAndCompare( CORBA::Double x , CORBA::Double y ,
+ AdditionComponent::Adder_ptr anOtherAdder ,
+ CORBA::Double & z ) {
beginService( " Adder_Impl::AddAndCompare" );
z = x + y ;
int S;
return ValFunc ;
}
-void Adder_Impl::SetLastResult( double z ) {
+void Adder_Impl::SetLastResult( CORBA::Double z ) {
beginService( " Adder_Impl::SetLastResult" );
sendMessage(NOTIF_STEP, "Adder_Impl::SetLastResult is Computing");
int S;
return ;
}
-void Adder_Impl::LastResult( double & z ) {
+void Adder_Impl::LastResult( CORBA::Double & z ) {
beginService( " Adder_Impl::LastResult" );
sendMessage(NOTIF_STEP, "Adder_Impl::LastResult is Computing");
int S;
return ;
}
-Engines::Component_ptr Adder_Impl::LccAdditionInterface( const char * aContainer ,
- const char * aComponentName ) {
+Engines::Component_ptr Adder_Impl::LccAdditionInterface( char * aContainer ,
+ char * aComponentName ) {
beginService( "Adder_Impl::LccAddComponent" );
Engines::Component_ptr objComponent ;
objComponent = Engines::Component::_nil() ;
virtual void destroy() ;
- virtual double Add( double x , double y , double & z ) ;
+ virtual CORBA::Double Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
- virtual double AddWithoutSleep( double x , double y , double & z ) ;
+ virtual CORBA::Double AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) ;
- virtual double AddAndCompare( const double x , const double y ,
- const AdditionComponent::Adder_ptr anOtherAdder ,
- double & z ) ;
+ virtual CORBA::Double AddAndCompare( CORBA::Double x , CORBA::Double y ,
+ AdditionComponent::Adder_ptr anOtherAdder ,
+ CORBA::Double & z ) ;
- virtual void SetLastResult( double z ) ;
+ virtual void SetLastResult( CORBA::Double z ) ;
- virtual void LastResult( double & z ) ;
+ virtual void LastResult( CORBA::Double & z ) ;
- virtual Engines::Component_ptr LccAdditionInterface( const char * aContainer ,
- const char * aComponentName ) ;
+ virtual Engines::Component_ptr LccAdditionInterface( char * aContainer ,
+ char * aComponentName ) ;
private:
LIB_SERVER_IDL = SALOME_ContainerManager.idl \
SALOME_Component.idl \
+ AddComponent.idl \
AdditionComponent.idl
# Executables targets
BIN_SERVER_IDL = SALOME_Exception.idl
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace -lSalomeNS -lSalomeLifeCycleCORBA
+LIBSFORBIN= $(LIBS)
LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
static omni_mutex aPutToStudyMutex;
SALOME_MED::FIELDDOUBLE_ptr CalculatorEngine::PutToStudy(SALOME_MED::FIELDDOUBLE_ptr theField1,
- long int theStudyId) {
+ CORBA::Long theStudyId) {
omni_mutex_lock aLock(aPutToStudyMutex);
CORBA::Object_var anObj = _NS->Resolve("/myStudyManager");
SALOME_MED::FIELDDOUBLE_ptr PutToStudy(SALOME_MED::FIELDDOUBLE_ptr theField,
- long int theStudyId);
+ CORBA::Long theStudyId);
SALOME_MED::FIELDDOUBLE_ptr Add(SALOME_MED::FIELDDOUBLE_ptr FirstField,
SALOME_MED::FIELDDOUBLE_ptr SecondField);
LIB = libCalculatorEngine.la
LIB_SRC = CalculatorEngine.cxx
#LIB_SERVER_IDL = Calculator.idl SALOME_Exception.idl SALOME_Component.idl SALOMEDS.idl SALOMEDS_Attributes.idl MED.idl
-LIB_SERVER_IDL = Calculator.idl
+LIB_SERVER_IDL = Calculator.idl SALOME_Comm.idl SALOME_ContainerManager.idl
LIB_CLIENT_IDL = SALOME_Exception.idl SALOME_Component.idl SALOMEDS.idl SALOME_GenericObj.idl SALOMEDS_Attributes.idl MED.idl
# Executables targets
BIN =
EXPORT_HEADERS =
CPPFLAGS+= $(PYTHON_INCLUDES) $(HDF5_INCLUDES) $(MED2_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I${MED_ROOT_DIR}/include/salome
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome -I${MED_ROOT_DIR}/include/salome
LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace -L${MED_ROOT_DIR}/lib/salome -lMEDEngine -lMEDClientcmodule
// File : DataStreamComponent_CheckOfUndefined.cxx
// Module : SuperVisionTest
-using namespace std;
#include <iostream>
#include <fstream>
#include <unistd.h>
#include "DataStreamComponent_Impl.hxx"
+using namespace std;
+
int main(int argc, char **argv) {
return 0;
}
// Author : Jean Rahuel
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
#include "DataStreamComponent_Impl.hxx"
+using namespace std;
+
DataStreamFactory_Impl::DataStreamFactory_Impl( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
DataStreamFactory_Impl::~DataStreamFactory_Impl() {
}
-void DataStreamFactory_Impl::Setxy( const long x , const long y ) {
+void DataStreamFactory_Impl::Setxy( CORBA::Long x , CORBA::Long y ) {
_x = x ;
_y = y ;
}
-void DataStreamFactory_Impl::Getxy( long & x , long & y ) {
+void DataStreamFactory_Impl::Getxy( CORBA::Long & x , CORBA::Long & y ) {
x = _x ;
y = _y ;
}
-void DataStreamFactory_Impl::Add( const long x , const long y , long & z ) {
+void DataStreamFactory_Impl::Add( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x+y ;
}
-void DataStreamFactory_Impl::Sub( const long x , const long y , long & z ) {
+void DataStreamFactory_Impl::Sub( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x-y ;
}
-void DataStreamFactory_Impl::Mul( const long x , const long y , long & z ) {
+void DataStreamFactory_Impl::Mul( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x*y ;
}
-void DataStreamFactory_Impl::Div( const long x , const long y , long & z ) {
+void DataStreamFactory_Impl::Div( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x/y ;
}
endService( "DataStream_Impl::~DataStream_Impl" );
}
-void DataStream_Impl::StreamSetxy( const long x , const long y ) {
+void DataStream_Impl::StreamSetxy( CORBA::Long x , CORBA::Long y ) {
_x = x ;
_y = y ;
}
-void DataStream_Impl::StreamGetxy( long & x , long & y ) {
+void DataStream_Impl::StreamGetxy( CORBA::Long & x , CORBA::Long & y ) {
x = _x ;
y = _y ;
}
-void DataStream_Impl::StreamAdd( const long x , const long y , long & z ) {
+void DataStream_Impl::StreamAdd( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x+y ;
}
-void DataStream_Impl::StreamSub( const long x , const long y , long & z ) {
+void DataStream_Impl::StreamSub( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x-y ;
}
-void DataStream_Impl::StreamMul( const long x , const long y , long & z ) {
+void DataStream_Impl::StreamMul( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x*y ;
}
-void DataStream_Impl::StreamDiv( const long x , const long y , long & z ) {
+void DataStream_Impl::StreamDiv( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) {
z = x/y ;
}
virtual ~DataStreamFactory_Impl();
- virtual void Setxy( const long x , const long y ) ;
+ virtual void Setxy( CORBA::Long x , CORBA::Long y ) ;
- virtual void Getxy( long & x , long & y ) ;
+ virtual void Getxy( CORBA::Long & x , CORBA::Long & y ) ;
- virtual void Add( const long x , const long y , long & z ) ;
- virtual void Sub( const long x , const long y , long & z ) ;
- virtual void Mul( const long x , const long y , long & z ) ;
- virtual void Div( const long x , const long y , long & z ) ;
+ virtual void Add( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
+ virtual void Sub( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
+ virtual void Mul( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
+ virtual void Div( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
virtual DataStreamComponent::DataStream_ptr NewDataStream() ;
virtual ~DataStream_Impl();
- virtual void StreamSetxy( const long x , const long y ) ;
+ virtual void StreamSetxy( CORBA::Long x , CORBA::Long y ) ;
- virtual void StreamGetxy( long & x , long & y ) ;
+ virtual void StreamGetxy( CORBA::Long & x , CORBA::Long & y ) ;
- virtual void StreamAdd( const long x , const long y , long & z ) ;
- virtual void StreamSub( const long x , const long y , long & z ) ;
- virtual void StreamMul( const long x , const long y , long & z ) ;
- virtual void StreamDiv( const long x , const long y , long & z ) ;
+ virtual void StreamAdd( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
+ virtual void StreamSub( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
+ virtual void StreamMul( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
+ virtual void StreamDiv( CORBA::Long x , CORBA::Long y , CORBA::Long & z ) ;
private:
-I${KERNEL_ROOT_DIR}/include/salome
LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
+LIBSFORBIN= $(LIBS)
LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
// Author : MARC TAJCHMAN, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
//#include "utilities.h"
#include "DivComponent.hxx"
+using namespace std;
+
DivComponentEngine::DivComponentEngine( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-#CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wno-deprecated
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -L${KERNEL_ROOT_DIR}/lib/salome
-
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification
@CONCLUDE@
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-#CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wno-deprecated
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification
+LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
// Author : MARC TAJCHMAN, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
//#include "utilities.h"
#include "MulComponent.hxx"
+using namespace std;
+
MulComponentEngine::MulComponentEngine( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-#CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wno-deprecated
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification
+LIBSFORBIN= $(LIBS)
+LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
// Author : MARC TAJCHMAN, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
//#include "utilities.h"
#include "SIGNALSComponent.hxx"
+using namespace std;
+
SIGNALSComponentEngine::SIGNALSComponentEngine( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
{
}
-long SIGNALSComponentEngine::SIGSEGVfunc() {
+CORBA::Long SIGNALSComponentEngine::SIGSEGVfunc() {
beginService( " SIGNALSComponentEngine::SIGSEGVfunc" );
int S = 10 ;
while ( S ) {
return nullptr ;
}
-long SIGNALSComponentEngine::SIGFPEfunc( long a , long b ) {
+CORBA::Long SIGNALSComponentEngine::SIGFPEfunc( CORBA::Long a , CORBA::Long b ) {
beginService( " SIGNALSComponentEngine::SIGFPEfunc" );
int S = 10 ;
while ( S ) {
virtual ~SIGNALSComponentEngine();
- long SIGSEGVfunc() ;
- long SIGFPEfunc( long a , long b ) ;
+ CORBA::Long SIGSEGVfunc() ;
+ CORBA::Long SIGFPEfunc( CORBA::Long a , CORBA::Long b ) ;
private:
#include <mpi.h>
#endif
+//CCRT
+#include <sstream>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+//end-CCRT
+
#include "Container_init_python.hxx"
using namespace std;
// Author : MARC TAJCHMAN, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
//#include "utilities.h"
#include "SIGNALSComponent_Impl.hxx"
+using namespace std;
+
SIGNALSComponent_Impl::SIGNALSComponent_Impl( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
{
}
-long SIGNALSComponent_Impl::SIGSEGVfunc() {
+CORBA::Long SIGNALSComponent_Impl::SIGSEGVfunc() {
beginService( " SIGNALSComponent_Impl::SIGSEGVfunc" );
cout << pthread_self() << "SIGNALSComponent_Impl::SIGSEGVfunc" << endl ;
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
return nullptr ;
}
-long SIGNALSComponent_Impl::SIGFPEfunc( long a , long b ) {
+CORBA::Long SIGNALSComponent_Impl::SIGFPEfunc( CORBA::Long a , CORBA::Long b ) {
beginService( " SIGNALSComponent_Impl::SIGFPEfunc" );
cout << pthread_self() << "SIGNALSComponent_Impl::SIGFPEfunc" << endl ;
int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
virtual ~SIGNALSComponent_Impl();
- long SIGSEGVfunc() ;
- long SIGFPEfunc( long a , long b ) ;
+ CORBA::Long SIGSEGVfunc() ;
+ CORBA::Long SIGFPEfunc( CORBA::Long a , CORBA::Long b ) ;
void MethodToKill() ;
void WaitKill() ;
SWIG_DEF = libSIGNALSComponent_Swig.i
EXPORT_PYSCRIPTS = libSIGNALSComponent_Swig.py
-LIB_SERVER_IDL =
+LIB_SERVER_IDL = SALOME_Component.idl \
+ SIGNALSComponent.idl \
+ UndefinedSymbolComponent.idl
+
# Executables targets
BIN =
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-#CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wno-deprecated
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -L${KERNEL_ROOT_DIR}/lib/salome -lSIGNALSComponentEngine
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSIGNALSComponentEngine
+LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-#CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wno-deprecated
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification
+LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
// Author : MARC TAJCHMAN, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
//#include "utilities.h"
#include "SubComponent.hxx"
+using namespace std;
+
SubComponentEngine::SubComponentEngine( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
LIB_SRC = \
SyrComponent_Impl.cxx
-LIB_SERVER_IDL = SALOME_Component.idl \
+LIB_SERVER_IDL = AddComponent.idl \
+ SALOME_Component.idl \
SyrComponent.idl
# Executables targets
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-#CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wno-deprecated
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
// File : SyrComponent_CheckOfUndefined.cxx
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <iostream>
#include <string>
#include <math.h>
+using namespace std;
+
// ------------------------------------------------------------------
// NextPrime : Compute the first prime number greater or equal than an integer
// ------------------------------------------------------------------
// Author : Jean Rahuel, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
#include "SyrComponent_Impl.hxx"
#include "Adder_Impl.hxx"
+using namespace std;
+
SyrComponent_Impl::SyrComponent_Impl( CORBA::ORB_ptr orb ,
PortableServer::POA_ptr poa ,
PortableServer::ObjectId * contId ,
SyrComponent_Impl::~SyrComponent_Impl() {
}
-long SyrComponent_Impl::C_ISEVEN( const long anInteger ) {
+CORBA::Long SyrComponent_Impl::C_ISEVEN( CORBA::Long anInteger ) {
bool RetVal ;
beginService( " SyrComponent_Impl::C_ISEVEN" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_ISEVEN is Computing");
return RetVal ;
}
-long SyrComponent_Impl::C_ISONE( const long anOddInteger ) {
+CORBA::Long SyrComponent_Impl::C_ISONE( CORBA::Long anOddInteger ) {
bool RetVal ;
beginService( " SyrComponent_Impl::C_ISONE" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_ISONE is Computing");
return RetVal ;
}
-long SyrComponent_Impl::C_M3( const long anOddInteger ) {
+CORBA::Long SyrComponent_Impl::C_M3( CORBA::Long anOddInteger ) {
beginService( " SyrComponent_Impl::C_M3" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_M3 is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return ( 3*anOddInteger ) ;
}
-long SyrComponent_Impl::C_M3P1( const long anOddInteger ) {
+CORBA::Long SyrComponent_Impl::C_M3P1( CORBA::Long anOddInteger ) {
beginService( " SyrComponent_Impl::C_M3P1" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_M3P1 is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return ( 3*anOddInteger + 1 ) ;
}
-long SyrComponent_Impl::C_DIV2( const long anEvenInteger ) {
+CORBA::Long SyrComponent_Impl::C_DIV2( CORBA::Long anEvenInteger ) {
beginService( " SyrComponent_Impl::C_DIV2" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_DIV2 is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return ( anEvenInteger >> 1 ) ;
}
-long SyrComponent_Impl::C_INCR( const long aCount ) {
+CORBA::Long SyrComponent_Impl::C_INCR( CORBA::Long aCount ) {
beginService( " SyrComponent_Impl::C_INCR" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_INCR is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return ( aCount + 1 ) ;
}
-void SyrComponent_Impl::CPP_SETLONG( const long aCount ) {
+void SyrComponent_Impl::CPP_SETLONG( CORBA::Long aCount ) {
beginService( " SyrComponent_Impl::CPP_SETLONG" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::CPP_SETLONG is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return ;
}
-long SyrComponent_Impl::CPP_ADDTOLONG( const long anIncr ) {
+CORBA::Long SyrComponent_Impl::CPP_ADDTOLONG( CORBA::Long anIncr ) {
beginService( " SyrComponent_Impl::CPP_ADDTOLONG" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::CPP_ADDTOLONG is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return ( _Count + anIncr ) ;
}
-long SyrComponent_Impl::C_MIN( const long aMinVal , const long anInteger ) {
+CORBA::Long SyrComponent_Impl::C_MIN( CORBA::Long aMinVal , CORBA::Long anInteger ) {
beginService( " SyrComponent_Impl::C_MIN" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_MIN is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return min ;
}
-long SyrComponent_Impl::C_MAX( const long aMaxVal , const long anInteger ) {
+CORBA::Long SyrComponent_Impl::C_MAX( CORBA::Long aMaxVal , CORBA::Long anInteger ) {
beginService( " SyrComponent_Impl::C_MAX" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_MAX is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
}
SuperVisionTest::ListOfSyr_ptr SyrComponent_Impl::C_AVERAGE(
- const SuperVisionTest::ListOfSyr_ptr aListOfSyr ,
- const long anInteger ,
- const long aCount ,
- double & anAverage ) {
+ SuperVisionTest::ListOfSyr_ptr aListOfSyr ,
+ CORBA::Long anInteger ,
+ CORBA::Long aCount ,
+ CORBA::Double & anAverage ) {
beginService( " SyrComponent_Impl::C_AVERAGE" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_AVERAGE is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return SuperVisionTest::ListOfSyr::_duplicate( aListOfSyr ) ;
}
-SuperVisionTest::Syr_ptr SyrComponent_Impl::Init( const long anOddInteger ) {
+SuperVisionTest::Syr_ptr SyrComponent_Impl::Init( CORBA::Long anOddInteger ) {
beginService( "SyrComponent_Impl::Init" );
sendMessage(NOTIF_STEP, "SyrComponent_Impl creates Syr_Impl");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
const char * interfaceName ,
const char * graphName ,
const char * nodeName ,
- const long anOddInteger ) :
+ const CORBA::Long anOddInteger ) :
SyrComponent_Impl(orb, poa, contId, instanceName, interfaceName,false) {
Names( graphName , nodeName ) ;
MESSAGE("Syr_Impl::Syr_Impl activate object instanceName("
endService( "Syr_Impl::~Syr_Impl" );
}
-long Syr_Impl::Initial() {
+CORBA::Long Syr_Impl::Initial() {
beginService( " Syr_Impl::Initial" );
sendMessage(NOTIF_STEP, "Syr_Impl::Initial is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return _InitialInteger ;
}
-long Syr_Impl::Current() {
+CORBA::Long Syr_Impl::Current() {
beginService( " Syr_Impl::Current" );
sendMessage(NOTIF_STEP, "Syr_Impl::Current is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
return _CurrentInteger ;
}
-long Syr_Impl::IsEven() {
+CORBA::Long Syr_Impl::IsEven() {
bool RetVal ;
beginService( " Syr_Impl::IsEven" );
sendMessage(NOTIF_STEP, "Syr_Impl::IsEven is Computing");
return RetVal ;
}
-long Syr_Impl::IsOne() {
+CORBA::Long Syr_Impl::IsOne() {
bool RetVal ;
beginService( " Syr_Impl::IsOne" );
sendMessage(NOTIF_STEP, "Syr_Impl::IsOne is Computing");
return RetVal ;
}
-long Syr_Impl::Count() {
+CORBA::Long Syr_Impl::Count() {
beginService( " Syr_Impl::Count" );
sendMessage(NOTIF_STEP, "Syr_Impl::Count is Computing");
// int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
virtual ~SyrComponent_Impl();
- virtual long C_ISEVEN( const long anInteger ) ;
+ virtual CORBA::Long C_ISEVEN( CORBA::Long anInteger ) ;
- virtual long C_ISONE( const long anOddInteger ) ;
+ virtual CORBA::Long C_ISONE( CORBA::Long anOddInteger ) ;
- virtual long C_M3( const long anOddInteger ) ;
+ virtual CORBA::Long C_M3( CORBA::Long anOddInteger ) ;
- virtual long C_M3P1( const long anOddInteger ) ;
+ virtual CORBA::Long C_M3P1( CORBA::Long anOddInteger ) ;
- virtual long C_DIV2( const long anEvenInteger ) ;
+ virtual CORBA::Long C_DIV2( CORBA::Long anEvenInteger ) ;
- virtual long C_INCR( const long aCount ) ;
+ virtual CORBA::Long C_INCR( CORBA::Long aCount ) ;
- virtual void CPP_SETLONG( const long aLong ) ;
+ virtual void CPP_SETLONG( CORBA::Long aLong ) ;
- virtual long CPP_ADDTOLONG( const long anIncr ) ;
+ virtual CORBA::Long CPP_ADDTOLONG( CORBA::Long anIncr ) ;
- virtual long C_MIN( const long aMinVal , const long anInteger ) ;
+ virtual CORBA::Long C_MIN( CORBA::Long aMinVal , CORBA::Long anInteger ) ;
- virtual long C_MAX( const long aMaxVal , const long anInteger ) ;
+ virtual CORBA::Long C_MAX( CORBA::Long aMaxVal , CORBA::Long anInteger ) ;
virtual SuperVisionTest::ListOfSyr_ptr C_LISTOFSYR() ;
virtual SuperVisionTest::ListOfSyr_ptr C_AVERAGE(
- const SuperVisionTest::ListOfSyr_ptr aListOfSyr ,
- const long anInteger ,
- const long aCount ,
- double & anAverage ) ;
+ SuperVisionTest::ListOfSyr_ptr aListOfSyr ,
+ CORBA::Long anInteger ,
+ CORBA::Long aCount ,
+ CORBA::Double & anAverage ) ;
- virtual SuperVisionTest::Syr_ptr Init( const long anOddInteger ) ;
+ virtual SuperVisionTest::Syr_ptr Init( CORBA::Long anOddInteger ) ;
private:
const char *interfaceName ,
const char * graphName ,
const char * nodeName ,
- const long anOddInteger );
+ const CORBA::Long anOddInteger );
virtual ~Syr_Impl();
- virtual long Initial() ;
+ virtual CORBA::Long Initial() ;
- virtual long Current() ;
+ virtual CORBA::Long Current() ;
- virtual long IsEven() ;
+ virtual CORBA::Long IsEven() ;
- virtual long IsOne() ;
+ virtual CORBA::Long IsOne() ;
- virtual long Count() ;
+ virtual CORBA::Long Count() ;
virtual void M3p1() ;
TestFunctionsMemory4
BIN_SRC =
BIN_CLIENT_IDL = SALOME_Component.idl \
+ SALOME_ContainerManager.idl \
AddComponent.idl
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeNS -lOpUtil
+LIBSFORBIN= $(LIBS)
LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeLifeCycleCORBA -lSalomeNS -lOpUtil
@CONCLUDE@
LIB_SRC = \
TypesCheck_Impl.cxx
-LIB_SERVER_IDL = TypesCheck.idl \
+LIB_SERVER_IDL = SALOME_Component.idl \
+ TypesCheck.idl \
AddComponent.idl
# Executables targets
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
-LDFLAGSFORBIN+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace -L${KERNEL_ROOT_DIR}/lib/salome
+LIBSFORBIN= $(LIBS)
+LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
// File : TypesCheck_CheckOfUndefined.cxx
// Module : SuperVisionTest
-using namespace std;
#include <iostream>
#include <fstream>
#include <unistd.h>
#include "TypesCheck_Impl.hxx"
+using namespace std;
+
int main(int argc, char **argv) {
return 0;
}
// Author : Jean Rahuel
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
#include "TypesCheck_Impl.hxx"
+using namespace std;
+
TypesCheck_Impl::TypesCheck_Impl( CORBA::ORB_ptr orb ,
PortableServer::POA_ptr poa ,
PortableServer::ObjectId * contId ,
endService( "TypesCheck_Impl::StringCheck" );
}
-void TypesCheck_Impl::BoolCheck( const bool InBool , bool & OutBool ) {
+void TypesCheck_Impl::BoolCheck( bool InBool , bool & OutBool ) {
beginService( "TypesCheck_Impl::BoolCheck" );
OutBool = InBool ;
endService( "TypesCheck_Impl::BoolCheck" );
}
-void TypesCheck_Impl::CharCheck( const unsigned char InChar , unsigned char & OutChar ) {
+void TypesCheck_Impl::CharCheck( unsigned char InChar , unsigned char & OutChar ) {
beginService( "TypesCheck_Impl::CharCheck" );
OutChar = InChar ;
endService( "TypesCheck_Impl::CharCheck" );
}
-void TypesCheck_Impl::ShortCheck( const short InShort , short & OutShort ) {
+void TypesCheck_Impl::ShortCheck( short InShort , short & OutShort ) {
beginService( "TypesCheck_Impl::ShortCheck" );
OutShort = InShort ;
endService( "TypesCheck_Impl::ShortCheck" );
}
-void TypesCheck_Impl::IntCheck( const int InInt , int & OutInt ) {
+void TypesCheck_Impl::IntCheck( int InInt , int & OutInt ) {
beginService( "TypesCheck_Impl::IntCheck" );
OutInt = InInt ;
endService( "TypesCheck_Impl::IntCheck" );
}
-void TypesCheck_Impl::LongCheck( const long InLong , long & OutLong ) {
+void TypesCheck_Impl::LongCheck( CORBA::Long InLong , CORBA::Long & OutLong ) {
beginService( "TypesCheck_Impl::LongCheck" );
int inInt = InLong ;
int outInt = OutLong ;
endService( "TypesCheck_Impl::LongCheck" );
}
-void TypesCheck_Impl::FloatCheck( const float InFloat , float & OutFloat ) {
+void TypesCheck_Impl::FloatCheck( float InFloat , float & OutFloat ) {
beginService( "TypesCheck_Impl::FloatCheck" );
OutFloat = InFloat ;
endService( "TypesCheck_Impl::FloatCheck" );
}
-void TypesCheck_Impl::DoubleCheck( const double InDouble , double & OutDouble ) {
+void TypesCheck_Impl::DoubleCheck( double InDouble , double & OutDouble ) {
beginService( "TypesCheck_Impl::DoubleCheck" );
OutDouble = InDouble ;
endService( "TypesCheck_Impl::DoubleCheck" );
}
-void TypesCheck_Impl::ObjRefCheck( const SuperVisionTest::Adder_ptr InObjRef , SuperVisionTest::Adder_out OutObjRef ) {
+void TypesCheck_Impl::ObjRefCheck( SuperVisionTest::Adder_ptr InObjRef , SuperVisionTest::Adder_out OutObjRef ) {
beginService( "TypesCheck_Impl::ObjRefCheck" );
OutObjRef = SuperVisionTest::Adder::_duplicate( InObjRef ) ;
endService( "TypesCheck_Impl::ObjRefCheck" );
}
-void TypesCheck_Impl::MiscTypes( const char * InString , const bool InBool , const unsigned char InChar , const short InShort , const long InLong , const float InFloat , const double InDouble , const SuperVisionTest::Adder_ptr InObjRef , _CORBA_String_out OutString ,bool & OutBool , unsigned char & OutChar , short & OutShort , long & OutLong , float & OutFloat , double & OutDouble , SuperVisionTest::Adder_out OutObjRef ) {
+void TypesCheck_Impl::MiscTypes( const char * InString , bool InBool , unsigned char InChar , short InShort , CORBA::Long InLong , float InFloat , double InDouble , SuperVisionTest::Adder_ptr InObjRef , _CORBA_String_out OutString ,bool & OutBool , unsigned char & OutChar , short & OutShort , CORBA::Long & OutLong , float & OutFloat , double & OutDouble , SuperVisionTest::Adder_out OutObjRef ) {
beginService( "TypesCheck_Impl::MiscTypes" );
OutString = CORBA::string_dup( InString ) ;
OutBool = InBool ;
virtual void StringCheck( const char * InString , _CORBA_String_out OutString ) ;
- virtual void BoolCheck( const bool InBool , bool & OutBool ) ;
+ virtual void BoolCheck( CORBA::Boolean InBool , CORBA::Boolean & OutBool ) ;
- virtual void CharCheck( const unsigned char InChar , unsigned char & OutChar ) ;
+ virtual void CharCheck( unsigned char InChar , unsigned char & OutChar ) ;
- virtual void ShortCheck( const short InShort , short & OutShort ) ;
+ virtual void ShortCheck( short InShort , short & OutShort ) ;
- virtual void IntCheck( const int InInt , int & OutInt ) ;
+ virtual void IntCheck( int InInt , int & OutInt ) ;
- virtual void LongCheck( const long InLong , long & OutLong ) ;
+ virtual void LongCheck( CORBA::Long InLong , CORBA::Long & OutLong ) ;
- virtual void FloatCheck( const float InFloat , float & OutFloat ) ;
+ virtual void FloatCheck( float InFloat , float & OutFloat ) ;
- virtual void DoubleCheck( const double InDouble , double & OutDouble ) ;
+ virtual void DoubleCheck( double InDouble , double & OutDouble ) ;
- virtual void ObjRefCheck( const SuperVisionTest::Adder_ptr InObjRef , SuperVisionTest::Adder_out OutObjRef ) ;
+ virtual void ObjRefCheck( SuperVisionTest::Adder_ptr InObjRef , SuperVisionTest::Adder_out OutObjRef ) ;
- virtual void MiscTypes( const char * InString , const bool InBool , const unsigned char InChar , const short InShort , const long InLong , const float InFloat , const double InDouble , SuperVisionTest::Adder_ptr InObjRef , _CORBA_String_out OutString , bool & OutBool , unsigned char & OutChar , short & OutShort , long & OutLong , float & OutFloat , double & OutDouble , SuperVisionTest::Adder_out OutObjRef ) ;
+ virtual void MiscTypes( const char * InString , CORBA::Boolean InBool , unsigned char InChar , short InShort , CORBA::Long InLong , float InFloat , double InDouble , SuperVisionTest::Adder_ptr InObjRef , _CORBA_String_out OutString , CORBA::Boolean & OutBool , unsigned char & OutChar , short & OutShort , CORBA::Long & OutLong , float & OutFloat , double & OutDouble , SuperVisionTest::Adder_out OutObjRef ) ;
private:
BIN_SERVER_IDL =
CPPFLAGS+= $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
-#CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wno-deprecated
-CXXFLAGS= -g -D_DEBUG_ -D__x86__ -D__linux__ $(PYTHON_INCLUDES) -ftemplate-depth-42 -Wall -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification
+LDFLAGSFORBIN+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lOpUtil -lRegistry -lSalomeNotification -lSALOMELocalTrace
@CONCLUDE@
// Author : MARC TAJCHMAN, CEA
// Module : SuperVisionTest
-using namespace std;
#include <stdio.h>
#include <unistd.h>
#include <fstream>
//#include "utilities.h"
#include "UndefinedSymbolComponent.hxx"
+using namespace std;
+
UndefinedSymbolComponentEngine::UndefinedSymbolComponentEngine( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId * contId,
extern "C" { long CallUndefined() ; } ;
-long UndefinedSymbolComponentEngine::UndefinedSymbol() {
+CORBA::Long UndefinedSymbolComponentEngine::UndefinedSymbol() {
beginService( " UndefinedSymbolComponentEngine::UndefinedSymbol" );
int S = 10 ;
while ( S ) {
virtual ~UndefinedSymbolComponentEngine();
- long UndefinedSymbol() ;
+ CORBA::Long UndefinedSymbol() ;
private:
