#
# Created from configure.in.base
#
-
+AS_SHELL_SANITIZES
AC_INIT(src)
AC_CONFIG_AUX_DIR(salome_adm/unix/config_files)
AC_CANONICAL_HOST
echo
echo
+dnl Modification B. Secher portage sur osf
+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='\${top_srcdir}'/salome_adm/unix/config_files/install-sh
+ INSTALL="${ROOT_SRCDIR}/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
echo
echo ---------------------------------------------
SALOME_Component.idl \
SALOME_TestComponent.idl \
SALOME_Registry.idl \
- TypeData.idl \
- MPIObject.idl \
- MPIContainer.idl \
+ SALOME_MPIObject.idl \
+ SALOME_MPIContainer.idl \
Logger.idl \
SALOME_GenericObj.idl \
SALOME_TestModuleCatalog.idl
echo "conftest.o: conftest.c" > conftest.verif
echo "int main() { return 0; }" > conftest.c
+dnl Evolution portage sur CCRT/osf system
+ case $host_os in
+ osf*)
+dnl sur CCRT/osf pas d'equivalent de l'option -MG de gcc avec compilo natif
+dnl on utilise donc gnu pour generer les dependances.
+ DEPCC=gcc
+ DEPCXX=g++
+ DEPCXXFLAGS="-Wno-deprecated"
+ DIFFFLAGS="-w"
+ ;;
+ *)
+ DEPCC=${CC-cc}
+ DEPCXX=${CXX-c++}
+ DEPCXXFLAGS="\${CXXFLAGS}"
+ DIFFFLAGS="-b -B"
+ ;;
+ esac
C_DEPEND_FLAG=
for ac_C_DEPEND_FLAG in -xM -MM -M ; do
rm -f conftest.d conftest.err
- ${CC-cc} ${ac_C_DEPEND_FLAG} -c conftest.c 1> conftest.d 2> conftest.err
+ ${DEPCC} ${ac_C_DEPEND_FLAG} -c conftest.c 1> conftest.d 2> conftest.err
if test -f conftest.u ; then
mv conftest.u conftest.d
fi
rm -f conftest
- diff -b -B conftest.d conftest.verif > conftest
+ diff ${DIFFFLAGS} conftest.d conftest.verif > conftest
if test ! -s conftest ; then
C_DEPEND_FLAG=${ac_C_DEPEND_FLAG}
break
dnl use gcc option -MG : asume unknown file will be construct later
rm -f conftest.d conftest.err
- ${CC-cc} ${C_DEPEND_FLAG} -MG -c conftest.c 1> conftest.d 2> conftest.err
+ ${DEPCC} ${C_DEPEND_FLAG} -MG -c conftest.c 1> conftest.d 2> conftest.err
if test -f conftest.u ; then
mv conftest.u conftest.d
fi
rm -f conftest
- diff -b -B conftest.d conftest.verif > conftest
+ diff ${DIFFFLAGS} conftest.d conftest.verif > conftest
if test ! -s conftest ; then
C_DEPEND_FLAG=${C_DEPEND_FLAG}" -MG"
fi
exit
fi
- echo -n " C : " ${C_DEPEND_FLAG}
+ printf " C : ${DEPCC} ${C_DEPEND_FLAG}"
AC_LANG_CPLUSPLUS
echo "conftest.o: conftest.cxx" > conftest.verif
for ac_CXX_DEPEND_FLAG in -xM -MM -M ; do
rm -f conftest.d conftest.err
- ${CXX-c++} ${ac_CXX_DEPEND_FLAG} -c conftest.cxx 1> conftest.d 2> conftest.err
+ ${DEPCXX} ${ac_CXX_DEPEND_FLAG} -c conftest.cxx 1> conftest.d 2> conftest.err
if test -f conftest.u ; then
mv conftest.u conftest.d
fi
rm -f conftest
- diff -b -B conftest.d conftest.verif > conftest
+ diff ${DIFFFLAGS} conftest.d conftest.verif > conftest
if test ! -s conftest ; then
CXX_DEPEND_FLAG=${ac_CXX_DEPEND_FLAG}
break
dnl use g++ option -MG : asume unknown file will be construct later
rm -f conftest.d conftest.err
- ${CXX-c++} ${CXX_DEPEND_FLAG} -MG -c conftest.cxx 1> conftest.d 2> conftest.err
+ ${DEPCXX} ${CXX_DEPEND_FLAG} -MG -c conftest.cxx 1> conftest.d 2> conftest.err
if test -f conftest.u ; then
mv conftest.u conftest.d
fi
rm -f conftest
- diff -b -B conftest.d conftest.verif > conftest
+ diff ${DIFFFLAGS} conftest.d conftest.verif > conftest
if test ! -s conftest ; then
CXX_DEPEND_FLAG=${CXX_DEPEND_FLAG}" -MG"
fi
exit
fi
- echo -n " C++ : " ${CXX_DEPEND_FLAG}
+ printf " C++ : ${DEPCXX} ${CXX_DEPEND_FLAG}"
AC_LANG_RESTORE
+ AC_SUBST(DEPCC)
+ AC_SUBST(DEPCXX)
+ AC_SUBST(DEPCXXFLAGS)
AC_SUBST(C_DEPEND_FLAG)
AC_SUBST(CXX_DEPEND_FLAG)
])
dnl @author Bernard Secher - 15/01/2004
dnl
AC_DEFUN([AC_CXX_OPTION], [
- AC_MSG_CHECKING(CXXFLAGS for $CXX in $1)
+ AC_MSG_CHECKING(wether $CXX accepts $1)
cat > conftest.cxx <<EOF
-int main(int argc, char **argv) { return 0; }
+int main() { return 0; }
EOF
$CXX $1 conftest.cxx > conftest.log 2>&1
var=`echo $1 | sed -e "s, .*$,," | sed -e "s,^-,,"`
AC_SUBST(CAS_OCAF)
AC_SUBST(CAS_DATAEXCHANGE)
AC_SUBST(CAS_LDFLAGS)
-
AC_SUBST(CAS_LDPATH)
OWN_CONFIG_H=no
occ_ok=no
own_config_h=no
-
dnl libraries directory location
case $host_os in
linux*)
irix6.*)
casdir=Linux
;;
- osf4.*)
+ osf*)
casdir=Linux
;;
solaris2.*)
;;
esac
+AC_MSG_CHECKING(for OpenCascade directories)
+if test -d ${CASROOT}/${casdir}/lib; then
+ CAS_LDPATH="-L$CASROOT/$casdir/lib "
+ AC_MSG_RESULT(yes)
+else
+ if test -d ${CASROOT}/lib; then
+ CAS_LDPATH="-L$CASROOT/lib "
+ AC_MSG_RESULT(yes)
+ else
+ AC_MSG_RESULT(no)
+ fi
+fi
+
+
dnl were is OCC ?
if test -z $CASROOT; then
AC_MSG_WARN(You must provide CASROOT variable : see OCC installation manual)
if test "x$occ_ok" = "xyes"; then
+dnl test c++ compiler flag for unsigned character
+ for opt in -funsigned-char -unsigned ; do
+ AC_CXX_OPTION($opt,CAS_CXXFLAGS,flag=yes,flag=no)
+ if test "$flag" = "yes"; then
+ break
+ fi
+ done
+
dnl cascade headers
CPPFLAGS_old="$CPPFLAGS"
- CPPFLAGS="$CPPFLAGS -DLIN -DLINTEL -DCSFDB -DNO_CXX_EXCEPTION -DNo_exception -DHAVE_CONFIG_H -DHAVE_LIMITS_H -I$CASROOT/inc -I$CASROOT -I$KERNEL_ROOT_DIR/include/salome -Wno-deprecated -DHAVE_WOK_CONFIG_H"
- CXXFLAGS_old="$CXXFLAGS"
- CXXFLAGS="$CXXFLAGS -funsigned-char"
-
+ CAS_CPPFLAGS="-DOCC_VERSION_MAJOR=$OCC_VERSION_MAJOR -DLIN -DLINTEL -DCSFDB -DNO_CXX_EXCEPTION -DNo_exception -DHAVE_CONFIG_H -DHAVE_LIMITS_H -DHAVE_WOK_CONFIG_H -I$CASROOT/inc"
+ CPPFLAGS="$CPPFLAGS $CAS_CPPFLAGS"
echo
echo
OWN_CONFIG_H=yes
fi
- CPPFLAGS="$CPPFLAGS -I$ROOT_BUILDDIR/salome_adm/unix"
-
AC_CHECK_HEADER(Standard_Type.hxx,occ_ok=yes ,occ_ok=no)
- CPPFLAGS="$CPPFLAGS_old"
- CXXFLAGS="$CXXFLAGS_old"
fi
AC_SUBST(OWN_CONFIG_H)
if test "x$occ_ok" = xyes ; then
- CAS_CPPFLAGS="-DOCC_VERSION_MAJOR=$OCC_VERSION_MAJOR -DLIN -DLINTEL -DCSFDB -DNO_CXX_EXCEPTION -DNo_exception -DHAVE_CONFIG_H -DHAVE_LIMITS_H -I$CASROOT/inc -I$CASROOT -DHAVE_WOK_CONFIG_H"
- CAS_CXXFLAGS="-funsigned-char"
-
AC_MSG_CHECKING(for OpenCascade libraries)
- CPPFLAGS_old="$CPPFLAGS"
- CPPFLAGS="$CPPFLAGS $CAS_CPPFLAGS -I$KERNEL_ROOT_DIR/include/salome -I$ROOT_BUILDDIR/salome_adm/unix -Wno-deprecated"
- CXXFLAGS_old="$CXXFLAGS"
- CXXFLAGS="$CXXFLAGS $CAS_CXXFLAGS"
LIBS_old="$LIBS"
- LIBS="$LIBS -L$CASROOT/$casdir/lib -lTKernel"
+ LIBS="$LIBS $CAS_LDPATH -lTKernel"
+
AC_CACHE_VAL(salome_cv_lib_occ,[
AC_TRY_LINK(
-using namespace std;
#include <Standard_Type.hxx>
, size_t size;
const Standard_CString aName="toto";
])
occ_ok="$salome_cv_lib_occ"
- CPPFLAGS="$CPPFLAGS_old"
- CXXFLAGS="$CXXFLAGS_old"
- LIBS="$LIBS_old"
fi
+CPPFLAGS="$CPPFLAGS_old"
+LIBS="$LIBS_old"
if test "x$occ_ok" = xno ; then
AC_MSG_RESULT(no)
AC_MSG_WARN(Opencascade libraries not found)
else
AC_MSG_RESULT(yes)
- CAS_LDPATH="-L$CASROOT/$casdir/lib "
CAS_KERNEL="$CAS_LDPATH -lTKernel -lTKMath"
- CAS_OCAF="$CAS_LDPATH -lPTKernel -lTKCAF -lFWOSPlugin -lTKPShape -lTKPCAF -lTKStdSchema -lTKShapeSchema -lPAppStdPlugin -lTKPAppStd -lTKCDF"
-dnl CAS_VIEWER="-L$CASROOT/$casdir/lib -lTKOpenGl -lTKV3d -lTKV2d -lTKService"
+
+ # E.A. compatibility version 4 and 5.x
+ CAS_OCAF="$CAS_LDPATH -lPTKernel -lTKCAF -lFWOSPlugin -lTKPShape -lTKPCAF -lTKStdSchema -lTKShapeSchema -lPAppStdPlugin"
+ if test $OCC_VERSION_MAJOR -lt 5 ; then
+ CAS_OCAF="$CAS_OCAF -lTKPAppStd"
+ fi
+ CAS_OCAF="$CAS_OCAF -lTKCDF"
+
CAS_VIEWER="$CAS_LDPATH -lTKOpenGl -lTKV3d -lTKService"
-# CAS_MODELER="-L$CASROOT/$casdir/lib -lTKG2d -lTKG3d -lTKGeomBase -lTKBRep -lTKGeomAlgo -lTKTopAlgo -lTKPrim -lTKBool -lTKHLR -lTKFillet -lTKFeat -lTKOffset"
CAS_MODELER="$CAS_LDPATH -lTKG2d -lTKG3d -lTKGeomBase -lTKBRep -lTKGeomAlgo -lTKTopAlgo -lTKPrim -lTKBool -lTKHLR -lTKFillet -lTKOffset"
-dnl CAS_DATAEXCHANGE="-L$CASROOT/$casdir/lib -lTKXSBase -lTKIGES -lTKSTEP -lTKShHealing -lTKShHealingStd -lTKSTL -lTKVRML "
- CAS_DATAEXCHANGE="$CAS_LDPATH -lTKXSBase -lTKIGES -lTKSTEP -lTKShHealing -lTKShHealingStd"
+
+ # E.A. compatibility version 4 and 5.x
+ CAS_DATAEXCHANGE="$CAS_LDPATH -lTKXSBase -lTKIGES -lTKSTEP -lTKShHealing"
+ if test $OCC_VERSION_MAJOR -lt 5 ; then
+ CAS_DATAEXCHANGE="$CAS_DATAEXCHANGE -lTKShHealingStd"
+ fi
+
+
CAS_LDFLAGS="$CAS_KERNEL $CAS_OCAF $CAS_VIEWER $CAS_MODELER $CAS_DATAEXCHANGE"
-
-
+
fi
AC_LANG_RESTORE
fi
if test "$WITHLAM" = "yes";then
+ WITHMPI="yes"
mpi_ok=yes
MPI_LIBS="$MPI_LIBS -lmpi -llam"
else
CORBA_IDLPYFLAGS="-DHAVE_MPI2 $CORBA_IDLPYFLAGS"
fi
+AC_SUBST(WITHMPI)
AC_SUBST(MPI_INCLUDES)
AC_SUBST(MPI_LIBS)
AC_SUBST(mpi_ok)
if test "$WITHMPICH" = "yes";then
LDFLAGS_old="$LDFLAGS"
LDFLAGS="$MPI_LIBS $LDFLAGS"
- AC_CHECK_LIB(mpich,MPI_Init,
- AC_CHECK_LIB(pmpich, PMPI_Init,WITHMPICH="yes",WITHMPICH="no"),
- WITHMPICH="no")
+ AC_CHECK_LIB(mpich,MPI_Init,WITHMPICH="yes",WITHMPICH="no")
AC_CHECK_LIB(mpich,MPI_Publish_name,WITHMPI2="yes",WITHMPI2="no")
LDFLAGS="$LDFLAGS_old"
fi
if test "$WITHMPICH" = "yes";then
+ WITHMPI="yes"
mpi_ok=yes
- MPI_LIBS="$MPI_LIBS -lpmpich -lmpich"
+ MPI_LIBS="$MPI_LIBS -lmpich"
else
mpi_ok=no
fi
dnl ----------------------------------------------------------------
dnl CHECK_PTHREADS
AC_DEFUN(CHECK_PTHREADS,[
-AC_REQUIRE([AC_CANONICAL_SYSTEM])dnl
-AC_CHECK_HEADER(pthread.h,AC_DEFINE(HAVE_PTHREAD_H))
-AC_CHECK_LIB(posix4,nanosleep, LIBS_PTHREADS="-lposix4",LIBS_PTHREADS="")
-AC_CHECK_LIB(pthread,pthread_mutex_lock,
- LIBS_PTHREADS="-lpthread $LIBS_PTHREADS")
-AC_MSG_CHECKING([parameters for using pthreads])
-case $build_os in
- freebsd*)
- CFLAGS_PTHREADS="-pthread"
- CXXFLAGS_PTHREADS="-pthread"
- ;;
- *)
- ;;
-esac
-AC_MSG_RESULT(["flags: $CFLAGS_PTHREADS\;libs: $LIBS_PTHREADS"])
-threads_ok=yes
+AC_CXX_OPTION(-pthread,CPPFLAGS,flag=yes,flag=no)
+
+if test $flag = no; then
+ AC_REQUIRE([AC_CANONICAL_SYSTEM])dnl
+ AC_CHECK_HEADER(pthread.h,AC_DEFINE(HAVE_PTHREAD_H))
+ AC_CHECK_LIB(posix4,nanosleep, LIBS_PTHREADS="-lposix4",LIBS_PTHREADS="")
+ AC_CHECK_LIB(pthread,pthread_mutex_lock,
+ LIBS_PTHREADS="-lpthread $LIBS_PTHREADS",LIBS_PTHREADS="")
+fi
+
+if test $flag = no && x$LIBS_PTHREADS = x; then
+ threads_ok=no
+else
+ threads_ok=yes
+fi
])dnl
dnl
dnl
sip_vers=new ;;
3.5*)
sip_vers=new ;;
+ 3.6*)
+ sip_vers=new ;;
+ 3.7*)
+ sip_vers=new ;;
+ 3.8*)
+ sip_vers=new ;;
+ 3.9*)
+ sip_vers=new ;;
*)
sip_vers=no ;;
esac
-
sip_ok=no
if test "x$sip_vers" = "xold"
if test "x$sip_vers" = "xnew"
then
- if test -d ${SIPDIR}/include ; then
- sip_ok=yes
+ sip_ok=yes
+ if test -d ${SIPDIR}/include/python${PYTHON_VERSION} ; then
SIP_ROOT="$SIPDIR"
- SIP_INCLUDES="${PYTHON_INCLUDES} -I${SIPDIR}/include"
- SIP_LIBS="-L${SIPDIR}/lib -lsip"
+ SIP_INCLUDES="${PYTHON_INCLUDES} -I${SIPDIR}/include/python${PYTHON_VERSION}"
+ SIP_LIBS="-L${SIPDIR}/lib/python${PYTHON_VERSION}/site-packages -lsip"
else
sip_ok=yes
SIP_ROOT="$SIPDIR"
AC_MSG_WARN(vtk needs OpenGL correct configuration, check configure output)
fi
+if test "x$x_libraries" != "x"
+then
+ LXLIB="-L$x_libraries"
+else
+ LXLIB=""
+fi
LOCAL_INCLUDES="$OGL_INCLUDES"
-LOCAL_LIBS="-lvtkCommon -lvtkGraphics -lvtkImaging -lvtkFiltering -lvtkIO -lvtkRendering -lvtkHybrid $OGL_LIBS -L$x_libraries -lX11 -lXt"
-TRY_LINK_LIBS="-lvtkCommon $OGL_LIBS -L$x_libraries -lX11 -lXt"
+LOCAL_LIBS="-lvtkCommon -lvtkGraphics -lvtkImaging -lvtkFiltering -lvtkIO -lvtkRendering -lvtkHybrid $OGL_LIBS $LXLIB -lX11 -lXt"
+TRY_LINK_LIBS="-lvtkCommon $OGL_LIBS $LXLIB -lX11 -lXt"
if test -z $VTKHOME
then
dnl vtk headers
CPPFLAGS_old="$CPPFLAGS"
-CPPFLAGS="$CPPFLAGS $LOCAL_INCLUDES -Wno-deprecated"
+CPPFLAGS="$CPPFLAGS $LOCAL_INCLUDES"
AC_CHECK_HEADER(vtkPlane.h,vtk_ok="yes",vtk_ok="no")
# LIBS="$LIBS $TRY_LINK_LIBS"
LIBS="$LIBS $LOCAL_LIBS"
CPPFLAGS_old="$CPPFLAGS"
- CPPFLAGS="$CPPFLAGS $VTK_INCLUDES -Wno-deprecated"
+ CPPFLAGS="$CPPFLAGS $VTK_INCLUDES"
dnl VTKPY_MODULES="$VTKHOME/python"
esac],
enable_production=AC_ENABLE_PRODUCTION_DEFAULT)dnl
-CXXFLAGS="$CXXFLAGS -Wno-deprecated -Wparentheses -Wreturn-type -Wmissing-declarations -Wunused "
+# portage alpha/OSF
+# CXXFLAGS="$CXXFLAGS -Wno-deprecated -Wparentheses -Wreturn-type -Wmissing-declarations -Wunused "
+echo $CXX
+AC_CXX_OPTION(-Wparentheses,CXXFLAGS)
+AC_CXX_OPTION(-Wreturn-type,CXXFLAGS)
+AC_CXX_OPTION(-Wmissing-declarations,CXXFLAGS)
+AC_CXX_OPTION(-Wunused,CXXFLAGS)
-CXXVERSION=`$CXX --version`
-if test "X$CXXVERSION" != "X2.95.3"; then
- CXXFLAGS="${CXXFLAGS} -fmessage-length=0 "
-fi
+# supprimer car ne marche qu'avec compilo gnu
+# CXXVERSION=`$CXX --version`
+# if test "X$CXXVERSION" != "X2.95.3"; then
+# CXXFLAGS="${CXXFLAGS} -fmessage-length=0 "
+# fi
if test "X$enable_production" = "Xyes"; then
CFLAGS="$CFLAGS -O"
- CXXFLAGS="$CXXFLAGS -O -Wuninitialized "
+# CXXFLAGS="$CXXFLAGS -O -Wuninitialized "
+ AC_CXX_OPTION(-Wuninitialized,CXXFLAGS)
+ CXXFLAGS="$CXXFLAGS -O "
fi
])
AC_MSG_CHECKING([if we need libdb])
PY_NEEDOPENDB=`nm $PYTHON_LIBA | grep dbopen | grep U`
if test "x$PY_NEEDOPENDB" != "x"; then
- PYTHON_LIBS="$PYTHON_LIBS -ldb"
AC_MSG_RESULT(yes)
+ AC_CHECK_LIB(db,dbopen,PYTHON_LIBS="$PYTHON_LIBS -ldb",db_ok=no)
else
AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING([if we need libdl])
PY_NEEDOPENDL=`nm $PYTHON_LIBA | grep dlopen | grep U`
if test "x$PY_NEEDOPENDL" != "x"; then
- PYTHON_LIBS="$PYTHON_LIBS -ldl"
AC_MSG_RESULT(yes)
+ AC_CHECK_LIB(dl,dlopen,PYTHON_LIBS="$PYTHON_LIBS -ldl",dl_ok=no)
else
AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING([if we need libutil])
PY_NEEDOPENPTY=`nm $PYTHON_LIBA | grep openpty | grep U`
if test "x$PY_NEEDOPENPTY" != "x"; then
- PYTHON_LIBS="$PYTHON_LIBS -lutil"
AC_MSG_RESULT(yes)
+ AC_CHECK_LIB(util,openpty,PYTHON_LIBS="$PYTHON_LIBS -lutil",openpty_ok=no)
else
AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING([if we need tcltk])
PY_NEEDTCLTK=`nm $PYTHON_LIBA | grep Tcl_Init | grep U`
if test "x$PY_NEEDTCLTK" != "x"; then
- PYTHON_LIBS="$PYTHON_LIBS -ltcl -ltk"
AC_MSG_RESULT(yes)
+ AC_CHECK_LIB(tcl,Tcl_Init,PYTHON_LIBS="$PYTHON_LIBS -ltcl -ltk",tclinit_ok=no)
else
AC_MSG_RESULT(no)
fi
inc_builddir=$(top_builddir)/include/salome
@SET_MAKE@
-SHELL=/bin/sh
+# Modifcation B. Secher portage sur osf
+SHELL=@SHELL@
# header missing
LIBS=@LIBS@
-LDFLAGS=@LDFLAGS@ -L$(top_builddir)/lib/salome -Xlinker -rpath-link -Xlinker -L$(top_builddir)/lib/salome
+# LDFLAGS=@LDFLAGS@ -L$(top_builddir)/lib/salome -Xlinker -rpath-link -Xlinker -L$(top_builddir)/lib/salome
+LDFLAGS=@LDFLAGS@ -L$(top_builddir)/lib/salome
# add libstdc++ to link c++ library with libtool !
-LDFLAGS+= -lstdc++
+LDFLAGS+= @STDLIB@
-CP=@CP@
+#CP=@CP@
# CPP
# JAVA
-JAVA_INCLUDES = @JAVA_INCLUDES@
-JAVA_LIBS = @JAVA_LIBS@
-JAVA_LDPATH = @JAVA_LDPATH@
+#JAVA_INCLUDES = @JAVA_INCLUDES@
+#JAVA_LIBS = @JAVA_LIBS@
+#JAVA_LDPATH = @JAVA_LDPATH@
# PYTHON
DOXYGEN = @DOXYGEN@
## Shared libraries
-LT_STATIC_EXEC=@LT_STATIC_EXEC@
-DYNAMIC_DIRS=@DYNAMIC_DIRS@
+#LT_STATIC_EXEC=@LT_STATIC_EXEC@
+#DYNAMIC_DIRS=@DYNAMIC_DIRS@
LT_LIB=libtool
LT=$(top_builddir)/libtool
LT_COMPILE=$(LT) --mode=compile $(CC)
*/
#include "Batch_APIInternalFailureException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- APIInternalFailureException(string ch = "undefined") : GenericException("APIInternalFailureException", ch) {}
+ APIInternalFailureException(std::string ch = "undefined") : GenericException("APIInternalFailureException", ch) {}
};
}
#include "Batch_InvalidArgumentException.hxx"
#include "Batch_FactBatchManager.hxx"
#include "Batch_BatchManager.hxx"
+using namespace std;
namespace Batch {
#ifndef _BATCHMANAGER_H_
#define _BATCHMANAGER_H_
-using namespace std;
#include <string>
#include <map>
#include "Batch_Job.hxx"
{
public:
// Constructeur et destructeur
- //BatchManager(string host="localhost") throw(InvalidArgumentException); // connexion a la machine host
+ //BatchManager(std::string host="localhost") throw(InvalidArgumentException); // connexion a la machine host
BatchManager(const FactBatchManager * parent, const char * host="localhost") throw(InvalidArgumentException); // connexion a la machine host
virtual ~BatchManager();
- virtual string __repr__() const;
+ virtual std::string __repr__() const;
// Recupere le l'identifiant d'un job deja soumis au BatchManager
- //virtual const JobId getJobIdByReference(const string & ref);
+ //virtual const JobId getJobIdByReference(const std::string & ref);
virtual const JobId getJobIdByReference(const char * ref);
// Methodes pour le controle des jobs : virtuelles pures
virtual JobInfo queryJob(const JobId & jobid) = 0; // renvoie l'etat du job
protected:
- string _hostname; // serveur ou tourne le BatchManager
- map< const string, const JobId * > jobid_map; // table des jobs deja soumis
+ std::string _hostname; // serveur ou tourne le BatchManager
+ std::map< const std::string, const JobId * > jobid_map; // table des jobs deja soumis
const FactBatchManager * _parent;
private:
#include <map>
#include "Batch_BatchManagerCatalog.hxx"
#include "Batch_FactBatchManager.hxx"
+using namespace std;
namespace Batch {
#ifndef _CATALOG_H_
#define _CATALOG_H_
-using namespace std;
#include <string>
#include <map>
#include <pthread.h>
static void addFactBatchManager(const char * type, FactBatchManager * pFBM);
virtual FactBatchManager * operator() (const char * type) const;
- virtual map<string, FactBatchManager *> * dict() const;
- virtual string __repr__() const;
+ virtual std::map<std::string, FactBatchManager *> * dict() const;
+ virtual std::string __repr__() const;
protected:
- static map<string, FactBatchManager *> * _p_catalog;
+ static std::map<std::string, FactBatchManager *> * _p_catalog;
static pthread_mutex_t _mutex;
private:
#include <sstream>
//#include "MEDMEM_STRING.hxx"
#include "Batch_BatchManager_PBS.hxx"
+using namespace std;
namespace Batch {
public:
// Constructeur et destructeur
//BatchManager_PBS() throw(InvalidArgumentException,ConnexionFailureException); // connexion au serveur par defaut
- //BatchManager_PBS(string host) throw(InvalidArgumentException,ConnexionFailureException); // connexion a la machine host
+ //BatchManager_PBS(std::string host) throw(InvalidArgumentException,ConnexionFailureException); // connexion a la machine host
BatchManager_PBS(const FactBatchManager * parent, const char * host="localhost") throw(InvalidArgumentException,ConnexionFailureException); // connexion a la machine host
virtual ~BatchManager_PBS();
// Recupere le nom du serveur par defaut
- // static string BatchManager_PBS::getDefaultServer();
+ // static std::string BatchManager_PBS::getDefaultServer();
// Methodes pour le controle des jobs
virtual const JobId submitJob(const Job & job); // soumet un job au gestionnaire
#ifdef SWIG
public:
// Recupere le l'identifiant d'un job deja soumis au BatchManager
- //virtual const JobId getJobIdByReference(const string & ref) { return BatchManager::getJobIdByReference(ref); }
+ //virtual const JobId getJobIdByReference(const std::string & ref) { return BatchManager::getJobIdByReference(ref); }
virtual const JobId getJobIdByReference(const char * ref) { return BatchManager::getJobIdByReference(ref); }
#endif
#include <string>
#include "Batch_BoolType.hxx"
+using namespace std;
namespace Batch {
#ifndef _BOOLTYPE_H_
#define _BOOLTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
BoolType(const bool b=false) : _data(b) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual BoolType & operator =(bool);
#include <string>
#include "Batch_CharType.hxx"
+using namespace std;
namespace Batch {
#ifndef _CHARTYPE_H_
#define _CHARTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
CharType(const char c=0) : _data(c) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual CharType & operator =(char);
*/
#include "Batch_ConnexionFailureException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- ConnexionFailureException(string ch = "undefined") : GenericException("ConnexionFailureException", ch) {}
+ ConnexionFailureException(std::string ch = "undefined") : GenericException("ConnexionFailureException", ch) {}
};
*/
#include "Batch_Couple.hxx"
+using namespace std;
namespace Batch {
#ifndef _COUPLE_H_
#define _COUPLE_H_
-using namespace std;
#include <string>
namespace Batch {
{
public:
// Constructeur standard
- Couple(const string & local="", const string & remote="") : _local(local), _remote(remote) {}
+ Couple(const std::string & local="", const std::string & remote="") : _local(local), _remote(remote) {}
// Constructeur par recopie
Couple(const Couple & C) : _local(C._local), _remote(C._remote) {}
// Operateur pour l'affichage sur un stream
- friend ostream & operator << (ostream & os, const Couple & cp);
+ friend std::ostream & operator << (std::ostream & os, const Couple & cp);
// Operateur d'affectation
virtual Couple & operator =(const Couple &);
// Conversion en chaine
- virtual string str() const;
+ virtual std::string str() const;
// Accesseurs
- virtual string getLocal() const { return _local; }
- virtual string getRemote() const { return _remote; }
+ virtual std::string getLocal() const { return _local; }
+ virtual std::string getRemote() const { return _remote; }
protected:
- string _local; // chemin d'acces au fichier local
- string _remote; // chemin d'acees au fichier distant
+ std::string _local; // chemin d'acces au fichier local
+ std::string _remote; // chemin d'acees au fichier distant
private:
*/
#include "Batch_CoupleType.hxx"
+using namespace std;
namespace Batch {
#ifndef _COUPLETYPE_H_
#define _COUPLETYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
#include "Batch_Couple.hxx"
CoupleType(const Couple & C) : _data(C) {}
// Conversion en chaine
- virtual string affiche() const;
- virtual operator string() const;
+ virtual std::string affiche() const;
+ virtual operator std::string() const;
// Operateur d'affectation
virtual CoupleType & operator =(const Couple & C);
#include <cstdio>
#include <ctime>
#include "Batch_Date.hxx"
+using namespace std;
namespace Batch {
#ifndef _DATE_H_
#define _DATE_H_
-using namespace std;
#include <string>
namespace Batch {
{
public:
Date(const long l=0);
- Date(const string s);
+ Date(const std::string s);
virtual Date & operator =(long l);
virtual Date & operator +(long l);
virtual Date & operator -(long l);
virtual Date & operator +=(long l);
virtual Date & operator -=(long l);
- virtual Date & operator =(const string & s);
- virtual string str() const;
+ virtual Date & operator =(const std::string & s);
+ virtual std::string str() const;
virtual long epoch() const;
protected:
#include <time.h>
}
#include "Batch_DateType.hxx"
+using namespace std;
namespace Batch {
#ifndef _DATETYPE_H_
#define _DATETYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
#include "Batch_Date.hxx"
DateType(const Date & d) : _data(d) {};
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual DateType & operator =(const Date &);
*/
#include "Batch_Environnement.hxx"
+using namespace std;
namespace Batch {
#define _ENVIRONNEMENT_H_
-using namespace std;
#include <string>
#include <map>
namespace Batch {
- typedef map < string, string > Environnement;
+ typedef std::map < std::string, std::string > Environnement;
}
#include "Batch_BatchManagerCatalog.hxx"
#include "Batch_FactBatchManager.hxx"
#include "utilities.h"
+using namespace std;
namespace Batch {
#ifndef _FACTBATCHMANAGER_H_
#define _FACTBATCHMANAGER_H_
-using namespace std;
#include <string>
#include <map>
{
public:
// Constructeur et destructeur
- FactBatchManager(const string & type);
+ FactBatchManager(const std::string & type);
virtual ~FactBatchManager();
virtual BatchManager * operator() (const char * hostname) const = 0;
- string getType() const;
- string __repr__() const;
+ std::string getType() const;
+ std::string __repr__() const;
protected:
- string type;
+ std::string type;
private:
#include "Batch_BatchManager_PBS.hxx"
#include "Batch_FactBatchManager_PBS.hxx"
#include "utilities.h"
+using namespace std;
namespace Batch {
#ifndef _FACTBATCHMANAGER_PBS_H_
#define _FACTBATCHMANAGER_PBS_H_
-using namespace std;
-#include <string>
-#include <map>
#include "Batch_FactBatchManager.hxx"
namespace Batch {
*/
#include "Batch_GenericException.hxx"
+using namespace std;
namespace Batch {
#define _GENERICEXCEPTION_H_
-using namespace std;
#include <string>
namespace Batch {
class GenericException
{
public:
- const string type; // la nature de l'exception
- const string message; // la raison de l'exception
+ const std::string type; // la nature de l'exception
+ const std::string message; // la raison de l'exception
// Constructeur
- GenericException(const string tp = "GenericException", const string ch = "undefined") : type(tp), message(ch) {}
+ GenericException(const std::string tp = "GenericException", const std::string ch = "undefined") : type(tp), message(ch) {}
};
}
#include <iostream>
#include <string>
#include "Batch_GenericType.hxx"
+using namespace std;
namespace Batch {
#define _GENERICTYPE_H_
-using namespace std;
#include <iostream>
#include <string>
virtual ~GenericType() { _nb--; }
// Operateur pour l'affichage sur un stream
- friend ostream & operator << (ostream & os, const GenericType & obj);
+ friend std::ostream & operator << (std::ostream & os, const GenericType & obj);
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Clone duplique l'objet et en fabrique un nouveau a l'aide de new
// qu'il faudra detruire ensuite manuellement
#include <sstream>
//#include "MEDMEM_STRING.hxx"
#include "Batch_IntType.hxx"
+using namespace std;
namespace Batch {
#ifndef _INTTYPE_H_
#define _INTTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
IntType(const int i=0) : _data(i) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual IntType & operator =(int);
*/
#include "Batch_InvalidArgumentException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- InvalidArgumentException(string ch = "undefined") : GenericException("InvalidArgumentException", ch) {}
+ InvalidArgumentException(std::string ch = "undefined") : GenericException("InvalidArgumentException", ch) {}
};
}
*/
#include "Batch_InvalidKeyException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- InvalidKeyException(string ch = "undefined") : GenericException("InvalidKeyException", ch) {}
+ InvalidKeyException(std::string ch = "undefined") : GenericException("InvalidKeyException", ch) {}
protected:
#include "Batch_Parametre.hxx"
#include <sstream>
//#include "MEDMEM_STRING.hxx"
+using namespace std;
namespace Batch {
virtual ~Job() {}
// Operateur pour l'affichage sur un stream
- friend ostream & operator <<(ostream & os, const Job & job);
+ friend std::ostream & operator <<(std::ostream & os, const Job & job);
// Accesseurs
Parametre getParametre() const;
// Methodes pour l'interfacage avec Python (SWIG)
// TODO : supprimer ces methodes et transferer leur definitions dans SWIG
- string __str__() const; // SWIG : affichage en Python
- string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+ std::string __str__() const; // SWIG : affichage en Python
+ std::string __repr__() const { return __str__(); }; // SWIG : affichage en Python
protected:
Parametre _param; // table des parametres batch du job
#include "Batch_BatchManager.hxx"
#include <sstream>
//#include "MEDMEM_STRING.hxx"
+using namespace std;
namespace Batch {
virtual ~JobId();
// Constructeur avec le pointeur sur le BatchManager associe et avec une reference
- JobId(BatchManager *, string ref);
+ JobId(BatchManager *, std::string ref);
// Operateur d'affectation entre objets
virtual JobId & operator =(const JobId &);
JobId(const JobId &);
// Accesseur pour la reference interne
- virtual string getReference() const;
+ virtual std::string getReference() const;
// Methodes pour le controle du job
virtual void deleteJob() const; // retire un job du gestionnaire
// Methodes pour l'interfacage avec Python (SWIG)
// TODO : supprimer ces methodes et transferer leur definitions dans SWIG
- string __str__() const; // SWIG : affichage en Python
- string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+ std::string __str__() const; // SWIG : affichage en Python
+ std::string __repr__() const { return __str__(); }; // SWIG : affichage en Python
protected:
BatchManager * _p_batchmanager; // pointeur sur le BatchManager qui controle le job
- string _reference; // reference du job au sein du BatchManager
+ std::string _reference; // reference du job au sein du BatchManager
private:
#include <sstream>
//#include "MEDMEM_STRING.hxx"
#include "Batch_JobInfo.hxx"
+using namespace std;
namespace Batch {
#ifndef _JOBINFO_H_
#define _JOBINFO_H_
-using namespace std;
#include <iostream>
#include <string>
#include "Batch_Parametre.hxx"
JobInfo(const JobInfo & jinfo) : _param(jinfo._param), _env(jinfo._env) {};
// Operateur pour l'affichage sur un stream
- friend ostream & operator <<(ostream & os, const JobInfo & ji);
+ friend std::ostream & operator <<(std::ostream & os, const JobInfo & ji);
// Accesseurs
virtual Parametre getParametre() const;
// Methodes pour l'interfacage avec Python (SWIG)
// TODO : supprimer ces methodes et transferer leur definitions dans SWIG
- string __str__() const; // SWIG : affichage en Python
- string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+ std::string __str__() const; // SWIG : affichage en Python
+ std::string __repr__() const { return __str__(); }; // SWIG : affichage en Python
protected:
Parametre _param; // parametres du job
#include "Batch_Environnement.hxx"
#include "Batch_RunTimeException.hxx"
#include "Batch_JobInfo_PBS.hxx"
+using namespace std;
namespace Batch {
// Methodes pour l'interfacage avec Python (SWIG)
// TODO : supprimer ces methodes et transferer leur definitions dans SWIG
- string __str__() const; // SWIG : affichage en Python
- string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+ std::string __str__() const; // SWIG : affichage en Python
+ std::string __repr__() const { return __str__(); }; // SWIG : affichage en Python
protected:
private:
// Convertit une date HH:MM:SS en secondes
- long HMStoLong(const string &);
+ long HMStoLong(const std::string &);
};
#include <stdlib.h>
#include <unistd.h>
#include "Batch_Job_PBS.hxx"
+using namespace std;
namespace Batch {
*/
#include "Batch_ListIsFullException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- ListIsFullException(string ch = "undefined") : GenericException("ListIsFullException", ch) {}
+ ListIsFullException(std::string ch = "undefined") : GenericException("ListIsFullException", ch) {}
};
}
#include <sstream>
//#include "MEDMEM_STRING.hxx"
#include "Batch_LongType.hxx"
+using namespace std;
namespace Batch {
#ifndef _LONGTYPE_H_
#define _LONGTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
LongType(const long l=0L) : _data(l) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual LongType & operator =(long);
#include <string>
#include "Batch_MapKey.hxx"
+using namespace std;
namespace Batch {
#define _MAPKEY_H_
-using namespace std;
#include <string>
namespace Batch {
// une classe privee pour les differents types
// ces types ne peuvent pas etre redefinis
- class MapKey : public string
+ class MapKey : public std::string
{
private:
friend class Parametre; // seule la classe Parametre peut creer des MapKey
- MapKey() : string() {}
- MapKey(const MapKey & mk, size_type pos, size_type npos) : string(mk, pos, npos) {}
- MapKey(const char * s, size_type n) : string(s, n) {}
- MapKey(const char * s) : string(s) {}
- MapKey(size_type n, char c) : string(n, c) {}
+ MapKey() : std::string() {}
+ MapKey(const MapKey & mk, size_type pos, size_type npos) : std::string(mk, pos, npos) {}
+ MapKey(const char * s, size_type n) : std::string(s, n) {}
+ MapKey(const char * s) : std::string(s) {}
+ MapKey(size_type n, char c) : std::string(n, c) {}
#ifdef __STL_MEMBER_TEMPLATES
template<class InputIterator>
- MapKey(InputIterator __begin, InputIterator __end) : string(__begin, __end) {}
+ MapKey(InputIterator __begin, InputIterator __end) : std::string(__begin, __end) {}
#else
- MapKey(const_iterator __begin, const_iterator __end) : string(__begin, __end) {}
+ MapKey(const_iterator __begin, const_iterator __end) : std::string(__begin, __end) {}
#endif
public:
- MapKey(const MapKey & mk) : string(mk) {}
+ MapKey(const MapKey & mk) : std::string(mk) {}
};
#include "Batch_GenericException.hxx"
+using namespace std;
namespace Batch {
#include "Batch_Versatile.hxx"
#include "Batch_InvalidKeyException.hxx"
#include "Batch_Parametre.hxx"
+using namespace std;
// Definition des membres constants statiques
// Definition des noms globaux pour les clefs en tant que references
#ifndef _PARAMETRE_H_
#define _PARAMETRE_H_
-using namespace std;
#include <map>
#include <string>
#include "Batch_InvalidKeyException.hxx"
// TODO : remplacer ce mecanisme statique par la lecture
// TODO : d'une descrption dans un fichier exterieur (genre XML)
-#define def_extern_MapKey(mk) extern const string & mk;
-#define def_static_MapKey(mk) const string Batch::Parametre::mk(#mk); \
- const string & mk = Batch::Parametre::mk;
+#define def_extern_MapKey(mk) extern const std::string & mk;
+#define def_static_MapKey(mk) const std::string Batch::Parametre::mk(#mk); \
+ const std::string & mk = Batch::Parametre::mk;
namespace Batch {
- class Parametre : public map< string, Versatile >
+ class Parametre : public std::map< std::string, Versatile >
{
public:
// Constructeur standard
Parametre::Parametre(const Parametre & PM);
// Operateur de recherche dans la map
- Versatile & operator [] (const string &);
- const Versatile & operator [] (const string &) const;
+ Versatile & operator [] (const std::string &);
+ const Versatile & operator [] (const std::string &) const;
// Operateur d'affectation
Parametre & operator =(const Parametre & PM);
// Declarations statique des clefs de la map
// TODO : supprimer les declarations statiques des clefs de la map
- static const string ACCOUNT;
- static const string CHECKPOINT;
- static const string CKPTINTERVAL;
- static const string CREATIONTIME;
- static const string EGROUP;
- static const string ELIGIBLETIME;
- static const string EUSER;
- static const string EXECUTABLE;
- static const string EXECUTIONHOST;
- static const string HOLD;
- static const string ID;
- static const string INFILE;
- static const string MAIL;
- static const string MAXCPUTIME;
- static const string MAXDISKSIZE;
- static const string MAXRAMSIZE;
- static const string MAXWALLTIME;
- static const string MODIFICATIONTIME;
- static const string NAME;
- static const string OUTFILE;
- static const string PID;
- static const string QUEUE;
- static const string QUEUEDTIME;
- static const string SERVER;
- static const string STARTDATE;
- static const string STATE;
- static const string TEXT;
- static const string TMPDIR;
- static const string USEDCPUTIME;
- static const string USEDDISKSIZE;
- static const string USEDRAMSIZE;
- static const string USEDWALLTIME;
- static const string USER;
+ static const std::string ACCOUNT;
+ static const std::string CHECKPOINT;
+ static const std::string CKPTINTERVAL;
+ static const std::string CREATIONTIME;
+ static const std::string EGROUP;
+ static const std::string ELIGIBLETIME;
+ static const std::string EUSER;
+ static const std::string EXECUTABLE;
+ static const std::string EXECUTIONHOST;
+ static const std::string HOLD;
+ static const std::string ID;
+ static const std::string INFILE;
+ static const std::string MAIL;
+ static const std::string MAXCPUTIME;
+ static const std::string MAXDISKSIZE;
+ static const std::string MAXRAMSIZE;
+ static const std::string MAXWALLTIME;
+ static const std::string MODIFICATIONTIME;
+ static const std::string NAME;
+ static const std::string OUTFILE;
+ static const std::string PID;
+ static const std::string QUEUE;
+ static const std::string QUEUEDTIME;
+ static const std::string SERVER;
+ static const std::string STARTDATE;
+ static const std::string STATE;
+ static const std::string TEXT;
+ static const std::string TMPDIR;
+ static const std::string USEDCPUTIME;
+ static const std::string USEDDISKSIZE;
+ static const std::string USEDRAMSIZE;
+ static const std::string USEDWALLTIME;
+ static const std::string USER;
protected:
- map< string, TypeParam > TypeMap; // map interne servant a controler le type de la valeur associee a chaque clef
+ std::map< std::string, TypeParam > TypeMap; // map interne servant a controler le type de la valeur associee a chaque clef
private:
#include "Batch_TypeMismatchException.hxx"
#include "Batch_ListIsFullException.hxx"
#include "Batch_InvalidArgumentException.hxx"
+using namespace std;
namespace Batch {
*/
#include "Batch_RunTimeException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- RunTimeException(string ch = "undefined") : GenericException("RunTimeException", ch) {}
+ RunTimeException(std::string ch = "undefined") : GenericException("RunTimeException", ch) {}
};
}
#include <string>
#include "Batch_StringType.hxx"
+using namespace std;
namespace Batch {
#ifndef _STRINGTYPE_H_
#define _STRINGTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
{
public:
// Constructeur
- StringType(const string & s="") : _data(s) {}
+ StringType(const std::string & s="") : _data(s) {}
// Conversion en chaine
- virtual string affiche() const;
- virtual operator string() const;
+ virtual std::string affiche() const;
+ virtual operator std::string() const;
// Operateur d'affectation
- virtual StringType & operator =(string);
+ virtual StringType & operator =(std::string);
// Clone duplique l'objet et en fabrique un nouveau a l'aide de new
// qu'il faudra detruire ensuite manuellement
virtual GenericType * clone() const;
protected:
- string _data;
+ std::string _data;
private:
*/
#include "Batch_TypeMismatchException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- TypeMismatchException(string ch = "undefined") : GenericException("TypeMismatchException", ch) {}
+ TypeMismatchException(std::string ch = "undefined") : GenericException("TypeMismatchException", ch) {}
};
}
#include "Batch_Versatile.hxx"
#include "Batch_TypeMismatchException.hxx"
#include "Batch_ListIsFullException.hxx"
+using namespace std;
namespace Batch {
#ifndef _VERSATILE_H_
#define _VERSATILE_H_
-using namespace std;
#include <iostream>
#include <list>
#include <string>
int maxelem; // le nombre d'elements autorises
} TypeParam;
- class Versatile : public list< GenericType * >
+ class Versatile : public std::list< GenericType * >
{
public:
// Constructeur standard et destructeur
// Constructeur depuis le type de "base"
Versatile(long l) : _discriminator(LONG), _maxsize(1), _name("long") { push_back(new LongType(l)); }
- Versatile(const string & s) : _discriminator(STRING), _maxsize(1), _name("string") { push_back(new StringType(s)); }
+ Versatile(const std::string & s) : _discriminator(STRING), _maxsize(1), _name("string") { push_back(new StringType(s)); }
Versatile(const Couple & c) : _discriminator(COUPLE), _maxsize(1), _name("couple") { push_back(new CoupleType(c)); }
// Operateur d'affectation et de concatenation a partir d'un type de "base"
Versatile & operator = (const long l) throw(TypeMismatchException);
- Versatile & operator = (const string & ch) throw(TypeMismatchException);
- Versatile & operator +=(const string & ch) throw(TypeMismatchException,ListIsFullException);
- Versatile & operator , (const string & ch) throw(TypeMismatchException,ListIsFullException);
+ Versatile & operator = (const std::string & ch) throw(TypeMismatchException);
+ Versatile & operator +=(const std::string & ch) throw(TypeMismatchException,ListIsFullException);
+ Versatile & operator , (const std::string & ch) throw(TypeMismatchException,ListIsFullException);
Versatile & operator = (const Couple & cp) throw(TypeMismatchException);
Versatile & operator +=(const Couple & cp) throw(TypeMismatchException,ListIsFullException);
Versatile & operator , (const Couple & cp) throw(TypeMismatchException,ListIsFullException);
// Conversion de type vers un type de "base"
operator long() const throw(TypeMismatchException);
- operator string() const throw(TypeMismatchException);
+ operator std::string() const throw(TypeMismatchException);
operator Couple() const throw(TypeMismatchException);
- string str() const throw(TypeMismatchException);
+ std::string str() const throw(TypeMismatchException);
// Operateur pour l'affichage sur un stream
- friend ostream & operator << (ostream & os, const Versatile & );
+ friend std::ostream & operator << (std::ostream & os, const Versatile & );
// Positionnement et recuperation du type de l'element interne
void setType(DiscriminatorType) throw(TypeMismatchException);
int getMaxSize() const { return _maxsize; }
// Positionnement et recuperation du nom de l'objet
- string getName() const;
- void setName(const string & name);
+ std::string getName() const;
+ void setName(const std::string & name);
protected:
// Efface tous les elements internes de l'objet
DiscriminatorType _discriminator; // type de l'element interne
int _maxsize; // nombre max d'elements internes
- string _name; // nom de l'objet (sert pour les exceptions)
+ std::string _name; // nom de l'objet (sert pour les exceptions)
private:
#include "CASCatch_SignalsHandler.h"
#include <OSD.hxx>
-
+using namespace std;
CASCatch_SignalsHandler::CASCatch_SignalsHandler(bool theFloatingSignal)
{
#include "MultiCommException.hxx"
+using namespace std;
MultiCommException::MultiCommException(const char *message)
{
#include <string>
-using namespace std;
class MultiCommException {
private:
- string _message;
+ std::string _message;
public:
MultiCommException(const char *message);
const char *what() const;
#include "Receiver.hxx"
#include <string.h>
+using namespace std;
/*!
return a deep copy of the array contained in the servant.
#include "ReceiverFactory.hxx"
#include "Receivers.hxx"
+using namespace std;
#ifdef COMP_CORBA_DOUBLE
#define CorbaDNoCopyReceiver CorbaNCNoCopyReceiver
#include "poa.h"
#include "utilities.h"
+using namespace std;
#define TAILLE_SPLIT 100000
#define TIMEOUT 20
#include "SALOMEMultiComm.hxx"
+using namespace std;
SALOMEMultiComm::SALOMEMultiComm():_type(SALOME::CORBA_)
{
#include "utilities.h"
#include "SenderFactory.hxx"
+using namespace std;
CORBA::ORB_var &getGlobalORB(){
ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
#define TIMEOUT 20
-using namespace std;
/*!
Generic servant class for senders that factorizes all the common methods and attributes necessary to senders.
#include "utilities.h"
#include "SALOMEMultiComm.hxx"
#include "SALOME_Comm_i.hxx"
+using namespace std;
#ifdef COMP_CORBA_DOUBLE
#define SALOME_CorbaDoubleSender SALOME_CorbaDoubleNCSender_i
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_Component_i.hxx"
#include "RegistryConnexion.hxx"
#include "OpUtil.hxx"
#include <dlfcn.h>
#include <cstdlib>
#include "utilities.h"
+using namespace std;
extern bool _Sleeping ;
static Engines_Component_i * theEngines_Component ;
#include <Python.h>
-extern "C" void HandleServerSideSignals(CORBA::ORB_ptr theORB);
-
using namespace std;
+extern "C" void HandleServerSideSignals(CORBA::ORB_ptr theORB);
+
static PyMethodDef MethodPyVoidMethod[] = {{ NULL, NULL }};
int main(int argc, char* argv[])
#include "CASCatch_SignalsHandler.h" // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+using namespace std;
extern "C" void HandleServerSideSignals(CORBA::ORB_ptr theORB)
{
std::map<std::string, void *> remove_map ;
omni_mutex _numInstanceMutex ; // if several threads on the same object
-private:
+ //private:
int _argc ;
char** _argv ;
// File : SALOME_DataTypeCatalog_Client.cxx
// Module : SALOME
-using namespace std;
/* $Header$ */
#include <iostream.h>
#include "SALOME_DataTypeCatalog.hh"
#include <string>
#include "utilities.h"
+using namespace std;
int main(int argc,char **argv)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_DataTypeCatalog_impl.hxx"
#include "Utils_ExceptHandlers.hxx"
#include <fstream>
+using namespace std;
UNEXPECT_CATCH(DTC_NotFound, SALOME_DataTypeCatalog::NotFound);
#include <qapplication.h>
#include <qthread.h>
#include <pthread.h>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
-using namespace std;
// File : SALOMEDS_Tool.cxx
// Created : Mon Oct 21 16:24:34 2002
// Author : Sergey RUIN
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
+using namespace std;
bool CreateAttributeFromASCII(HDFinternalObject *father, FILE* fp);
bool CreateDatasetFromASCII(HDFcontainerObject *father, FILE *fp);
// File : HDFattribute.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include "HDFexception.hxx"
#include "HDFattribute.hxx"
#include "HDFinternalObject.hxx"
+using namespace std;
HDFattribute::HDFattribute(char *name,HDFinternalObject *father,hdf_type type, size_t size)
: HDFobject(name)
// File : HDFcontainerObject.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include "HDFcontainerObject.hxx"
#include "HDFexception.hxx"
#include "utilities.h"
+using namespace std;
HDFcontainerObject::HDFcontainerObject(char *name)
: HDFinternalObject(name)
// File : HDFconvert.cc
// Module : SALOME
-using namespace std;
#include "HDFconvert.hxx"
+using namespace std;
int HDFConvert::FromAscii(const string& file, const HDFcontainerObject & hdf_container, const string& nomdataset)
{
// File : HDFdataset.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include "HDFexception.hxx"
#include <iostream.h>
+using namespace std;
herr_t dataset_attr(hid_t loc_id, const char *attr_name, void *operator_data)
{
// File : HDFexplorer.cc
// Module : SALOME
-using namespace std;
#include "HDFcontainerObject.hxx"
#include "HDFexception.hxx"
#include "HDFinternalObject.hxx"
#include "HDFexplorer.hxx"
+using namespace std;
HDFexplorer::HDFexplorer(HDFcontainerObject *container)
{
// File : HDFfile.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include <iostream.h>
#include "HDFfile.hxx"
#include "HDFexception.hxx"
+using namespace std;
herr_t file_attr(hid_t loc_id, const char *attr_name, void *operator_data)
{
// File : HDFgroup.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
}
#include "HDFgroup.hxx"
#include "HDFexception.hxx"
+using namespace std;
herr_t group_attr(hid_t loc_id, const char *attr_name, void *operator_data)
{
// File : HDFinternalObject.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
}
#include "HDFinternalObject.hxx"
+using namespace std;
HDFinternalObject::HDFinternalObject(char *name)
: HDFobject(name)
// File : HDFobject.cc
// Module : SALOME
-using namespace std;
#include "HDFobject.hxx"
extern "C"
{
#include <string.h>
}
#include "utilities.h"
+using namespace std;
HDFobject::HDFobject(char *name)
{
// File : test3.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test4.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test5.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test6.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
{
// File : test7.cxx
// Module : SALOME
-using namespace std;
#include "HDFIO.hxx"
#include <iostream.h>
+using namespace std;
int main()
{
// File : test8.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test9.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// Module : SALOME
// $Header$
-using namespace std;
#include <iostream>
#include <fstream>
#include <sstream>
#include "SALOME_LifeCycleCORBA.hxx"
#include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog)
#include "SALOME_NamingService.hxx"
+using namespace std;
SALOME_LifeCycleCORBA::SALOME_LifeCycleCORBA()
{
SALOME_NamingService *_NS;
Engines::Container_var _FactoryServer ;
-private:
+ //private:
std::string ContainerName( const char * aComputerContainer ,
std::string * theComputer ,
std::string * theContainer ) ;
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include <iostream>
#include <unistd.h>
#include "SALOME_NamingService.hxx"
#include "SALOME_LifeCycleCORBA.hxx"
#include <OpUtil.hxx>
+using namespace std;
int main (int argc, char * argv[])
{
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "InquireServersQThread.h"
#include "SALOME_NamingService.hxx"
//#include "utilities.h"
#include "OpUtil.hxx"
+using namespace std;
#include CORBA_CLIENT_HEADER(SALOME_Session)
#include CORBA_CLIENT_HEADER(SALOME_Registry)
// Module : SALOME
// $Header$
-using namespace std;
/*! \file SALOME_Session_loader.cxx
*/
#include <qapplication.h>
#include "InquireServersQThread.h"
+using namespace std;
int main(int argc, char **argv)
{
// Author : Vasily Rusyaev
// Module : SALOME
-using namespace std;
#include <iostream>
#include "SALOME_Logger_Server.hxx"
#include <SALOMEconfig.h>
#include <sys/types.h>
#include <unistd.h>
+using namespace std;
+
omni_mutex Logger::myLock;
/////////////////////////////////////////////////////////////////////
// Author : Vasily Rusyaev
// Module : SALOME
-using namespace std;
#include "SALOME_Trace.hxx"
#include <memory.h>
#include <string>
//#include <stdio.h>
#include <stdlib.h>
#include <iostream>
+using namespace std;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
// File : MPIContainer_i.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include <dlfcn.h>
#include <stdio.h>
#include "MPIContainer_i.hxx"
+#include "SALOME_NamingService.hxx"
+#include "Utils_SINGLETON.hxx"
+#include "OpUtil.hxx"
#include "utilities.h"
+using namespace std;
-MPIContainer_i::MPIContainer_i(int nbproc, int numproc,
- CORBA::ORB_ptr orb,
- PortableServer::POA_ptr poa,
- char * containerName)
- : Engines_Container_i(orb,poa,containerName,0,0), MPIObject_i(nbproc,numproc)
+// L'appel au registry SALOME ne se fait que pour le process 0
+Engines_MPIContainer_i::Engines_MPIContainer_i(int nbproc, int numproc,
+ CORBA::ORB_ptr orb,
+ PortableServer::POA_ptr poa,
+ char * containerName,
+ int argc, char *argv[])
+ : Engines_Container_i(orb,poa,containerName,argc,argv,false,false), MPIObject_i(nbproc,numproc)
{
+ MESSAGE("[" << numproc << "] activate object");
_id = _poa->activate_object(this);
- MESSAGE("[" << _numproc << "] containerName=" << _containerName);
- if( _numproc == 0 ){
+ if(numproc==0){
+
+ // _NS = new SALOME_NamingService(_orb);
_NS = SINGLETON_<SALOME_NamingService>::Instance() ;
ASSERT(SINGLETON_<SALOME_NamingService>::IsAlreadyExisting()) ;
_NS->init_orb( orb ) ;
Engines::Container_ptr pCont
= Engines::Container::_narrow(POA_Engines::MPIContainer::_this());
- _NS->Register(pCont, _containerName.c_str());
+ SCRUTE(_containerName);
+ _NS->Register(pCont, _containerName.c_str());
}
// Root recupere les ior des container des autre process
BCastIOR(_orb,pobj,true);
}
-MPIContainer_i::~MPIContainer_i(void)
+Engines_MPIContainer_i::Engines_MPIContainer_i(int nbproc, int numproc)
+ : Engines_Container_i(), MPIObject_i(nbproc,numproc)
+{
+}
+
+Engines_MPIContainer_i::~Engines_MPIContainer_i(void)
{
+ MESSAGE("[" << _numproc << "] Engines_MPIContainer_i::~Engines_MPIContainer_i()");
if( !handle_map.empty() ){
- MESSAGE("[" << _numproc << "] MPIContainer_i::~MPIContainer_i: warning destroy a not empty container");
+ MESSAGE("[" << _numproc << "] Engines_MPIContainer_i::~Engines_MPIContainer_i: warning destroy a not empty container");
}
}
+// Start MPI Container
+Engines::MPIContainer_ptr Engines_MPIContainer_i::start_MPIimpl(
+ const char* ContainerName,
+ CORBA::Short nbproc )
+{
+
+ char nbp[1024];
+
+ MESSAGE("[" << _numproc << "] start_impl argc " << _argc << " ContainerName " << ContainerName
+ << hex << this << dec) ;
+ _numInstanceMutex.lock() ; // lock on the instance number
+
+ CORBA::Object_var obj = Engines::MPIContainer::_nil() ;
+ bool nilvar = true ;
+ try {
+ string cont("/Containers/");
+ cont += machineName() ;
+ cont += "/" ;
+ cont += ContainerName;
+ INFOS("[" << _numproc << "] " << machineName() << " start_impl unknown container " << cont.c_str()
+ << " try to Resolve" );
+ obj = _NS->Resolve( cont.c_str() );
+ nilvar = CORBA::is_nil( obj ) ;
+ if ( nilvar ) {
+ INFOS("[" << _numproc << "] " << machineName() << " start_impl unknown container "
+ << ContainerName);
+ }
+ }
+ catch (ServiceUnreachable&) {
+ INFOS("[" << _numproc << "] " << machineName() << "Caught exception: Naming Service Unreachable");
+ }
+ catch (...) {
+ INFOS("[" << _numproc << "] " << machineName() << "Caught unknown exception.");
+ }
+ if ( !nilvar ) {
+ _numInstanceMutex.unlock() ;
+ MESSAGE("[" << _numproc << "] start_impl container found without new launch") ;
+ return Engines::MPIContainer::_narrow(obj);
+ }
+ int i = 0 ;
+ while ( _argv[ i ] ) {
+ MESSAGE("[" << _numproc << "] argv" << i << " " << _argv[ i ]) ;
+ i++ ;
+ }
+ sprintf(nbp,"mpirun -np %d SALOME_MPIContainer ",nbproc);
+ string shstr(nbp);
+ shstr += ContainerName ;
+ if ( _argc == 4 ) {
+ shstr += " " ;
+ shstr += _argv[ 2 ] ;
+ shstr += " " ;
+ shstr += _argv[ 3 ] ;
+ }
+ shstr += " > /tmp/" ;
+ shstr += ContainerName ;
+ shstr += ".log 2>&1 &" ;
+ MESSAGE("system(" << shstr << ")") ;
+ int status = system( shstr.c_str() ) ;
+ if (status == -1) {
+ INFOS("[" << _numproc << "] Engines_MPIContainer_i::start_impl SALOME_MPIContainer failed (system command status -1)") ;
+ }
+ else if (status == 217) {
+ INFOS("[" << _numproc << "] Engines_MPIContainer_i::start_impl SALOME_MPIContainer failed (system command status 217)") ;
+ }
+ INFOS("[" << _numproc << "] " << machineName() << " Engines_MPIContainer_i::start_impl SALOME_MPIContainer launch done");
+
+ obj = Engines::MPIContainer::_nil() ;
+ try {
+ string cont("/Containers/");
+ cont += machineName() ;
+ cont += "/" ;
+ cont += ContainerName;
+ nilvar = true ;
+ int count = 20 ;
+ while ( nilvar && count >= 0) {
+ sleep( 1 ) ;
+ obj = _NS->Resolve(cont.c_str());
+ nilvar = CORBA::is_nil( obj ) ;
+ if ( nilvar ) {
+ INFOS("[" << _numproc << "] " << count << ". " << machineName()
+ << " start_impl unknown container " << cont.c_str());
+ count -= 1 ;
+ }
+ }
+ _numInstanceMutex.unlock() ;
+ if ( !nilvar ) {
+ MESSAGE("[" << _numproc << "] start_impl container found after new launch of SALOME_MPIContainer") ;
+ }
+ return Engines::MPIContainer::_narrow(obj);
+ }
+ catch (ServiceUnreachable&) {
+ INFOS("[" << _numproc << "] " << machineName() << "Caught exception: Naming Service Unreachable");
+ }
+ catch (...) {
+ INFOS("[" << _numproc << "] " << machineName() << "Caught unknown exception.");
+ }
+ _numInstanceMutex.unlock() ;
+ MESSAGE("[" << _numproc << "] start_impl MPI container not found after new launch of SALOME_MPIContainer") ;
+ return Engines::MPIContainer::_nil() ;
+}
+
// Load component
-Engines::Component_ptr MPIContainer_i::load_impl(const char* nameToRegister,
+Engines::Component_ptr Engines_MPIContainer_i::load_impl(const char* nameToRegister,
const char* componentName)
{
int ip;
- Engines::Component_var iobject;
- Engines::MPIObject_var pobj;
- char cproc[4];
if( _numproc == 0 ){
// Invocation du chargement du composant dans les autres process
for(ip= 1;ip<_nbproc;ip++)
- (Engines::MPIContainer::_narrow((*_tior)[ip]))->load_impl(nameToRegister,
+ (Engines::MPIContainer::_narrow((*_tior)[ip]))->SPload_impl(nameToRegister,
componentName);
}
+ return Lload_impl(nameToRegister,componentName);
+
+}
+
+// Load component
+void Engines_MPIContainer_i::SPload_impl(const char* nameToRegister,
+ const char* componentName)
+{
+ Lload_impl(nameToRegister,componentName);
+}
+
+Engines::Component_ptr Engines_MPIContainer_i::Lload_impl(
+ const char* nameToRegister,
+ const char* componentName)
+{
+ Engines::Component_var iobject;
+ Engines::MPIObject_var pobj;
+ char cproc[4];
+
sprintf(cproc,"_%d",_numproc);
- BEGIN_OF("[" << _numproc << "] MPIContainer_i::load_impl");
+ BEGIN_OF("[" << _numproc << "] MPIContainer_i::Lload_impl");
_numInstanceMutex.lock() ; // lock on the instance number
_numInstance++ ;
char _aNumI[12];
sprintf(_aNumI,"%d",_numInstance) ;
- _numInstanceMutex.unlock() ;
string _impl_name = componentName;
- string instanceName = string(nameToRegister) + "_inst_" + _aNumI + cproc;
+ string _nameToRegister = nameToRegister;
+ string instanceName = _nameToRegister + "_inst_" + _aNumI + cproc;
+ MESSAGE("[" << _numproc << "] instanceName=" << instanceName);
string absolute_impl_name(_impl_name);
MESSAGE("[" << _numproc << "] absolute_impl_name=" << absolute_impl_name);
void * handle = dlopen(absolute_impl_name.c_str(), RTLD_LAZY);
if(!handle){
- MESSAGE("[" << _numproc << "] Can't load shared library : " << absolute_impl_name);
- MESSAGE("[" << _numproc << "] error dlopen: " << dlerror());
+ INFOS("[" << _numproc << "] Can't load shared library : " << absolute_impl_name);
+ INFOS("[" << _numproc << "] error dlopen: " << dlerror());
return Engines::Component::_nil() ;
}
- string factory_name = string(nameToRegister) + string("Engine_factory");
+ string factory_name = _nameToRegister + string("Engine_factory");
MESSAGE("[" << _numproc << "] factory_name=" << factory_name) ;
PortableServer::ObjectId * (*MPIComponent_factory) (int,int,
if ((error = dlerror()) != NULL){
// Try to load a sequential component
MESSAGE("[" << _numproc << "] Try to load a sequential component");
+ _numInstanceMutex.unlock() ;
iobject = Engines_Container_i::load_impl(nameToRegister,componentName);
if( CORBA::is_nil(iobject) ) return Engines::Component::_duplicate(iobject);
}
// Instanciation du composant parallele
MESSAGE("[" << _numproc << "] Try to load a parallel component");
PortableServer::ObjectId * id = (MPIComponent_factory)
- (_nbproc,_numproc,_orb, _poa, _id, instanceName.c_str(), nameToRegister);
+ (_nbproc,_numproc,_orb, _poa, _id, instanceName.c_str(), _nameToRegister.c_str());
// get reference from id
CORBA::Object_var o = _poa->id_to_reference(*id);
pobj = Engines::MPIObject::_narrow(o) ;
- iobject = Engines::Component::_narrow(pobj) ;
+ iobject = Engines::Component::_narrow(o) ;
}
- // Root recupere les ior des composants des autre process
- BCastIOR(_orb,pobj,false);
-
if( _numproc == 0 ){
// utiliser + tard le registry ici :
// register the engine under the name containerName.dir/nameToRegister.object
- string component_registerName = _containerName + "/" + nameToRegister;
+ string component_registerName = _containerName + "/" + _nameToRegister;
_NS->Register(iobject, component_registerName.c_str()) ;
}
- _numInstanceMutex.lock() ; // lock on the add on handle_map (necessary ?)
handle_map[instanceName] = handle;
_numInstanceMutex.unlock() ;
- END_OF("[" <<_numproc << "] MPIContainer_i::load_impl");
+
+ // Root recupere les ior des composants des autre process
+ BCastIOR(_orb,pobj,false);
+
+ END_OF("[" <<_numproc << "] MPIContainer_i::Lload_impl");
return Engines::Component::_duplicate(iobject);
}
-void MPIContainer_i::remove_impl(Engines::Component_ptr component_i)
+void Engines_MPIContainer_i::remove_impl(Engines::Component_ptr component_i)
{
int ip;
Engines::Component_ptr cptr;
for(ip= 1;ip<_nbproc;ip++){
spcptr = Engines::MPIObject::_narrow((*(pcptr->tior()))[ip]);
cptr = (Engines::Component_ptr)spcptr;
- (Engines::MPIContainer::_narrow((*_tior)[ip]))->remove_impl(cptr);
+ (Engines::MPIContainer::_narrow((*_tior)[ip]))->SPremove_impl(cptr);
}
}
+ Lremove_impl(component_i);
+}
+
+void Engines_MPIContainer_i::SPremove_impl(Engines::Component_ptr component_i)
+{
+ Lremove_impl(component_i);
+}
+
+void Engines_MPIContainer_i::Lremove_impl(Engines::Component_ptr component_i)
+{
+ int ip;
+ Engines::Component_ptr cptr;
+ Engines::MPIObject_ptr pcptr;
+ Engines::MPIObject_ptr spcptr;
+
+ BEGIN_OF("[" << _numproc << "] MPIContainer_i::Lremove_impl");
+
+ ASSERT(! CORBA::is_nil(component_i));
+
string instanceName = component_i->instanceName() ;
MESSAGE("[" << _numproc << "] unload component " << instanceName);
component_i->destroy() ;
{
MESSAGE("[" << _numproc << "] stay " << (*im).first);
}
+
+ END_OF("[" << _numproc << "] MPIContainer_i::Lremove_impl");
+
}
-void MPIContainer_i::finalize_removal()
+void Engines_MPIContainer_i::finalize_removal()
{
int ip;
- MESSAGE("[" << _numproc << "] finalize unload : dlclose");
-
if( _numproc == 0 ){
// Invocation de la destruction du composant dans les autres process
for(ip= 1;ip<_nbproc;ip++)
- (Engines::MPIContainer::_narrow((*_tior)[ip]))->finalize_removal();
+ (Engines::MPIContainer::_narrow((*_tior)[ip]))->SPfinalize_removal();
}
+ Lfinalize_removal();
+}
+
+void Engines_MPIContainer_i::SPfinalize_removal()
+{
+ Lfinalize_removal();
+}
+
+void Engines_MPIContainer_i::Lfinalize_removal()
+{
+ BEGIN_OF("[" << _numproc << "] MPIContainer_i::Lfinalize_removal");
+
map<string, void *>::iterator im ;
- _numInstanceMutex.lock() ; // lock on the explore remove_map & dlclose
+ // lock on the explore remove_map & dlclose
+ _numInstanceMutex.lock() ;
for (im = remove_map.begin() ; im != remove_map.end() ; im ++)
{
void * handle = (*im).second ;
- dlclose(handle) ;
MESSAGE("[" << _numproc << "] dlclose " << (*im).first);
+ dlclose(handle) ;
}
+ MESSAGE("[" << _numproc << "] remove_map.clear()");
remove_map.clear() ;
_numInstanceMutex.unlock() ;
- MESSAGE("[" << _numproc << "] remove_map.clear()");
+
+ END_OF("[" << _numproc << "] MPIContainer_i::Lfinalize_removal");
}
#define _SALOME_PCONTAINER_
#include <SALOMEconfig.h>
-#include CORBA_SERVER_HEADER(MPIContainer)
+#include CORBA_SERVER_HEADER(SALOME_MPIContainer)
#include "SALOME_Container_i.hxx"
-#include "SALOME_NamingService.hxx"
-#include "Utils_SINGLETON.hxx"
-#include "OpUtil.hxx"
#include "MPIObject_i.hxx"
-class MPIContainer_i : public POA_Engines::MPIContainer,
- public Engines_Container_i,
- public MPIObject_i
+class Engines_MPIContainer_i : public POA_Engines::MPIContainer,
+ public Engines_Container_i,
+ public MPIObject_i
{
public:
// Constructor
- MPIContainer_i( int nbproc, int numproc,
- CORBA::ORB_ptr orb,
- PortableServer::POA_ptr poa,
- char * containerName);
+ Engines_MPIContainer_i( int nbproc, int numproc,
+ CORBA::ORB_ptr orb,
+ PortableServer::POA_ptr poa,
+ char * containerName,
+ int argc, char *argv[]);
+ Engines_MPIContainer_i(int nbproc, int numproc);
// Destructor
- ~MPIContainer_i();
+ ~Engines_MPIContainer_i();
- // Load a component
+ // Launch a new MPI container from the current container
+ Engines::MPIContainer_ptr start_MPIimpl(const char* ContainerName,
+ CORBA::Short nbproc);
+
+ // Load a component in current MPI container
+ // synchronous version for process 0
Engines::Component_ptr load_impl(const char* nameToRegister,
const char* componentName);
+ // asynchronous version for other process
+ void SPload_impl(const char* nameToRegister, const char* componentName);
- // Unload a component
+ // Unload a component from current MPI container
+ // synchronous version for process 0
void remove_impl(Engines::Component_ptr component_i);
+ // asynchronous version for other process
+ void SPremove_impl(Engines::Component_ptr component_i);
+
+ // synchronous version for process 0
void finalize_removal();
+ // asynchronous version for other process
+ void SPfinalize_removal();
+
+ private:
+ // local version to not duplicate code
+ // called by synchronous and asynchronous version
+ Engines::Component_ptr Lload_impl(const char* nameToRegister,
+ const char* componentName);
+ void Lremove_impl(Engines::Component_ptr component_i);
+ void Lfinalize_removal();
};
#endif
// File : MPIObject_i.cxx
// Module : SALOME
-using namespace std;
#include "MPIObject_i.hxx"
#include "utilities.h"
#include <mpi.h>
+using namespace std;
MPIObject_i::MPIObject_i()
{
- _nbproc = 1;
- _numproc = 0;
+ MPI_Comm_size( MPI_COMM_WORLD, &_nbproc );
+ MPI_Comm_rank( MPI_COMM_WORLD, &_numproc );
_tior=NULL;
}
Engines::IORTab* MPIObject_i::tior()
{
- Engines::IORTab* tior = new Engines::IORTab;
+ Engines::IORTab_var tior = new Engines::IORTab;
tior->length(_tior->length());
for(unsigned int ip=0;ip<tior->length();ip++)
- (*tior)[ip] = (*_tior)[ip];
- return tior;
+ tior[ip] = (*_tior)[ip];
+ return tior._retn();
};
void MPIObject_i::tior(const Engines::IORTab& ior)
(*_tior)[ip] = ior[ip];
}
-void MPIObject_i::BCastIOR(CORBA::ORB_ptr orb, Engines::MPIObject_var pobj,
+void MPIObject_i::BCastIOR(CORBA::ORB_ptr orb, Engines::MPIObject_ptr pobj,
bool amiCont)
{
int err, ip, n;
char *ior;
MPI_Status status; /* status de reception de message MPI */
- // Conversion IOR vers string
- CORBA::String_var sior(orb->object_to_string(pobj));
-
if( _numproc == 0 ){
//Allocation du tableau des IOR
- Engines::IORTab *iort = new Engines::IORTab;
+ Engines::IORTab_var iort = new Engines::IORTab;
iort->length(_nbproc);
- (*iort)[0] = pobj;
+ iort[0] = pobj;
// Process 0 recupere les ior de l'object sur les autres process
for(ip=1;ip<_nbproc;ip++){
exit(1);
}
// Allocation de la chaine de longueur n
- ior = (char*)calloc(n,sizeof(char));
+ ior = new char[n];
err = MPI_Recv(ior,n,MPI_CHAR,ip,2*ip,MPI_COMM_WORLD,&status);
if(err){
MESSAGE("[" << _numproc << "] MPI_RECV error");
exit(1);
}
- (*iort)[ip] = Engines::MPIObject::_narrow(orb->string_to_object(ior));
- free(ior);
+ iort[ip] = orb->string_to_object(ior);
+ delete [] ior;
}
// On donne le tableau des ior a l'objet Corba du process 0
if( amiCont )
- tior(*iort);
+ tior(*(iort._retn()));
else
- pobj->tior(*iort);
+ pobj->tior(*(iort._retn()));
}
else{
+ // Conversion IOR vers string
+ ior = orb->object_to_string(pobj);
+ n = strlen(ior) + 1;
// On envoie l'IOR au process 0
- n = strlen((char*)sior);
err = MPI_Send(&n,1,MPI_INT,0,_numproc,MPI_COMM_WORLD);
if(err){
MESSAGE("[" << _numproc << "] MPI_SEND error");
exit(1);
}
- err = MPI_Send((char*)sior,n,MPI_CHAR,0,2*_numproc,MPI_COMM_WORLD);
+ err = MPI_Send(ior,n,MPI_CHAR,0,2*_numproc,MPI_COMM_WORLD);
if(err){
MESSAGE("[" << _numproc << "] MPI_SEND error");
exit(1);
}
+ CORBA::string_free(ior);
}
}
#define _SALOME_POBJECT_I_H_
#include <SALOMEconfig.h>
-#include CORBA_SERVER_HEADER(MPIObject)
+#include CORBA_SERVER_HEADER(SALOME_MPIObject)
class MPIObject_i: public POA_Engines::MPIObject
{
// IOR des objets paralleles sur tous les process mpi
Engines::IORTab* _tior;
// Echange des IOR de l'objet entre process
- void BCastIOR(CORBA::ORB_ptr orb,Engines::MPIObject_var pobj,bool amiCont);
+ void BCastIOR(CORBA::ORB_ptr orb,Engines::MPIObject_ptr pobj,bool amiCont);
} ;
#endif
LIB = libSalomeMPIContainer.la
LIB_SRC = MPIObject_i.cxx MPIContainer_i.cxx
-LIB_SERVER_IDL = TypeData.idl MPIObject.idl MPIContainer.idl
+LIB_SERVER_IDL = SALOME_MPIObject.idl SALOME_MPIContainer.idl
# Executables targets
BIN = SALOME_MPIContainer
BIN_SRC =
-BIN_SERVER_IDL = TypeData.idl MPIObject.idl MPIContainer.idl
+BIN_SERVER_IDL = SALOME_MPIObject.idl SALOME_MPIContainer.idl
-CXXFLAGS+=${MPI_INCLUDES}
-CXX_DEPEND_FLAG+=${MPI_INCLUDES}
-LDFLAGS+= -lSalomeContainer -lSalomeNS -lRegistry -lOpUtil ${MPI_LIBS}
+LDFLAGS+= -lSalomeContainer -lSalomeNS -lRegistry -lOpUtil -lSalomeNotification -lSALOMELocalTrace
+
+ifeq (@WITHMPI@,yes)
+ CXXFLAGS+=${MPI_INCLUDES}
+ CXX_DEPEND_FLAG+=${MPI_INCLUDES}
+ LDFLAGS+= ${MPI_LIBS}
+endif
@CONCLUDE@
-// SALOME MPIContainer : implemenation of container based on MPI libraries
-//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-//
-//
-//
-// File : SALOME_MPIContainer.cxx
-// Module : SALOME
-
-using namespace std;
#include <iostream>
#include "MPIContainer_i.hxx"
+#include "Utils_ORB_INIT.hxx"
+#include "Utils_SINGLETON.hxx"
#include "utilities.h"
-#include "LocalTraceCollector.hxx"
#include <mpi.h>
+using namespace std;
int main(int argc, char* argv[])
{
- LocalTraceCollector *myThreadTrace = LocalTraceCollector::instance();
int nbproc, numproc;
- MPIContainer_i * myContainer;
+ int flag;
+ Engines_MPIContainer_i * myContainer=NULL;
BEGIN_OF(argv[0])
try {
MESSAGE("Connection MPI");
-
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&nbproc);
MPI_Comm_rank(MPI_COMM_WORLD,&numproc);
- MESSAGE("Initialisation CORBA");
+ MESSAGE("[" << numproc << "] Initialisation CORBA");
// Initialise the ORB.
- CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
+ // CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
+ ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
+ ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting()) ;
+ CORBA::ORB_var &orb = init( argc , argv ) ;
// Obtain a reference to the root POA.
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
containerName = argv[1] ;
}
- MESSAGE("Chargement container sur proc: " << numproc);
- myContainer = new MPIContainer_i(nbproc,numproc,orb,factory_poa, containerName);
- MESSAGE("Fin chargement container");
+ MESSAGE("[" << numproc << "] Chargement container");
+ myContainer = new Engines_MPIContainer_i(nbproc,numproc,orb,factory_poa, containerName,argc,argv);
pman->activate();
orb->run();
orb->destroy();
- delete myContainer;
- MPI_Finalize();
}
- catch(CORBA::SystemException&) {
- INFOS("Caught CORBA::SystemException.")
+ catch(CORBA::SystemException&){
+ INFOS("Caught CORBA::SystemException.");
}
- catch(PortableServer::POA::WrongPolicy&)
- {
- INFOS("Caught CORBA::WrongPolicyException.")
+ catch(PortableServer::POA::WrongPolicy&){
+ INFOS("Caught CORBA::WrongPolicyException.");
}
- catch(PortableServer::POA::ServantAlreadyActive&)
- {
- INFOS("Caught CORBA::ServantAlreadyActiveException")
+ catch(PortableServer::POA::ServantAlreadyActive&){
+ INFOS("Caught CORBA::ServantAlreadyActiveException");
}
- catch(CORBA::Exception&) {
- INFOS("Caught CORBA::Exception.")
+ catch(CORBA::Exception&){
+ INFOS("Caught CORBA::Exception.");
}
- catch(...) {
- INFOS("Caught unknown exception.")
- }
+ catch(...){
+ INFOS("Caught unknown exception.");
+ }
+
+ if(myContainer)
+ delete myContainer;
+ MPI_Initialized(&flag);
+ if(flag)
+ MPI_Finalize();
+
END_OF(argv[0]);
- delete myThreadTrace;
- return 0;
}
}
Engines::MPIContainer_var SALOME_MPILifeCycleCORBA::FindOrStartMPIContainer(
- const string theComputer ,
- const string theMPIContainerRoot,
+ const std::string theComputer ,
+ const std::string theMPIContainerRoot,
const int nbproc)
{
char nbp[1024];
sprintf(nbp,"_%d",nbproc);
- string theMPIContainer = theMPIContainerRoot + nbp;
- string aComputerContainer = theComputer + "/" + theMPIContainer;
+ std::string theMPIContainer = theMPIContainerRoot + nbp;
+ std::string aComputerContainer = theComputer + "/" + theMPIContainer;
SCRUTE( aComputerContainer ) ;
SCRUTE( theComputer ) ;
if ( !strcmp( &theMPIContainerRoot.c_str()[len-2] , "Py" ) ) {
pyCont = true ;
}
- string MPIFactoryServer = theComputer ;
+ std::string MPIFactoryServer = theComputer ;
if ( pyCont ) {
MPIFactoryServer += "/MPIFactoryServerPy" ;
}
// On n'a pas trouve le container generique: on lance le container demande
if ( CORBA::is_nil( aMPIFactoryServer ) ) {
// rsh -n ikkyo /export/home/rahuel/SALOME_ROOT/bin/runSession SALOME_Container -ORBInitRef NameService=corbaname::dm2s0017:1515 &
- string rsh( "" ) ;
+ std::string rsh( "" ) ;
if ( theComputer!= GetHostname() ) {
rsh += "rsh -n " ;
rsh += theComputer ;
rsh += " " ;
}
- string path = ComputerPath( theComputer.c_str() ) ;
+ std::string path = ComputerPath( theComputer.c_str() ) ;
SCRUTE( path ) ;
// rsh += "runSession " ;
if ( pyCont ) {
rsh += nbp;
rsh += theMPIContainer +" -" ;
}
- string omniORBcfg( getenv( "OMNIORB_CONFIG" ) ) ;
+ std::string omniORBcfg( getenv( "OMNIORB_CONFIG" ) ) ;
ifstream omniORBfile( omniORBcfg.c_str() ) ;
char ORBInitRef[12] ;
char nameservice[132] ;
Engines::MPIContainer_var _MPIFactoryServer ;
private:
- Engines::MPIContainer_var FindOrStartMPIContainer(const string theComputer ,
- const string theMPIContainerRoot,
+ Engines::MPIContainer_var FindOrStartMPIContainer(const std::string theComputer ,
+ const std::string theMPIContainerRoot,
const int nbproc) ;
} ;
#include "SALOME_NamingService.hxx"
#include "SALOME_MPILifeCycleCORBA.hxx"
#include "OpUtil.hxx"
+using namespace std;
int main (int argc, char * argv[])
{
**
*****************************************************************************/
-using namespace std;
#include <qfile.h>
#include <qtextstream.h>
#include <qtextcodec.h>
#include <stdio.h>
#include <stdlib.h>
+using namespace std;
static QString* defaultScope = 0;
RegistryDisplay ModuleGenerator SALOME_PYQT Loader Communication
ifeq (@mpi_ok@,yes)
- SUBDIRS+= MPIContainer
+ SUBDIRS+= MPIContainer MPILifeCycleCORBA TestMPIContainer
endif
ifeq (@WITHOPENPBS@,yes)
#include "utilities.h"
#include <sstream>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
// Author : Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION_Swig.hxx"
+using namespace std;
// Swig notification supplier
// --------------------------
// Author : Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
class NOTIFICATION_Supplier_Swig {
// File : ServiceUnreachable.cxx
// Module : SALOME
-using namespace std;
#include "ServiceUnreachable.hxx"
+using namespace std;
ServiceUnreachable::ServiceUnreachable( void ): SALOME_Exception( "ServiceUnreachable" )
{
// Author : Laurent DADA / Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
-using namespace std;
#include "Utils_ORB_INIT.hxx"
#include "Utils_SINGLETON.hxx"
+using namespace std;
CosNA_EventChannel_ptr NOTIFICATION_channel() {
ORB_INIT& init = *SINGLETON_<ORB_INIT>::Instance(); ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
// Author : Laurent DADA / Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
+using namespace std;
NOTIFICATION_Consumer::NOTIFICATION_Consumer():
proxy_supplier(0),
// Author : Laurent DADA / Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
+using namespace std;
long NOTIFICATION_Supplier::_stamp = 0;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_AISObject.ixx"
+using namespace std;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_AISShape.ixx"
+using namespace std;
SALOME_AISShape::SALOME_AISShape(const TopoDS_Shape& shape): AIS_Shape(shape) {
}
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class SALOME_InteractiveObject SALOME_InteractiveObject.hxx
\brief ...
*/
#include "SALOME_InteractiveObject.ixx"
+using namespace std;
SALOME_InteractiveObject::SALOME_InteractiveObject()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer.h"
#include "OCCViewer_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* OCCViewer::createView(QAD_RightFrame* parent)
{
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class OCCViewer_AISSelector OCCViewer_AISSelector.h
\brief Selector for AIS interactive context.
*/
#include "OCCViewer_AISSelector.h"
+using namespace std;
/*!
Constructor
// $Header$
#include "OCCViewer_Prs.h"
+using namespace std;
//==========================================================
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer_VService.h"
// Open CASCADE Includes
#include <Xdps_Driver.hxx>
#include <Xw_TypeOfMapping.hxx>
#endif
+using namespace std;
// For 2d
#define LOPTIM
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer_ViewFrame.h"
#include "OCCViewer_Viewer3d.h"
#include "OCCViewer_ViewPort.h"
#include <V3d_View.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
#include <Visual3d_View.hxx>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer_ViewPort3d.h"
#include "QAD.h"
#if !defined WNT
#include <Xw.hxx>
#endif
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class OCCViewer_Viewer3d OCCViewer_Viewer3d.h
\brief Open CASCADE Viewer 3D with viewport 3D and selection.
#include <TColStd_IndexedMapOfInteger.hxx>
#include <NCollection_DefineBaseCollection.hxx>
#include <NCollection_DefineDataMap.hxx>
+using namespace std;
DEFINE_BASECOLLECTION( OCCViewer_CollectionOfIndexedMapOfShapes, TopTools_IndexedMapOfShape )
DEFINE_DATAMAP( OCCViewer_MapOfIOIndexedMapOfShape, OCCViewer_CollectionOfIndexedMapOfShapes, Handle_SALOME_InteractiveObject, TopTools_IndexedMapOfShape)
**
**********************************************************************/
-using namespace std;
#include "qsplitterP.h"
#ifndef QT_NO_COMPLEXWIDGETS
#include <qobjectlist.h>
#include <qapplication.h> //sendPostedEvents
+using namespace std;
#define SPLITTER_ICON_WIDTH 10
#define SPLITTER_ICON_HEIGHT 12
**
**********************************************************************/
-using namespace std;
#include "qworkspaceP.h"
#include <qapplication.h>
#include <private/qapplication_p.h>
#include <private/qinternal_p.h>
+using namespace std;
#define BUTTON_WIDTH 16
#define BUTTON_HEIGHT 14
#include "Plot2d.h"
#include "Plot2d_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* Plot2d::createView(QAD_RightFrame* parent)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "Plot2d_Curve.h"
#include "utilities.h"
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "Plot2d_CurveContainer.h"
+using namespace std;
/*!
Constructor
#include "QAD_Tools.h"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
+using namespace std;
#define SPACING_SIZE 6
#define MARGIN_SIZE 11
// $Header$
#include "Plot2d_Prs.h"
+using namespace std;
//==========================================================
/*!
#include <qlabel.h>
#include <qpushbutton.h>
#include <qcolordialog.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SALOMEDS)
#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
+using namespace std;
#define DEFAULT_LINE_WIDTH 0 // (default) line width
#define DEFAULT_MARKER_SIZE 9 // default marker size
// Module : SALOME
// $Header$
-using namespace std;
-using namespace std;
# include "Utils_ORB_INIT.hxx"
# include "RegistryConnexion.hxx"
# include "SALOME_NamingService.hxx"
{
# include <stdio.h>
}
+using namespace std;
Registry::Components_var Connexion( int argc , char **argv , const char *ptrSessionName ) throw( CommException )
protected :
const char* _Ior ; // engine ior
Registry::Components_var _VarComponents ; // RegistryService reference
- string _SessionName ;
- string _Name ; // code name
+ std::string _SessionName ;
+ std::string _Name ; // code name
int _Id ; // code identity returned by RegistryService
void add( const char *aName );
void remove( void );
// Module : SALOME
// $Header$
-using namespace std;
-using namespace std;
# include "RegistryService.hxx"
# include "OpUtil.hxx"
# include "utilities.h"
}
#include <unistd.h>
+using namespace std;
/* ------------------------------*/
/* Constructeurs et Destructeurs */
# include <map>
-using namespace std;
class RegistryService : public POA_Registry::Components //, public PortableServer::RefCountServantBase
{
const char *_SessionName ;
int _Compteur ;
- map<int,client_infos *> _reg ;
- map<int,client_infos *> _fin ;
+ std::map<int,client_infos *> _reg ;
+ std::map<int,client_infos *> _fin ;
- Registry::AllInfos* makeseq(map<int,client_infos *> &mymap );
+ Registry::AllInfos* makeseq(std::map<int,client_infos *> &mymap );
} ;
// Module : SALOME
// $Header$
-using namespace std;
# include "HelpWindow.hxx"
# include "utilities.h"
# include <qpushbutton.h>
# include <qtextstream.h>
# include <qfile.h>
+using namespace std;
HelpWindow::HelpWindow(QWidget* parent, const char* name )
: QMainWindow( parent, name, WType_TopLevel | WDestructiveClose )
#include <qpushbutton.h>
#include <qlayout.h>
# include "utilities.h"
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
# include <qpushbutton.h>
# include <qspinbox.h>
-using namespace std;
class IntervalWindow : public QDialog
{
// Module : SALOME
// $Header$
-using namespace std;
# include <qpushbutton.h>
# include <qlistview.h>
# include <qtabwidget.h>
# include "RegWidget.hxx"
# include "HelpWindow.hxx"
# include "IntervalWindow.hxx"
+using namespace std;
typedef int PIXELS;
RegWidget* RegWidget::myRegWidgetPtr = 0;
// Module : SALOME
// $Header$
-using namespace std;
# include "RegWidget.hxx"
# include "utilities.h"
+using namespace std;
extern "C"
{
// File : SALOME_RessourcesCatalog_Client.cxx
// Module : SALOME
-using namespace std;
/* $Header$ */
#include <iostream.h>
#include CORBA_SERVER_HEADER(SALOME_RessourcesCatalog)
#include <string>
#include "utilities.h"
+using namespace std;
int main(int argc,char **argv)
{
// Author : Estelle Deville
// Module : SALOME
-using namespace std;
#include "SALOME_RessourcesCatalog_impl.hxx"
#include <fstream>
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(RC_NotFound, SALOME_RessourcesCatalog::NotFound);
//----------------------------------------------------------------------
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttLong_i.hxx"
#include "utilities.h"
#include <TDF_Tool.hxx>
#include <stdio.h>
+using namespace std;
//============================================================================
/*! Function : Set
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttReal_i.hxx"
#include "utilities.h"
#include <TDF_Tool.hxx>
#include <stdio.h>
#include <cstring>
+using namespace std;
//============================================================================
/*! Function : Set
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeComment_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeComment_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeDrawable_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeDrawable_i::IsDrawable() {
return (Handle(SALOMEDS_DrawableAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeExpandable_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeExpandable_i::IsExpandable() {
return (Handle(SALOMEDS_ExpandableAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeExternalFileDef_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeExternalFileDef_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeFileType_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeFileType_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeIOR_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
#include "SALOMEDS_Study_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeIOR_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeInteger_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Long SALOMEDS_AttributeInteger_i::Value() {
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeLocalID_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Long SALOMEDS_AttributeLocalID_i::Value() {
return Handle(SALOMEDS_LocalIDAttribute)::DownCast(_myAttr)->Get();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeName_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeName_i::Value() {
TCollection_ExtendedString S = Handle(TDataStd_Name)::DownCast(_myAttr)->Get();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeOpened_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeOpened_i::IsOpened() {
return (Handle(SALOMEDS_OpenedAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributePersistentRef_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributePersistentRef_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributePixMap_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TCollection_AsciiString.hxx>
+using namespace std;
CORBA::Boolean SALOMEDS_AttributePixMap_i::HasPixMap() {
TCollection_ExtendedString S = Handle(SALOMEDS_PixMapAttribute)::DownCast(_myAttr)->Get();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributePythonObject_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include <TColStd_HArray1OfCharacter.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
void SALOMEDS_AttributePythonObject_i::SetObject(const char* theSequence, CORBA::Boolean IsScript) {
CheckLocked();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeSelectable_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeSelectable_i::IsSelectable() {
return (Handle(SALOMEDS_SelectableAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeSequenceOfInteger_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfInteger.hxx>
+using namespace std;
void SALOMEDS_AttributeSequenceOfInteger_i::Assign(const SALOMEDS::LongSeq& other)
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeSequenceOfReal_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfReal.hxx>
+using namespace std;
void SALOMEDS_AttributeSequenceOfReal_i::Assign(const SALOMEDS::DoubleSeq& other)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeStudyProperties_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfExtendedString.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
+using namespace std;
#define CREATION_MODE_NOTDEFINED 0
#define CREATION_MODE_SCRATCH 1
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTableOfInteger_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfInteger.hxx>
#include <stdexcept>
#include <strstream>
#include <string>
+using namespace std;
#define SEPARATOR '\1'
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTableOfReal_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfReal.hxx>
#include <string>
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(ATR_IncorrectIndex, SALOMEDS::AttributeTableOfReal::IncorrectIndex);
UNEXPECT_CATCH(ATR_IncorrectArgumentLength, SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength);
// Author : Sergey Ruin
// Module : SALOME
-using namespace std;
#include <TCollection_ExtendedString.hxx>
#include <TCollection_AsciiString.hxx>
#include <string>
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(ATS_IncorrectIndex, SALOMEDS::AttributeTableOfString::IncorrectIndex);
UNEXPECT_CATCH(ATS_IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectArgumentLength);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTarget_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TDF_LabelList.hxx>
#include <TDF_ListIteratorOfLabelList.hxx>
+using namespace std;
void SALOMEDS_AttributeTarget_i::Add(SALOMEDS::SObject_ptr anObject) {
TDF_Label aLabel;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTextColor_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HArray1OfReal.hxx>
+using namespace std;
SALOMEDS::Color SALOMEDS_AttributeTextColor_i::TextColor() {
SALOMEDS::Color TextColor;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTextHighlightColor_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HArray1OfReal.hxx>
+using namespace std;
SALOMEDS::Color SALOMEDS_AttributeTextHighlightColor_i::TextHighlightColor() {
SALOMEDS::Color TextHighlightColor;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTreeNode_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include "utilities.h"
#include <TDocStd_Document.hxx>
#include <TDF_Tool.hxx>
+using namespace std;
static Handle(TDataStd_TreeNode) GetNode(SALOMEDS::AttributeTreeNode_ptr value,
const Handle(TDataStd_TreeNode)& aNode) {
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeUserID_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeUserID_i::Value() {
char aGUID[40];
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_BasicAttributeFactory.hxx"
#include "utilities.h"
+using namespace std;
//============================================================================
/*! Function : Create
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_BasicAttribute_i.hxx"
+using namespace std;
//============================================================================
/*! Function : SetLabel
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_ChildIterator_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include "utilities.h"
+using namespace std;
#ifndef _SALOMEDS_DataMapNodeOfDataMapOfIntegerString_HeaderFile
#include <SALOMEDS_DataMapNodeOfDataMapOfIntegerString.hxx>
#endif
+using namespace std;
#define TheKey Standard_Real
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DataMapIteratorOfDataMapStringLabel.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOMEDS_DataMapNodeOfDataMapStringLabel_HeaderFile
#include "SALOMEDS_DataMapNodeOfDataMapStringLabel.hxx"
#endif
-
+ using namespace std;
+
#define TheKey TCollection_ExtendedString
#define TheKey_hxx <TCollection_ExtendedString.hxx>
#ifndef _SALOMEDS_DataMapIteratorOfDataMapOfIntegerString_HeaderFile
#include <SALOMEDS_DataMapIteratorOfDataMapOfIntegerString.hxx>
#endif
+using namespace std;
SALOMEDS_DataMapNodeOfDataMapOfIntegerString::~SALOMEDS_DataMapNodeOfDataMapOfIntegerString() {}
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DataMapNodeOfDataMapStringLabel.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOMEDS_DataMapIteratorOfDataMapStringLabel_HeaderFile
#include "SALOMEDS_DataMapIteratorOfDataMapStringLabel.hxx"
#endif
+using namespace std;
SALOMEDS_DataMapNodeOfDataMapStringLabel::~SALOMEDS_DataMapNodeOfDataMapStringLabel() {}
#ifndef _SALOMEDS_DataMapIteratorOfDataMapOfIntegerString_HeaderFile
#include <SALOMEDS_DataMapIteratorOfDataMapOfIntegerString.hxx>
#endif
-
+ using namespace std;
+
#define TheKey Standard_Real
#define TheKey_hxx <Standard_Real.hxx>
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DataMapStringLabel.hxx"
#ifndef _Standard_DomainError_HeaderFile
#ifndef _SALOMEDS_DataMapIteratorOfDataMapStringLabel_HeaderFile
#include "SALOMEDS_DataMapIteratorOfDataMapStringLabel.hxx"
#endif
-
+ using namespace std;
+
#define TheKey TCollection_ExtendedString
#define TheKey_hxx <TCollection_ExtendedString.hxx>
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DrawableAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_ExpandableAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include <TDataStd_TreeNode.hxx>
#include <TDataStd_UAttribute.hxx>
#include "SALOMEDS_ExternalFileDef.hxx"
#include "SALOMEDS_FileType.hxx"
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
#define RegisteredAttributes 26
UNEXPECT_CATCH(GALockProtection, SALOMEDS::GenericAttribute::LockProtection);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_IORAttribute.ixx"
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_Study_i.hxx"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_LocalIDAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_OCAFApplication.ixx"
+using namespace std;
//=======================================================================
//function : SALOMEDS_OCAFApplication
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_OpenedAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_PersRefAttribute.ixx"
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_PixMapAttribute.ixx"
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_PythonObjectAttribute.ixx"
#include <string>
+using namespace std;
const Standard_GUID& SALOMEDS_PythonObjectAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SComponentIterator_i.hxx"
+using namespace std;
//============================================================================
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SComponent_i.hxx"
#include "utilities.h"
+using namespace std;
//============================================================================
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOMEDS_SObject_i.hxx"
//SALOMEDS Headers
#include "SALOMEDS_GenericAttribute_i.hxx"
#include "SALOMEDS_IORAttribute.hxx"
#include <TDF_AttributeIterator.hxx>
+using namespace std;
//============================================================================
/*! Function : constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SelectableAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SequenceOfIntegerAttribute.ixx"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SequenceOfRealAttribute.ixx"
#include <TDataStd_Real.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOMEDS_Study_i.hxx"
//#include "SALOMEDS_StudyBuilder_i.hxx"
#include <HDFOI.hxx>
#include <stdlib.h>
+using namespace std;
#define USE_CASE_LABEL_TAG 2
#define DIRECTORYID 16661
#include "Utils_CorbaException.hxx"
#include <strstream>
-using namespace std;
#include "SALOME_GenericObj_i.hh"
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(SalomeException,SALOME::SALOME_Exception);
UNEXPECT_CATCH(LockProtection, SALOMEDS::StudyBuilder::LockProtection);
// Module : SALOME
// $Header$
-using namespace std;
#include <SALOMEDS_StudyPropertiesAttribute.ixx>
+using namespace std;
const Standard_GUID& SALOMEDS_StudyPropertiesAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOMEDS_Study_i.hxx"
#include "SALOMEDS_LocalIDAttribute.hxx"
#include "SALOMEDS_PersRefAttribute.hxx"
#include "SALOMEDS_UseCaseIterator_i.hxx"
+using namespace std;
#define DIRECTORYID 16661
// Module : SALOME
// $Header$
-using namespace std;
#include <SALOMEDS_TableOfIntegerAttribute.ixx>
#include <Standard_Failure.hxx>
#include <TColStd_DataMapIteratorOfDataMapOfIntegerInteger.hxx>
#include <string>
+using namespace std;
const Standard_GUID& SALOMEDS_TableOfIntegerAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include <SALOMEDS_TableOfRealAttribute.ixx>
#include <Standard_Failure.hxx>
#include <TColStd_DataMapIteratorOfDataMapOfIntegerReal.hxx>
#include <string>
#include <stdio.h>
+using namespace std;
const Standard_GUID& SALOMEDS_TableOfRealAttribute::GetID()
{
// Author : Sergey Ruin
// Module : SALOME
-using namespace std;
#include <SALOMEDS_TableOfStringAttribute.ixx>
#include <Standard_Failure.hxx>
#include <SALOMEDS_DataMapIteratorOfDataMapOfIntegerString.hxx>
#include <string>
#include <stdio.h>
+using namespace std;
const Standard_GUID& SALOMEDS_TableOfStringAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_TargetAttribute.ixx"
#include <TDF_Reference.hxx>
#include <TDF_ListIteratorOfAttributeList.hxx>
#include "utilities.h"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_TextColorAttribute.ixx"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_TextHighlightColorAttribute.ixx"
+using namespace std;
//=======================================================================
//function : GetID
// Author : Yves FRICAUD
// Module : SALOME
-using namespace std;
#include "SALOMEDS_UseCaseBuilder_i.hxx"
#include "SALOMEDS_AttributeComment_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TDataStd_ChildNodeIterator.hxx>
#include <TCollection_AsciiString.hxx>
#include <TDF_ChildIterator.hxx>
+using namespace std;
#define USE_CASE_LABEL_TAG 2
#define USE_CASE_GUID "AA43BB12-D9CD-11d6-945D-0050DA506788"
// Author : Yves FRICAUD
// Module : SALOME
-using namespace std;
#include "SALOMEDS_UseCaseIterator_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include "utilities.h"
+using namespace std;
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Application QAD_Application.h
\brief Study manager for QAD-based application.
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <Standard_Failure.hxx>
+using namespace std;
static bool checkPermission(QString fileName) {
if ( QFile::exists( fileName ) ) {
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Config QAD_Config.h
\brief Settings file management for QAD-based application.
#include <qfile.h>
#include <qregexp.h>
#include <qtextstream.h>
+using namespace std;
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_DirListDlg.h"
#include "QAD_Desktop.h"
#include "QAD_FileDlg.h"
#include <qlabel.h>
#include <qpushbutton.h>
#include <qapplication.h>
+using namespace std;
#define MIN_WIDTH 400
#define MIN_HEIGHT 200
// Module : SALOME
// $Header$
-using namespace std;
#include <qapplication.h>
#include <qdir.h>
#include <qlabel.h>
#include "QAD_FileDlg.h"
#include "QAD_MessageBox.h"
#include "QAD_Tools.h"
+using namespace std;
#define MIN_COMBO_SIZE 100
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Help.h"
+using namespace std;
/*!
\class QAD_Help QAD_HelpL.h
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_HelpWindow QAD_HelpWindow.h
\brief Html browser for help.
#include <qtoolbutton.h>
#include <qcombobox.h>
#include <qfileinfo.h>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_LeftFrame.h"
#include "QAD_ObjectBrowser.h"
#include <qlayout.h>
+using namespace std;
/*!
\class QAD_LeftFrame QAD_LeftFrame.h
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ListMenuIdAction.h"
+using namespace std;
QAD_ListMenuIdAction::QAD_ListMenuIdAction(QPopupMenu* theMenu,
int id,
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ListPopupMenu.h"
+using namespace std;
/*!
Constructor.
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Menus.h"
+using namespace std;
/*!
Constructor.
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Message.h"
#include "QAD_Application.h"
#include "QAD_Config.h"
#include <qstring.h>
#include <qpopupmenu.h>
#include <qmap.h>
+using namespace std;
enum { IdCopy, IdClear, IdSelectAll };
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_MessageBox QAD_MessageBox.h
\brief Message dialog box for QAD-based application.
// QT Includes
#include <qmessagebox.h>
#include <qapplication.h>
+using namespace std;
/*!
Shows info message box with one button [ static ]
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_NameBrowser.h"
#include "QAD_Study.h"
#include <qvariant.h>
#include <qtooltip.h>
#include <qwhatsthis.h>
+using namespace std;
/*!
Constructs a QAD_NameBrowser which is a child of 'parent', with the
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ObjectBrowserItem.h"
#include <qcolor.h>
#include <qpixmap.h>
#include <qstringlist.h>
#include <qpainter.h>
+using namespace std;
/*!
Constructors
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Operation QAD_Operation.h
\brief Base class for OCAF operations in QAD-based application.
// QT Include
#include <qapplication.h>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_OperatorMenus.h"
#include "QAD_Desktop.h"
+using namespace std;
/*!
Constructor.
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ParserSettings.h"
#include <stdio.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qtextstream.h>
+using namespace std;
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD.h"
#include "QAD_Popup.h"
#include "utilities.h"
+using namespace std;
/*****************************************************************************
** Class QAD_PopupClientServer
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_ResourceMgr QAD_ResourceMgr.h
\brief ResourceMgr QAD-based application.
#include <qfileinfo.h>
#include <Standard.hxx>
+using namespace std;
/* configuration file */
static const char* CONFIG_FILE = "config";
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Settings.h"
#include <stdio.h>
#include <qregexp.h>
#include <qstring.h>
#include <qtextstream.h>
+using namespace std;
/*!
Class QAD_Settings is a base class for different kind of settings
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_SpinBoxDbl.h"
#include <qpushbutton.h>
#include <qpainter.h>
#include <qpixmapcache.h>
#include <qapplication.h>
#include <limits.h>
+using namespace std;
//******************************************************************************
// QDblRangeControl class
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Splitter.h"
+using namespace std;
/*!
Constructs an horizontal splitter.
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Tools QAD_Tools.h
\brief Helpful functions for QAD.
#include <string.h>
#include <ctype.h>
#include <qstringlist.h>
+using namespace std;
static char* tempName()
{
// Module : SALOME
// $Header$
-using namespace std;
#define INCLUDE_MENUITEM_DEF
#include "QAD_Desktop.h"
#include <qaccel.h>
#include <qstringlist.h>
#include <qfileinfo.h>
+using namespace std;
map<int,QString> QAD_XmlHandler::_bibmap;
#include "SALOMEGUI.h"
#include "QAD_Desktop.h"
+using namespace std;
//=============================================================================
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_AboutDlg.h"
#include "QAD_Desktop.h"
#include "QAD_Tools.h"
#include <qlayout.h>
#include <qpixmap.h>
#include <qmessagebox.h>
+using namespace std;
/*
* Constructor
// Author : Michael Zorin (mzn)
// Module : SALOME
-using namespace std;
#include "SALOMEGUI_ActivateComponentDlg.h"
#include <qframe.h>
#include <qpushbutton.h>
#include <qlayout.h>
#include <qpixmap.h>
+using namespace std;
static const char* const default_icon[] = {
"48 48 17 1",
// Author : Vasily RUSYAEV (vrv)
// Module : SALOME
-using namespace std;
#include "SALOMEGUI_CloseDlg.h"
#include <qpushbutton.h>
#include <qlayout.h>
#include <qlabel.h>
#include <qmessagebox.h>
+using namespace std;
SALOMEGUI_CloseDlg::SALOMEGUI_CloseDlg ( QWidget * parent, const char * name, bool modal, WFlags f )
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_Desktop.h"
#include "SALOME_Selection.h"
#include "SALOME_ListIteratorOfListIO.hxx"
#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_ExternalBrowserDlg.h"
#include <qbuttongroup.h>
#include "QAD_FileDlg.h"
#include "QAD_Tools.h"
+using namespace std;
/*
* Constructs a modal SALOMEGUI_ExternalBowserDlg which is a child of 'parent'
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_ImportOperation.h"
+using namespace std;
SALOMEGUI_ImportOperation::SALOMEGUI_ImportOperation( QAD_Study* study ) :
QAD_Operation( study )
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_LoadStudiesDlg.h"
#include <qlabel.h>
#include <qlayout.h>
#include <qlistbox.h>
#include <qpushbutton.h>
+using namespace std;
#define SPACING_SIZE 6
#define MARGIN_SIZE 11
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_NameDlg.h"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include <qlineedit.h>
#include <qpushbutton.h>
#include <qlayout.h>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_OpenWith.h"
#include <qlabel.h>
#include <qpushbutton.h>
#include <qlayout.h>
#include <qlistbox.h>
+using namespace std;
#define SPACING_SIZE 6
#define MARGIN_SIZE 11
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_QtCatchCorbaException.hxx"
#include "utilities.h"
#include "QAD_Desktop.h"
#include "QAD_MessageBox.h"
+using namespace std;
void QtCatchCorbaException(const SALOME::SALOME_Exception & S_ex)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_SetValueDlg.h"
#include "QAD_Tools.h"
#include <qpushbutton.h>
#include <qlayout.h>
#include <qvalidator.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_SetupCurveDlg.h"
#include "QAD_Tools.h"
#include <qlayout.h>
#include <qtoolbutton.h>
#include <qgroupbox.h>
#include <qcolordialog.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_StudyPropertiesDlg.h"
#include "QAD_Desktop.h"
#include <qpushbutton.h>
#include <qlayout.h>
+using namespace std;
#define DEFAULT_MARGIN 11
#define DEFAULT_SPACING 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_TableDlg.h"
#include "QAD_Tools.h"
#include "QAD_MessageBox.h"
#include <qinputdialog.h>
#include <qlabel.h>
#include "utilities.h"
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_TrihedronSizeDlg.h"
#include <qbuttongroup.h>
#include <qpushbutton.h>
#include <qspinbox.h>
#include <qlayout.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_ViewChoiceDlg.h"
#include "QAD_Config.h"
#include "QAD_StudyFrame.h"
#include <qvariant.h>
#include <qtooltip.h>
#include <qwhatsthis.h>
+using namespace std;
/*
* Constructs a SALOMEGUI_ViewChoiceDlg which is a child of 'parent', with the
// File : SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOME_DataMapNodeOfDataMapOfIOMapOfInteger_HeaderFile
#include "SALOME_DataMapNodeOfDataMapOfIOMapOfInteger.hxx"
#endif
-
+using namespace std;
+
#define TheKey Handle_SALOME_InteractiveObject
#define TheKey_hxx "SALOME_InteractiveObject.hxx"
// File : SALOME_DataMapNodeOfDataMapOfIOMapOfInteger_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_DataMapNodeOfDataMapOfIOMapOfInteger.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger_HeaderFile
#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
#endif
+using namespace std;
SALOME_DataMapNodeOfDataMapOfIOMapOfInteger::~SALOME_DataMapNodeOfDataMapOfIOMapOfInteger() {}
// File : SALOME_DataMapOfIOMapOfInteger_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_DataMapOfIOMapOfInteger.hxx"
#ifndef _Standard_DomainError_HeaderFile
#ifndef _SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger_HeaderFile
#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
#endif
-
+using namespace std;
+
#define TheKey Handle_SALOME_InteractiveObject
#define TheKey_hxx "SALOME_InteractiveObject.hxx"
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_Filter.ixx"
+using namespace std;
// File : SALOME_ListIO_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListIO.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOME_ListNodeOfListIO_HeaderFile
#include "SALOME_ListNodeOfListIO.hxx"
#endif
-
+using namespace std;
+
#define Item Handle_SALOME_InteractiveObject
#define Item_hxx "SALOME_InteractiveObject.hxx"
// File : SALOME_ListIteratorOfListIO_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListIteratorOfListIO.hxx"
#ifndef _Standard_NoMoreObject_HeaderFile
#ifndef _SALOME_ListNodeOfListIO_HeaderFile
#include "SALOME_ListNodeOfListIO.hxx"
#endif
+using namespace std;
#define Item Handle_SALOME_InteractiveObject
// File : SALOME_ListIteratorOfListOfFilter_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListIteratorOfListOfFilter.hxx"
#ifndef _Standard_NoMoreObject_HeaderFile
#ifndef _SALOME_ListNodeOfListOfFilter_HeaderFile
#include "SALOME_ListNodeOfListOfFilter.hxx"
#endif
+using namespace std;
#define Item Handle_SALOME_Filter
// File : SALOME_ListNodeOfListIO_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListNodeOfListIO.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOME_ListIteratorOfListIO_HeaderFile
#include "SALOME_ListIteratorOfListIO.hxx"
#endif
+using namespace std;
SALOME_ListNodeOfListIO::~SALOME_ListNodeOfListIO() {}
// File : SALOME_ListNodeOfListOfFilter_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListNodeOfListOfFilter.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOME_ListIteratorOfListOfFilter_HeaderFile
#include "SALOME_ListIteratorOfListOfFilter.hxx"
#endif
+using namespace std;
SALOME_ListNodeOfListOfFilter::~SALOME_ListNodeOfListOfFilter() {}
// File : SALOME_ListOfFilter_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListOfFilter.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOME_ListNodeOfListOfFilter_HeaderFile
#include "SALOME_ListNodeOfListOfFilter.hxx"
#endif
+using namespace std;
#define Item Handle_SALOME_Filter
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_NumberFilter.ixx"
#include "SALOME_Selection.h"
#include "SALOME_InteractiveObject.hxx"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_Study.h"
+using namespace std;
SALOME_NumberFilter::SALOME_NumberFilter(NumberFilter TheKind, Standard_Integer aValue):
myKind(TheKind),
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_TypeFilter.ixx"
#include "SALOME_InteractiveObject.hxx"
+using namespace std;
SALOME_TypeFilter::SALOME_TypeFilter(const Standard_CString TheKind):
myKind(TheKind){}
#include "LocalTraceBufferPool.hxx"
#include "utilities.h"
+using namespace std;
+
// In case of truncated message, end of trace contains "...\n\0"
#define TRUNCATED_MESSAGE "...\n"
#define MAXMESS_LENGTH MAX_TRACE_LENGTH-5
-using namespace std;
-
LocalTraceBufferPool* LocalTraceBufferPool::_singleton = 0;
pthread_mutex_t LocalTraceBufferPool::_singletonMutex;
#include <sstream>
#include <cstdlib>
-using namespace std;
#include "LocalTraceBufferPool.hxx"
* thread waken up is not garanteed (no fifo or priority rules in Linux Kernel)
*/
-#define MESS_INIT(deb) ostringstream os; os<<deb
+#define MESS_INIT(deb) std::ostringstream os; os<<deb
#define MESS_BEGIN(deb) MESS_INIT(deb)<<__FILE__ <<" ["<<__LINE__<<"] : "
#define MESS_END endl; LocalTraceBufferPool::instance()->insert(NORMAL_MESS, os.str().c_str());
#define MESS_ABORT endl; LocalTraceBufferPool::instance()->insert(ABORT_MESS, os.str().c_str());
#define INFOS(msg) {MESS_BEGIN("- Trace ") << msg << MESS_END}
#define PYSCRIPT(msg) {MESS_INIT("---PYSCRIPT--- ") << msg << MESS_END}
#define INTERRUPTION(msg) {MESS_BEGIN("- INTERRUPTION: ")<< msg << MESS_ABORT}
-#define IMMEDIATE_ABORT(code) {cout <<flush; \
+#define IMMEDIATE_ABORT(code) {cout <<std::flush; \
cerr << "- ABORT " << __FILE__ << " [" <<__LINE__<< "] : " << flush; \
cerr << "ABORT return code= "<< code << endl; \
std::exit(code);}
#include <map>
#include <string>
+using namespace std;
+
static PyInterp_PyQt *interp = NULL;
static map<int,PyInterp_PyQt*> mapInterp;
// File : SalomePyQt.cxx
// Module : SALOME
-using namespace std;
#include "SalomePyQt.hxx"
#include <qapplication.h>
#include "QAD_Config.h"
#include "QAD_Settings.h"
+using namespace std;
QWidget* SalomePyQt::getDesktop()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SUPERVGraph.h"
#include "SUPERVGraph_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* SUPERVGraph::createView(QAD_RightFrame* parent)
{
// Author : Francis KLOSS
// Module : SALOME
-using namespace std;
#include "SUPERVGraph_Graph.h"
#include "QAD_Settings.h"
#include <qcolordialog.h>
#include <qpopupmenu.h>
+using namespace std;
SUPERVGraph_Graph::SUPERVGraph_Graph(QWidget* parent) :
// Module : SALOME
// $Header$
-using namespace std;
#include "SUPERVGraph_ViewFrame.h"
#include "QAD_Settings.h"
//QT Include
#include <qlayout.h>
#include <qcolordialog.h>
+using namespace std;
SUPERVGraph_View::SUPERVGraph_View(QWidget* theParent): QWidget(theParent){
init(theParent);
// Module : SALOME
// $Header$
-using namespace std;
#include <qapplication.h>
#include <qlabel.h>
#include "Utils_CorbaException.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SALOMEDS)
+using namespace std;
//=============================================================================
/*! SALOME_Session_QThread
#include "SALOME_Session_i.hxx"
#include "Session_ServerLauncher.hxx"
+using namespace std;
extern "C" int HandleSignals(QApplication *theQApplication);
#include <qapplication.h>
#include "CASCatch_SignalsHandler.h" // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+using namespace std;
extern "C" int HandleSignals(QApplication *theQApplication)
#include "Utils_SALOME_Exception.hxx"
#include "utilities.h"
+using namespace std;
//=============================================================================
/*!
#include <qthread.h>
#include <qwaitcondition.h>
-using namespace std;
class ServArg
{
PortableServer::POA_var _root_poa;
QMutex* _GUIMutex;
QWaitCondition *_ServerLaunch;
- list<ServArg> _argServToLaunch;
- vector<string> _argCopy;
- list<Session_ServerThread*> _serverThreads;
+ std::list<ServArg> _argServToLaunch;
+ std::vector<std::string> _argCopy;
+ std::list<Session_ServerThread*> _serverThreads;
};
#endif
#define _SESSION_SERVERTHREAD_HXX_
#include <CORBA.h>
-#include <string>
#include "SALOME_NamingService.hxx"
#include <qthread.h>
-using namespace std;
class Session_ServerThread
{
-using namespace std;
// File : SALOMEDS_Tool.cxx
// Created : Mon Oct 21 16:24:34 2002
// Author : Sergey RUIN
#include <sys/time.h>
#include <stdlib.h>
+using namespace std;
//============================================================================
// function : GetTempDir
// Module : SALOME
// $Header$
-using namespace std;
#include "ToolsGUI.h"
#include "ToolsGUI_CatalogGeneratorDlg.h"
#include "utilities.h"
#include <stdlib.h>
+using namespace std;
int ToolsGUI::runCommand(string & arg)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOME_TestComponent_i.hxx"
#include <stdio.h>
#include <cstdlib>
#include <map>
+using namespace std;
Engines_TestComponent_i::Engines_TestComponent_i(CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include <iostream>
#include <unistd.h>
#include <SALOMEconfig.h>
#include "SALOME_NamingService.hxx"
#include "OpUtil.hxx"
+using namespace std;
int main (int argc, char * argv[])
{
# include "Utils_SINGLETON.hxx"
#include "SALOME_NamingService.hxx"
#include "OpUtil.hxx"
+using namespace std;
int main (int argc, char * argv[])
{
// Module : SALOME
// $Header$
-using namespace std;
# include "Utils_CommException.hxx"
+using namespace std;
CommException::CommException( void ): SALOME_Exception( "CommException" )
{
throw SALOME::SALOME_Exception(ExDescription); \
}
-#include <ostream.h>
+#include <iostream>
//Dump the CORBA exception type.
-static ostream& operator<<(ostream& os, const CORBA::Exception& e)
+static std::ostream& operator<<(std::ostream& os, const CORBA::Exception& e)
{
CORBA::Any tmp;
tmp<<= e;
# include "Utils_DESTRUCTEUR_GENERIQUE.hxx"
# include "utilities.h"
+using namespace std;
+
void Nettoyage();
#ifdef _DEBUG_
static int MYDEBUG = 0;
#endif
-using namespace std;
-
static list<DESTRUCTEUR_GENERIQUE_*> *Destructeurs=0 ;
/*! \class ATEXIT_
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SALOME_Exception)
+using namespace std;
+
void SalomeException ()
{
throw SALOME_Exception("Salome Exception");
// Module : SALOME
// $Header$
-using namespace std;
#include <iostream>
#include "Utils_SALOME_Exception.hxx"
#include "utilities.h"
+using namespace std;
extern "C"
{
#include <math.h>
#include <signal.h>
#include "Utils_SignalsHandler.h"
+using namespace std;
//============================================================================
StoreSignalHandler(mySigHandlerCont,SIGTERM); // termination
StoreSignalHandler(mySigHandlerCont,SIGSEGV); // segmentation
//StoreSignalHandler(mySigHandlerCont,SIGABRT); // abort (ANSI).
- StoreSignalHandler(mySigHandlerCont,SIGSTKFLT); // stack fault.
+ // portage CCRT
+ // StoreSignalHandler(mySigHandlerCont,SIGSTKFLT); // stack fault.
}
// Module : SALOME
# include "Utils_Timer.hxx"
-# include <stream.h>
-using namespace std;
+# include <iostream>
#include "utilities.h"
+using namespace std;
static struct timezone *tz=(struct timezone*) malloc(sizeof(struct timezone));
#include <vtkUnstructuredGrid.h>
#include <vtkVoxel.h>
#include <vtkWedge.h>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
#include <vtkDataSet.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
+using namespace std;
vtkCxxRevisionMacro(SALOME_PassThroughFilter, "$Revision$");
vtkStandardNewMacro(SALOME_PassThroughFilter);
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
#include <vtkUnstructuredGrid.h>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
// Module : SALOME
// $Header$
-using namespace std;
#include "VTKViewer.h"
#include "VTKViewer_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* VTKViewer::createView(QAD_RightFrame* parent)
{
// Module : SALOME\r
\r
#include "VTKViewer_Filter.h"\r
+using namespace std;\r
\r
IMPLEMENT_STANDARD_HANDLE(VTKViewer_Filter, MMgt_TShared)\r
IMPLEMENT_STANDARD_RTTIEXT(VTKViewer_Filter, MMgt_TShared)\r
// $Header$
#include "VTKViewer_Prs.h"
+using namespace std;
//==========================================================
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "VTKViewer_RenderWindow.h"
#include "utilities.h"
#include "QAD_Settings.h"
#if QT_VERSION > 300
#include <qcursor.h>
#endif
+using namespace std;
VTKViewer_RenderWindow::VTKViewer_RenderWindow(QWidget *parent, const char *name) :
QWidget(parent, name,
#include "vtkObjectFactory.h"
#include "vtkPoints.h"
#include "vtkPolyData.h"
+using namespace std;
vtkCxxRevisionMacro(VTKViewer_VectorText, "$Revision$");
vtkStandardNewMacro(VTKViewer_VectorText);
